Lua

Cheat Engine comes with an extensive set of Lua functions you can use inside cheat tables, trainers and standalone scripts.

# Variables

## Globals

* TrainerOrigin: A variable that contains the path of the trainer that launched cheat engine (Only set when launched as a trainer)
* process: A variable that contains the main modulename of the currently opened process
* MainForm: The main Cheat Engine gui
* AddressList: The address list of the main Cheat Engine gui

## Variables

* Debug Variables
	+ EFLAGS
	+ **32/64-bit**: EAX, EBX, ECX, EDX, EDI, ESI, EBP, ESP, EIP
	+ **64-bit only**: RAX, RBX, RCX, RDX, RDI, RSI, RBP, RSP, RIP, R8, R9, R10, R11, R12, R13, R14, R15 : The value of the register

# Functions

## Cheat table

These functions help manage the cheat table.

* getAddressList: Returns the cheat table Addresslist object
* findTableFile: Returns a TableFile stored in the cheat table
* createTableFile: Add a new file to a cheat table
* loadTable: Loads a ".ct" or ".cetrainer" file or stream
* saveTable: Saves the current table

## Trainers

* registerEXETrainerFeature: Adds a new feature to the exe trainer generator window, and calls your function when the user builds an .exe trainer
* unregisterEXETrainerFeature: Unregisters the trainer feature

## Protection

* activateProtection: Prevents basic memory scanners from opening the cheat engine process
* enableDRM: Prevents normal memory scanners from reading the Cheat Engine process (kernelmode)
* encodeFunction: Converts a given function into an encoded string that you can pass on to decodeFunction
* decodeFunction: Converts an encoded string back into a function

## Scanning

These functions control Cheat Engine's scanning.

* AOBScan: Scans the currently opened process and returns a StringList object containing all the results
* getCurrentMemscan: Returns the currently active scan session as a MemScan object

## Process

* createProcess: Creates a process with or without debugging
* openProcess: Causes cheat engine to open the given processname or id
* onOpenProcess: Called by CE when it opens a process (userdefined)
* getForegroundProcess: Returns the process ID of the process that is currently on top
* getOpenedProcessID: Returns the currently opened process
* getProcessIDFromProcessName: Returns a processid
* openFileAsProcess: Causes cheat engine to open the file with memory access as if it's a process
* saveOpenedFile: Saves the changes of the opened file
* setPointerSize: Sets the size cheat engine will deal with pointers in bytes. (Some 64-bit processes can only use 32-bit addresses)
* setAssemblerMode: Sets the assembler's bit size mode (0=32-bit, 1=64-bit)
* getProcesslist: Returns a processlist of the system
* getWindowlist: Returns the top-window list of the system
* pause: Pauses the current opened process
* unpause: Resumes the current opened process
* targetIs64Bit: Returns true if the target process is 64-bit, false if 32-bit
* enumModules: Returns a table containing information about each module in the current process, or the specified process ID
* closeRemoteHandle: Closes the handle of a process

## Threads

* getCPUCount: Returns the number of CPU's
* getThreadlist: Fills a List object with the threadlist of the currently opened process
* inMainThread: Returns true if the current code is running inside the main thread (6.4+)
* synchronize: Calls the given function from the main thread. Returns the return value of the given function
* queue: Calls the given function from the main thread. Does not wait for the result
* checkSynchronize: Call this from an infinite loop in the main thread when using threading and synchronize calls

## Handles

* getHandleList: Returns a table with all the handles in the system

## Addresses

These functions help convert between memory addresses and symbols/CEAddressStrings.

