Perfecto. Mira, veo que eres el primer usuario que se ha leido mi tutorial de CE (al menos eres el primero en postear aquí exponiendo tus dudas), así que te voy a mandar deberes

Te dejo el link de un videojuego para que le apliques un hack. Se llama Maldita Castilla. Es un juego gratuito, ocupa pocos MegaBytes y se puede jugar sin necesidad de instalar nada en tu PC



Primero de todo descarga el juego de su web oficial http://www.locomalito.com/maldita_castilla.php (el link está abajo del todo). Lo que te pido es que consigas hacer un cheat para evitar que el personaje muera al recibir golpes. Básicamente lo que debes conseguir es encontrar la dirección de tu Salud/Vida y forzarlo siempre a 3 (valor máximo).

Puedes hacerlo de 2 formas. O encuentras el pointer de la salud del personaje o escribes un AA script para inyectar el valor 3 a la dirección de tu salud cada vez que recibas un golpe.

Suerte!!

https://mega.co.nz/#!LYV30RAB!bUUSUnvyEJ7xeFdNw8pUXC4lZOR7KizQoMUxt7ikin0

https://mega.co.nz/#!ycVzSRwI!bzp-AmaiLgkCMe3Ze881gx1nfjZGCpG2WvVp4HMiqDU

Pues sintiéndolo mucho, no tengo ni idea Al parecer 0xFF, 0xFF, 0xFF, 0xFF, 0x51, 0x55, 0xFC, 0x11 se traduce como aobscan(FF FF FF 51 55 FC 11) y supongo que la función devuelve la dirección encontrada. Deberías hacer pruebas o preguntar en ese mismo hilo (yo no tengo ni idea de C).

De todas fromas, porqué quieres hacer el trainer en C? CE trae su propio intérprete LUA para generar trainers, en el foro de CE hay muchísimos ejemplos sobre como generar trainers con CE LUA, pudiendo llamar a las funciones internas de aobscan de forma sencilla.

Por cierto, has probado de hacer el aobscan "manual" como te he explicado? Es la forma más sencilla para ver como funciona.

[ USAGE ] ------------------------------------------------------------------------------
//
// Examples:
//
//      SigScan _sigScan = new SigScan();
//      _sigScan.Process = someProc;
//      _sigScan.Address = new IntPtr(0x123456);
//      _sigScan.Size = 0x1000;
//      IntPtr pAddr = _sigScan.FindPattern(new byte[]{ 0xFF, 0xFF, 0xFF, 0xFF, 0x51, 0x55, 0xFC, 0x11 }, "xxxx?xx?", 12);
//
//      SigScan _sigScan = new SigScan(someProc, new IntPtr(0x123456), 0x1000);
//      IntPtr pAddr = _sigScan.FindPattern(new byte[]{ 0xFF, 0xFF, 0xFF, 0xFF, 0x51, 0x55, 0xFC, 0x11 }, "xxxx?xx?", 12);
// 

http://forum.cheatengine.org/viewtopic.php?p=5243058&sid=a83fb95aee8be17a7442f61861e3b004

Haz lo siguiente, ejecuta tu programa y el CE (sin mi tabla, ejecuta el CE completamente vacío).

1. Busca y encuentra la dirección con tu variable
2. Haz click derecho "Find out what writes to this address"
3. Pulsa el botón de sumar, aparecerá la instrucción:

002A06BE - FF 80 4C010000  - inc [eax+0000014C]

4. Pulsa en Show Disassembler
6. Aparece la instrucción, haz click drecho y copia los bytes:



7. Vuelve a la ventana principal de CE, pulsa NEW SCAN, Value Type -> Array of Byte
8. En la caja de texto pulsa Ctrl+V y dale a buscar:



Como ves, esa es la forma "manual" de usar AOBSCAN(), CE nos devuelve una dirección solamente (002A06BE) que curiosamente se corresponde al offset de mi instrucción:

002A06BE - FF 80 4C010000  - inc [eax+0000014C]

