Help File:Auto Assembler help

Auto Assembler help

Auto assemble allows you to write assembler code at different locations using a script. It can be found in the 'memory view' part of cheat engine under extra.

There are 3 special commands you can give it, ALLOC , LABEL and FULLACCESS. With LABEL you can give a address a name by declaring it before you use it. ALLOC is basicaly the same as LABEL but allocates some memory for you.

Usage:

LABEL(labelname) 

Enables the word labelname to be used as a address

ALLOC(allocname,sizeinbytes, preferedregion OPTIONAL) 

same as label, but allocates the memory it points to itself

DEALLOC(allocname) 

Deallocates a block of memory allocated with alloc. It always gets executed last, no matter where it is positioned in the code, and only actually frees the memory when all allocations have been freed. only usable in a script designed as cheattable. (e.g used for the disable cheat)

FULLACCESS(address,size)

makes a memory region at the specified address and at least "size" bytes readable, writable and executable

REGISTERSYMBOL(symboname) 

adds the symbol to the userdefined symbol list so cheattables and the memory browser can use that name instead of a address (The symbol has to be declared in the script when using it)

UNREGISTERSYMBOL(symbolname) 

removes the symbol from the userdefined symbol list. It won't give a error if it isn't found

DEFINE(name,whatever) 

Will replace all tokens with the specified name with the text of whatever

INCLUDE(filename) 

includes another auto assembler file at that spot

LOADBINARY(address,filename) 

Will load a binary file at the specified address

CREATETHREAD(address) 

Will spawn a thread in the process at the specified address

LOADLIBRARY(filename) 

Will inject the specified dll into the target process

READMEM(address,size) 

Will write the addresses at address at the location this instruction is placed

GLOBALALLOC(name,size) 

Will allocate a certain amount of memory and registers the specified name. Using GlobalAlloc in other scripts will then not allocate the memory again, but reuse the already existing memory. (Or allocate it anyhow if found it was not allocated yet)

ASSERT(address, array of byte) 

Will check the memory address for the given address. If the memory is not what is defined by the array of byte given, the auto assemble script will not execute.

AOBSCAN(name, array of byte) 

Will scan the memory for the given array of byte (Wildcards are supported) and replaces all tokens with the specified name with the address the array of byte was found. If it's not found, the auto assemble script will not execute

AOBSCANMODULE(name, modulename, array of byte) 

Will scan the specific module for the given AOB

AOBSCANREGION(name, startaddress, stopaddress, array of byte) 

Will scan the specific range for the given AOB

STRUCT / ENDSTRUCT 

With STRUCT you can define an internal structure in your auto assembler script. This can be used to keep your code clear.

Example:

 STRUCT stackview
 returnaddress: DD ?
 param1:
   DD ?
 param2: DB ? ? ? ?
 ENDSTRUCT
 
 mov eax,[EBP+stackview.param1]
 mov ebx,[EBP+param2]

{$LUA}/{$ASM} 

Code between {$LUA} and {$ASM} (separate lines) will execute that lua script. If it returns a string, the result will be handled as an auto assembler commands.

Note: The lua code is executed before anything else of the auto assembler is parsed.

Value notation: Normally everything is written as hexadecimal in auto assembler, but there are ways to override this so you can input decimal values, and even floating point values. for example, a integer value of 100 can be written in hex as 64, but you can also write it as #100, or as (int)100 for floating point value like 100.1 you can use (float)100.1
and for a double, you could use (double)100.1

Basic Example:

 00451029:
 jmp 00410000
 nop
 nop
 nop

00410000:

 mov [00580120],esi
 mov [esi+80],ebx
 xor eax,eax
 jmp 00451031

Example using LABEL:

 label(mylabel)

 00451029:
 jmp 00410000
 nop
 nop
 nop
 mylabel:

 00410000:
 mov [00580120],esi
 mov [esi+80],ebx
 xor eax,eax
 jmp mylabel

Example using ALLOC:

 alloc(memloc1,4)

 00451029:
 jmp 00410000
 nop
 nop
 nop

 00410000:
 mov [alloc1],esi
 mov [esi+80],ebx
 xor eax,eax
 jmp 00451031

Example using ALLOC and LABEL:

 alloc(alloc1,4)
 label(mylabel)

 00451029:
 jmp 00410000
 nop
 nop
 nop
 mylabel:

 00410000:
 mov [alloc1],esi
 mov [esi+80],ebx
 xor eax,eax
 jmp mylabel

Example using FULLACCESS:

 FULLACCESS(00400800,4) // 00400800 is usually read only non executable data, this makes it writeable and executable
 00451029:
 jmp 00410000
 nop
 nop
 nop

 00410000:
 mov [00400800],esi
 mov [esi+80],ebx
 xor eax,eax
 jmp 00451031

Example using DEFINE:

 DEFINE(clear_eax,xor eax,eax)
 00400500:
 clear_eax

ReadMem example:

 alloc(x,16)
 alloc(script,2048)

 script:
 mov eax,[x]
 mov edx,[x+c]
 ret

 x:
 readmem(00410000,16) // place the contents of address 00410000 at the address of X

The absolute best way to learn these is by practical use. So for a start, follow the tutorial program all the way through and then apply it to some games. The more you use it, the quicker and more capable you will become with it. It looks daunting at first sight (like a coding language), but if you're serious about gamehacking, this will soon become your new best friend!