* getAddress: Returns the address of a symbol. Can be a modulename or an export
* getAddressSafe: Returns the address of a symbol, or nil if not found. Similar to getAddress when errorOnLookup is false, but returns nil instead
* getNameFromAddress: Returns the given address in string form, returning the symbol representation if possible
* registerSymbol: Assign the specified symbolname to an address
* unregisterSymbol: Remove the name from the address
* getSymbolInfo: Returns a table as defined by the SymbolList class object (module name, search key, address, size)
* reinitializeSymbolhandler: Reinitializes the symbolhandler. E.g when new modules have been loaded
* inModule: Returns true if the given address is inside a module
* inSystemModule: Returns true if the given address is inside a system module
* getModuleSize: Returns the size of a given module (Use getAddress to get the base address)
* errorOnLookupFailure: Set whether address lookups will throw errors, or just return 0.
* registerSymbolLookupCallback: Registers a function to be called when a a symbol is parsed
* unregisterSymbolLookupCallback: Removes the callback
* registerAddressLookupCallback: Registers a function to be called when the name of an address is requested
* unregisterAddressLookupCallback: Removes the callback
* reinitializeDotNetSymbolhandler: Reinitializes only the DotNet part of the symbol list

## Memory

* allocateMemory: Allocates some memory into the target process
* deAlloc: Frees allocated memory
* allocateSharedMemory: Creates a shared memory object of the given size if it doesn't exist yet
* createSection: Creates a 'section' in memory
* mapViewOfSection: Maps the section to memory
* unMapViewOfSection: Unmaps a section from memory
* copyMemory: Copies memory from the given address to the destination address
* allocateKernelMemory: Allocates a block of nonpaged memory and returns the address
* freeKernelMemory: Frees the given memory region
* mapMemory: Maps a specific address to the usermode context from the given PID to the given PID
These functions read/write memory from the opened process.

### Reading

* readBytes: Returns the bytes at the given address. If ReturnAsTable is true it will return a table instead of multiple bytes
* readSmallInteger: Reads a 16-bit integer from the specified address.
* readInteger: Reads a 32-bit integer from the specified address.
* readQword: Reads a 64-bit integer from the specified address.
* readPointer: In a 64-bit target this equals readQword, in a 32-bit target readInteger().
* readFloat: Reads a single precision floating point value from the specified address
* readDouble: Reads a double precision floating point value from the specified address
* readString: Reads a string from memory until it hits a 0-terminator. maxlength is just so you won't freeze for too long
* readRegionFromFile: Writes the given file to a specific address

* readBytesLocal: See readBytes but then it's for Cheat engine's memory
* readSmallIntegerLocal: Reads a 16-bit integer from the specified address in CE's memory
* readIntegerLocal: Reads a 32-bit integer from the specified address in CE's memory
* readQwordLocal: Reads a 64-bit integer from the specified address in CE's memory
* readPointerLocal: ReadQwordLocal/ReadIntegerLocal depending on the cheat engine build
* readFloatLocal: Reads a single precision floating point value from the specified address in CE's memory
* readDoubleLocal: Reads a double precision floating point value from the specified address in CE's memory
* readStringLocal: Reads a string from CE's memory until it hits a 0-terminator

### Writing

* writeBytes: Write the given bytes to the given address from a table
* writeSmallInteger: Writes a 16-bit integer to the specified address. Returns true on success.
* writeInteger: Writes a 32-bit integer to the specified address. Returns true on success.
* writeQword: Write a 64-bit integer to the specified address. Returns true on success.
* writeFloat: Writes a single precision floating point to the specified address. Returns true on success.
* writeDouble: Writes a double precision floating point to the specified address. Returns true on success.
* writeString: Write a string to the specified address. Returns true on success.
* writeRegionToFile: Writes the given region to a file. Returns the number of bytes written.

* writeSmallIntegerLocal: Writes a 16-bit integer to the specified address in CE's memory. Returns true on success
* writeIntegerLocal: Writes a 32-bit integer to the specified address in CE's memory. Returns true on success
* writeQwordLocal: Writes a 64-bit integer to the specified address in CE's memory. Returns true on success
* writeFloatLocal: Writes a single precision floating point to the specified address in CE's memory. Returns true on success
* writeDoubleLocal: Writes a double precision floating point to the specified address in CE's memory. Returns true on success
* writeStringLocal: Write a string to the specified address. Returns true on success.
* writeBytesLocal: See writeBytes but then it's for Cheat Engine's memory