---------------------------------

Para automatizar todo esto en un script, se realiza llamando a la función aobscan(), digamos que mi script hace esos pasos anteriores de forma automática y sin que te enteres

---------------------------------

Aobscan() es una función interna de CE, no existe equivalente en C o VB, deberías de programarlo tu con las APIs ReadProcessMemory, supongo.

Bueno, he estado revisando tu programa.

El problema parece ser que es debido a Framework, como ya sabes, todos los programas creados con Visual Studio son interpretados por una VM, en VB6 la VM es MSVBVM60.DLL, en las versiones posteriores son ejecutados por las librerías y dependencias Framework.

Después de estar revisando un poco el ejecutable, las operaciones de incrementar o restar son ejecutadas evidentemente por la VM de VisualStudio (Framework), dichas librerías ejecutan y procesan el código a su manera, realmente no entiendo como demonios funciona internamente, lo que sí es seguro es que los punteros son asignados en espacios de memoria de forma aleatoria.

Cuando ejecuto tu programa, puedo encontrar el pointer (puntero) asignado a tu variable. Después de incrementar el valor, la variable "salta" y se almacena en otra dirección de memoria nueva (ésto es MUY raro y jamás lo había visto, es por culpa del maldito Framework), curiosamente, el pointer que he encontrado es capaz de seguir ese "salto" y continua mostrando el valor correcto de tu variable.

El problema viene aquí: Cuando ejecuto de nuevo el programa, el pointer que había encontrado antes ya no sirve (ésto es la primera vez que lo veo). He usado el pointer-scanner para comprobar si son punteros de multi-nivel, pero no es el caso.

También he probado de crear un AA script, funciona correctamente, pero cuando reinicio el programa, Framework interpreta el código de alguna forma extraña y deja inservible el AA script.

____________________________________

Mi conclusión es que Framework nos está jugando una mala pasada. Por alguna razón, cuando ejecutas el programa, asigna sus funciones en un rango aleatorio de la memoria (offsets). Con el resto de ejecutables que he trabajado, las variables se asignan de forma aleatoria, pero sus pointers y funciones (offsets) siempre ocupan la misma dirección relativa. Me explico:

Ejecuto por primera vez tu programa, tras encontrar la dirección, Framework hace lo siguiente:

003D06BE - FF 80 4C010000        - inc [eax+0000014C]

003D06BE = Es el offset encargado de incrementar tu variable
inc = Es la instrucción ASM que incrementa
[eax+0000014C] = La dirección de memoria con tu variable

La segunda vez que ejecuto tu programa ocurre lo siguiente:

005806BE - FF 80 4C010000        - inc [eax+0000014C]

El offset ha cambiado pasando de 003Dxxxx -> 0058xxxx, pongo la mano en el fuego que el culpable de éste cambio sin-sentido es debido al Framework.

Lamentablemente no puedo darte una solución a tu problema Deberíamos mover tu pregunta al foro oficial de CheatEngine, a ver si alguien puede lanzar un poco de luz a éste problema

__________________________________________

EDIT

Estoy revisando más a fondo tu problema. Parece ser que la función AOBSCAN() se puede encontrar el offset exacto que realiza el incremento para luego hacer una inyección de código o incluso dumpear la dirección de memoria donde se almacena tu variable.

El problema es que no soy muy experto en usar el AOBSCAN() bajo CE, estoy haciendo pruebas, pero creo que se puede conseguir

001D072A - 90 - nop 
001D072B - 8B 45 F8  - mov eax,[ebp-08]
001D072E - FF 80 4C010000  - inc [eax+0000014C] <<
001D0734 - 8B 45 F8  - mov eax,[ebp-08]
001D0737 - 8B 80 40010000  - mov eax,[eax+00000140]

EAX=025A391C
EBX=025C80D8
ECX=025A391C
EDX=025C7238
ESI=025C7238
EDI=0267C32C
ESP=0034EEF8
EBP=0034EF08
EIP=001D0734