* + readSmallInteger, readInteger, readSmallIntegerLocal, readIntegerLocal can also have second boolean parameter. If true, value will be signed.

## Conversions

* ansiToUtf8: Converts a string in ANSI encoding to UTF8
* utf8ToAnsi: Converts a string in UTF8 encoding to ANSI
* stringToMD5String: Returns an MD5 hash string from the provided string
* integerToUserData: Converts a given integer to a userdata variable
* userDataToInteger: Converts a given userdata variable to an integer

### To Byte Table

* wordToByteTable: Converts a word to a bytetable
* dwordToByteTable: Converts a dword to a bytetable
* qwordToByteTable: Converts a qword to a bytetable
* floatToByteTable: Converts a float to a bytetable
* doubleToByteTable: Converts a double to a bytetable
* stringToByteTable: Converts a string to a bytetable
* wideStringToByteTable: Converts a string to a widestring and converts that to a bytetable

### From Byte Table

* byteTableToWord: Converts a bytetable to a word
* byteTableToDword: Converts a bytetable to a dword
* byteTableToQword: Converts a bytetable to a qword
* byteTableToFloat: Converts a bytetable to a float
* byteTableToDouble: Converts a bytetable to a double
* byteTableToString: Converts a bytetable to a string
* byteTableToWideString: Converts a bytetable to a widestring and converts that to a string

### Binary

* bOr: Binary Or
* bXor: Binary Xor
* bAnd: Binary And
* bShl: Binary shift left
* bShr: Binary shift right
* bNot: Binary not

## Input devices

These functions get/set keyboard/mouse input.

* getMousePos: Returns the *X* and *Y* coordinates of the mouse
* setMousePos: Sets the mouse position
* isKeyPressed: Returns true if the specified key is currently pressed
* keyDown: Causes the key to go into down state
* keyUp: Causes the key to go up
* doKeyPress: Simulates a key press
* mouse\_event: The Windows' API *"mouse\_event"*. msdn.microsoft.com/en-us/library/windows/desktop/ms646260(v=vs.85).aspx
* setGlobalKeyPollInterval: Sets the global keypoll interval
* setGlobalDelayBetweenHotkeyActivation: Sets the minimum delay between the activation of the same hotey in milliseconds

### Game Controller

* getXBox360ControllerState: Fetches the state of the connected XBox controller
* setXBox360ControllerVibration: Sets the speed of the left and right vibrating motor inside the controller

### Clipboard

* writeToClipboard: Writes the given text to the clipboard
* readFromClipboard: Reads the text from the clipboard

## Screen

* getScreenHeight: Returns the screen height
* getScreenWidth: Returns the screen width
* getWorkAreaHeight: Returns the work area height
* getWorkAreaWidth: Returns the work area width
* getScreenCanvas: Returns a Canvas object you can use to write to the screen (Note: Not as useful as you may think)
* getPixel: Returns the RGB value of the pixel at the specific screen coordinate

## Sounds

* playSound: Plays a sound file
* beep: Plays the fabulous beep/ping sound!
* speak: Speaks a given text using the given flags msdn.microsoft.com/en-us/library/speechplatform\_speakflags.aspx
* speakEnglish: Will try the English voice by wrapping the given text into an XML statement specifying the English voice

### xmplayer

* xmplayer\_playXM: Plays the given filename using the xmplayer
* xmplayer\_pause: Pauses the current xm audio file
* xmplayer\_resume: Resumes the current xm audio file
* xmplayer\_stop: Stops the current xm audio file
* xmplayer\_isPlaying: Returns true if there is currently an xm audio file being played

## Text to Speech

* speak: Speaks a given text.
* speakEnglish: Speaks a given text with English voice.

## Fonts

* loadFontFromStream: Loads a font from a memory stream and returns an id (handle) to the font for use with unloadLoadedFont
* unloadLoadedFont: Unloads a font from a memory stream

## Forms and Windows

* findWindow: Finds a window with the given classname and/or windowname
* getWindow: Gets a specific window based on the given window (Check MSDN getWindow for the command description)
* getWindowCaption: Returns the caption of the window
* getWindowClassName: Returns the classname of the window
* getWindowProcessID: Returns the processid of the process this window belongs to
* getForegroundWindow: Returns the windowhandle of the topmost window
* sendMessage: Sends a message to a window
* hookWndProc: Hooks a window's wndproc procedure
* unhookWndProc: Called when done with the hook from hookWndProc

## Cheat Engine

These functions help manage Cheat Engine itself.

* getCEVersion: Returns a floating point value specifying the version of cheat engine
* getCheatEngineFileVersion: Returns the full version data of the cheat engine version. A raw integer, and a table containing major, minor, release and build
* getFreezeTimer: Returns the Timer object responsible for freezing values
* getUpdateTimer: Returns the Timer object responsible for updating the value list
* getCommonModuleList: Returns the commonModuleList StringList object
* getCheatEngineProcessID: Returns the processid of cheat engine
* cheatEngineIs64Bit: Returns true if Cheat Engine is 64-bit, false if 32-bit
* closeCE: Closes Cheat Engine
* getAutoAttachList: Returns the AutoAttach StringList object
* connectToCEServer: Connects to the given host and port. On success, most commands subsequent will be handled by the server
* supportCheatEngine: Will show an advertising window which will help keep the development of Cheat Engine going.
* fuckCheatEngine: Removes the ad window if it was showing
* getCheatEngineDir: Returns the folder Cheat Engine (or the trainer) is located at.
* getComment: Gets the userdefined comment at the specified address
* setComment: Sets a userdefined comment at the specifried address
* getHeader: Gets the userdefined header at the specified address
* setHeader: Sets the userdefined header at the specified address
* registerBinUtil: Registers a binutils toolset with Cheat Engine
* reloadSettingsFromRegistry: This will cause cheat engine to reload the settings from the registry and apply them
* loadPlugin: Loads the given plugin
* getSettings: Returns a settings object

### Forms

* getFormCount: Returns the total number of forms assigned to the main CE application
* getForm: Returns the form at the specific index
* getMemoryViewForm: Returns the first Memoryview form class object
* getMainForm: Returns the first Mainform class object
* getSettingsForm: Returns the main settings form
* getLuaEngine: Returns the lua engine form object (Creates it if needed)
* unhideMainCEwindow: Shows the main Cheat Engine window
* hideAllCEWindows: Makes all normal Cheat Engine windows invisible (e.g trainer table)
* registerFormAddNotification: Registers a function to be called when a form is attached to Cheat Engine's form list
* unregisterFormAddNotification: unregister the FormAddNotification call back

### Messages

* showMessage: Shows a message box with the given text
* messageDialog: Pops up a message box
* outputDebugString: Outputs a message using the windows OutputDebugString message
* processMessages: Lets the main eventhandler process the new messages (allows for new button clicks)

### Input

* inputQuery: Shows a dialog where the user can input a string. This function returns the given string, or nil on cancel (CE6.4+)

### Shortcuts

* shortCutToText: Returns the textual representation of the given shortcut value (integer) (6.4+)
* textToShortCut: Returns an shortcut integer that the given string represents. (6.4+)
* convertKeyComboToString: Returns a string representation of the given keys like the hot-key handler does

### Speed Hack

* speedhack\_setSpeed: Enables the speed hack if it was not active yet and sets the given speed
* speedhack\_getSpeed: Returns the last set speed

## Lua

These functions help manage Lua itself.

* resetLuaState: This will create a new Lua state that will be used.
* sleep: Pauses for the number of specified milliseconds
* createRef: Integer - Returns an integer reference that you can use with getRef
* getRef: Returns whatever the reference points out
* destroyRef: Removes the reference

## Types

These functions help structure a process's memory into datatypes.

* onAutoGuess: Registers an function to be called whenever autoguess is used to predict a variable type.
* registerCustomTypeLua: Registers a custom type based on Lua functions.
* registerCustomTypeAutoAssembler: Registers a custom type based on an auto assembler script.

## Object-oriented

These functions determine how a Lua object fits in the class hierarchy.

* inheritsFromObject: Returns true if given any class
* inheritsFromComponent: Returns true if the given object inherits from the Component class
* inheritsFromControl: Returns true if the given object inherits from the Control class
* inheritsFromWinControl: Returns true if the given object inherits from the WinControl class

## Assembly

These functions help work with the x86 machine code as assembly.

* autoAssemble: Runs the auto assembler with the given text
* autoAssembleCheck: Checks the script for syntax errors. Returns true on succes, false with an error message on failure
* disassemble: Disassembles the given address and returns a string in the format of "address - bytes - opcode extra"
* splitDisassembledString: Returns 4 strings. The address, bytes, opcode and extra field
* getInstructionSize: Returns the size of an instruction
* getPreviousOpcode: Returns the address of the previous opcode (guess)
* registerAssembler: Registers a function to be called when the single line assembler is invoked to convert an instruction to a list of bytes
* unregisterAssembler: Unregisters the registered assembler

## Auto Assembler

* registerAutoAssemblerCommand: Registers an auto assembler command to call the specified function
* unregisterAutoAssemblerCommand: Unregisters an auto assembler command
* registerAutoAssemblerPrologue: Registers a function to be called when the auto assembler is about to parse an auto assembler script
* unregisterAutoAssemblerPrologue: Unregisters an auto assembler prologue
* fullAccess: Changes the protection of a block of memory to writable and executable

### Scripts

* registerAutoAssemblerTemplate: Registers a template for the auto assembler
* unregisterAutoAssemblerTemplate: Unregisters a template for the auto assembler
* generateCodeInjectionScript: Adds a default code injection script to the given script
* generateAOBInjectionScript: Adds an AOB injection script to the given script
* generateFullInjectionScript: Adds a Full Injection script to the given script
* generateAPIHookScript: Generates an auto assembler script which will hook the given address when executed

## Debugger

These functions manage the debugger. See *Lua Debugging*.

* debug\_isDebugging: Returns true if the debugger has been started
* debug\_getCurrentDebuggerInterface: Returns the current debuggerinterface used (1=windows, 2=VEH 3=Kernel, nil=no debugging active)
* debug\_canBreak: Returns true if there is a possibility the target can stop on a breakpoint. 6.4+
* debug\_isBroken: Returns true if the debugger is currently halted on a thread
* debug\_getBreakpointList: Returns a lua table containing all the breakpoint addresses
* debugProcess: Debugs the currently attached process
* debug\_setBreakpoint: Sets a breakpoint of a specific size at the given address
* debugger\_onBreakpoint: Called by CE when a breakpoint hits (userdefined)
* debug\_removeBreakpoint: Removes a breakpoint
* debug\_continueFromBreakpoint: Continues the debugger when it's halted on a breakpoint
* debug\_setLastBranchRecording: Tells the kernelmode debugger to record the last few branches before the breakpoint got hit
* debug\_getMaxLastBranchRecord: Returns the maximum number of branch records this cpu supports
* debug\_getLastBranchRecord: Returns the value of the Last Branch Record at the given index (when handling a breakpoint)
* debugger\_onModuleLoad: Called by CE when the windows debugger interface loads a module (userdefined)
* debug\_getContext (since 6.5): Force-update the Lua variables representing the registers?
* debug\_setContext (since 6.5[1]): Force-update the registers to the Lua variables which represent them?
* debug\_updateGUI: Will refresh the userinterface to reflect the new context if the debugger was broken
* detachIfPossible: Detaches the debugger from the target process (if it was attached)
* debug\_addThreadToNoBreakList: This will cause breakpoints on the provided thread to be ignored
* debug\_removeThreadFromNoBreakList: removed the threadid from the list
* debug\_getXMMPointer: Returns the address of the specified xmm register of the thread that is currently broken
* debugger\_onModuleLoad: This routine is called when a module is loaded. Only works for the windows debugger

## DBK

* dbk\_initialize: Loads the DBK driver into memory if possible
* dbk\_useKernelmodeOpenProcess: Switches the internal pointer of the OpenProcess api to dbk\_OpenProcess
* dbk\_useKernelmodeProcessMemoryAccess: Switches the internal pointer to the ReadProcessMemory and WriteProcessMemory apis to dbk\_ReadProcessMemory and dbk\_WriteProcessMemory
* dbk\_useKernelmodeQueryMemoryRegions: Switches the internal pointer to the QueryVirtualMemory api to dbk\_QueryVirtualMemory
* dbk\_getPEProcess: Returns the pointer of the EProcess structure of the selected processid
* dbk\_getPEThread: Gets the pointer to the EThread structure of a threadid
* dbk\_readMSR: Reads the msr using the dbk driver
* dbk\_writeMSR: Writes the msr using the dbk driver
* dbk\_executeKernelMemory: Executes a routine from kernelmode (e.g a routine written there with auto assembler)
* dbk\_getCR0: Returns Control Register 0
* dbk\_getCR3: Returns Control Register 3 of the currently opened process
* dbk\_getCR4: Returns Control Register 4
* dbk\_getPhysicalAddress: Returns the physical address of the given address
* dbk\_writesIgnoreWriteProtection: Set to true if you do not wish to initiate copy-on-write behaviour

## DBVM

* dbvm\_initialize: Initializes the dbvm functions
* dbvm\_addMemory: Adds memory to DBVM
* dbvm\_readMSR: Reads the msr using dbvm (bypasses the driver)
* dbvm\_writeMSR: Writes the msr using dbvm (bypasses the driver)
* dbvm\_getCR4: Returns the real Control Register 4 state
* dbvm\_readPhysicalMemory: Reads physical memory using DBVM
* dbvm\_writePhysicalMemory: Writes physical memory using DBVM
* dbvm\_watch\_writes: Starts memory region write monitoring
* dbvm\_watch\_reads: Starts memory region read monitoring
* dbvm\_watch\_retrievelog: Receives the result of memory region monitoring
* dbvm\_watch\_disable: Disables memory region monitoring
* dbvm\_cloak\_activate: Cloak a page so changes to it will become invisible
* dbvm\_cloak\_deactivate: Undo the cloak. Also undoes changes
* dbvm\_cloak\_readOriginal: Read the memory that gets executed in a cloaked region
* dbvm\_cloak\_writeOriginal: Writes the memory that gets executed in a cloaked region
* dbvm\_changeregonbp : Cloaks and sets a breakpoint at the given address and change registers when executed
* dbvm\_removechangeregonbp: Removes a change reg on bp breakpoint
* dbvm\_log\_cr3\_start : Start logging CR3 values
* dbvm\_log\_cr3\_stop : Stop logging CR3 values
* dbvm\_speedhack\_setSpeed : sets the systemwide speedhack
* dbvm\_setTSCAdjust : Lets you specify what happens when a program tries to detect a virtual machine by calling rdtsc

## Translation

* getTranslationFolder: Returns the path of the current translation files, empty if there is no translation going on
* loadPOFile: Loads a *".PO"* file used for translation
* translate: Returns a translation of the string, returns the same string if it can't be found
* translateID: Returns a translation of the string ID

## Files

* getFileVersion: Returns the 64-bit file version, and a table that has split up the file version into major, minor, release and build
* getFileList: Returns an indexed table with filenames
* getDirectoryList: Returns an indexed table with directory names

## Structures

* registerStructureDissectOverride: same as onAutoGuess, but is called by the structure dissect window when the user chooses to let cheat engine guess the structure for them
* unregisterStructureDissectOverride: unregisters the structure dissect auto guess override
* registerStructureNameLookup: Registers a function to be called when dissect data asks the user for the name of a new structure define
* unregisterStructureNameLookup:

## Miscellaneous

* injectDll: Injects a dll
* shellExecute: Executes a given command
* executeCode: Executes a stdcall function with 1 parameter at the given address in the target process and wait for it to return
* executeCodeEx:
* executeCodeLocal: Executes a stdcall function with 1 parameter at the given address in the target process
* executeCodeLocalEx:
* onAPIPointerChange: Registers a callback when an api pointer is changed
* setAPIPointer: Sets the pointer of the given api to the given address
* md5memory: Returns a md5 sum calculated from the provided memory
* md5file: Returns a md5 sum calculated from the file
* getSystemMetrics: Retrieves the specified system metric or system configuration setting msdn.microsoft.com/en-us/library/windows/desktop/ms724385.aspx
* getTickCount: Returns the current tickcount since windows was started. Each tick is one millisecond
* getUserRegistryEnvironmentVariable: Returns the environment variable stored in the user registry environment
* setUserRegistryEnvironmentVariable: Sets the environment variable stored in the user registry environment
* broadcastEnvironmentUpdate: Call this when you've changed the environment variables in the registry
* getApplication: Returns the application object (the titlebar)
* getInternet: Returns an internet class object. The string provided will be the name of the client provided

# Classes

Besides the above functions, Cheat Engine also implements some classes.

* Addresslist: The addresslist class is a container for memory records
* Bitmap: Bitmap based Graphic object
* Brush: The brush class is part of the Canvas object. It's used to fill surfaces
* Button: The button class is a visual component in the shape of a button.
* ButtonControl: Common ancestor of several button like objects.
* Canvas: The canvas class is a graphical class. It allows you do draw lines, pictures, and text on top of other object. Usually used in onPaint events and other graphical events
* CheatComponent: The cheatcomponent class is the component used in Cheat Engine 5.x trainers
* CheckBox: The Checkbox is a visual component that lets the user click it and change state between checked, unchecked, and if possible, grayed
* Component : Base class for all components that need owner-owned functionality.
* Control : Base class for visible controls.
* Collection: The Collection class is an abstract class that the ListColumns class implements (And perhaps other classes as well)
* CollectionItem: Basic object that is managed by a Collection class
* ComboBox: The Combobox is like an edit field with a ListBox attached to it
* CriticalSection:
* CustomControl: Base class for windowed controls which paint themselves
* CustomType: The custom type is an convertor of raw data, to a human readable interpretation.
* D3DHOOK: The d3dhook functions provide a method to render graphics and text inside the game, as long as it is running in directx9, 10 or 11
* D3DHook\_FontMap: A fontmap is a texture that contains extra data regarding the characters
* D3DHook\_Texture: This class controls the texture in memory. Without a sprite to use it, it won't show
* D3Dhook\_TextContainer: A d3dhook\_sprite class draws a piece of text on the screen based on the used fontmap
* D3DHook\_RenderObject: The renderobject is the abstract class used to control in what manner objects are rendered.
* D3DHook\_Sprite: A d3dhook\_sprite class is a visible texture on the screen
* Disassembler:
* Disassemblerview: The visual disassembler used in the memory view window
* Edit: The Edit class is a visual component that lets the user type in data (Use control\_getCaption to get the user input)
* Event:
* FileStream: The FileStream class is a Stream class that is linked to an open file on disk
* Font: Class that defines a font
* Form: Class that defines a window
* FoundList: The foundlist is an companion class to MemScan. It opens the current memscan's result file and provides an interface for reading out the addresses
* GenericHotkey: Lets you register hotkeys to Cheat Engine's internal hotkey handler
* Graphic: Base class for dealing with Graphic images (Abstract)
* GraphicControl: Class that supports simple lightweight controls that do not need the ability to accept keyboard input or contain other controls.
* GroupBox: The groupbox class is like a Panel, but then has a header on top
* Hexadecimal: The visual hexadecimal object used on the memory view window
* Hexadecimalview: The visual hexadecimal object used on the memory view window
* Icon:
* Image: The Image class is a visual component that lets you show an image
* Label: The Label class is a visual component that lets you display text
* LuaPipe: Abstract class that LuaPipeServer and LuaPipeclient inherit from
* LuaPipeClient: Class implementing a client that connects to a pipe
* LuaPipeServer: Class launching the server side of a pipe
* ListBox: The listbox class is a visual component with a list of selectable strings
* ListColumn: The listcolumn class is an implemented CollectionItem class which is used by the ListColumns class of the listview class
* ListColumns: The ListColumns class contains the Column class objects of a ListView object
* ListItem: The ListItem class object is an entry in a ListView
* ListItems: The listItems class is a container for the ListItem class objects of a Listview
* Listview: The listview class lets you have a listbox like component with resizable columns
* MainMenu: The menu at the top of a form
* Memo: The Memo class is a multiline edit field
* MemScan: The memscan class is the memory scanner of Cheat engine
* Menu: Common Class ancestor for the MainMenu and PopupMenu classes
* MenuItem: Holds the menuitems of a Menu, PopupMenu or even another MenuItem
* MemoryRecord: The Memoryrecord class object describes a Cheat Table's Cheat Entry.
* MemoryRecordHotkey: The memoryRecordHotkey class object is part of a MemoryRecord class. It's used as an interface to each individual hotkey inside a Cheat Table
* MemoryStream: The memorystream class is a Stream class that is stored completely in memory. Because it's a stream there are multiple functions that can work with it
* Memoryview: The memoryview class is the Memory view window of Cheat Engine. Use this as a basis to access the objects inside this window
* MultiReadExclusiveWriteSynchronizer:
* Object: Most basic class. All classes inherit from this class
* PaintBox:
* PageControl: This is an object that can hold multiple pages
* Panel: The Panel class is like a form which can contain visual components.
* Pen: The Pen class is part of the Canvas object. It's used to draw lines
* Picture: Container for the Graphic class
* PopupMenu: The menu that shows when rightclicking on an object
* PortableNetworkGraphic:
* ProgressBar: The progressbar class is a visual representation for a bar that can show the current progress on something
* RadioGroup: The radiogroup is like a GroupBox but autopopulated using the Items(Strings object)
* RasterImage: Base class for some graphical controls
* RIPRelativeScanner:
* OpenDialog: The OpenDialog class is used for selecting files to open.
* SaveDialog: The SaveDialog class is based on the OpenDialog class but is used to select a file for saving
* Settings: This class can be used to read out and set settings of cheat engine and of plugins, and store your own data
* Splitter: The Splitter class is a visual component that lets the user re-size neighboring components)
* Stringlist: Class that holds a list of strings
* Strings: Abstract class that some text based classes make use of
* SymbolList: This class can be used to look up an address to a symbolname, and a symbolname to an address
* TabSheet: Part of a page control
* TableFile: Tablefiles are files stored into a Cheat Table. You can access the data of such a file using this class
* Thread:
* Timer: The timer class is an non visual component that when active triggers an onTimer event every few milliseconds, based on the given interval
* ToggleBox: The togglebox is like a button, but can stay down. Use with the checkbox methods
* TrackBar: The trackbar class is a slider you can drag arround and read/set the state
* WinControl: Base class for controls which can contain other controls.
* xmplayer:

## Class Helper Functions

* inheritsFromObject: Returns true if given any class
* inheritsFromComponent: Returns true if the given object inherits from the Component class
* inheritsFromControl: Returns true if the given object inherits from the Control class
* inheritsFromWinControl: Returns true if the given object inherits from the WinControl class
* createClass: Creates an object of the specified class (Assuming it's a registered class and has a default constructor)
* createComponentClass: Creates an object of the specified component inherited class

## Undefined Class Property Functions

Not all properties of all classes have been explicitly exposed to lua, but if you know the name of a property of a specific class you can still access them (assuming they are declared as published in the pascal class declaration)

* getPropertyList: Returns a StringList object containing all the published properties of the specified class
* setProperty: Sets the value of a published property of a class (Won't work for method properties)
* getProperty: Gets the value of a published property of a class (Won't work for method properties)
* setMethodProperty: Sets the method property to the specific function
* getMethodProperty: Returns a function you can use to call the original function