TFRMPOINTERSCANNERSETTINGS.CAPTION=Pointerscanner scanoptions
TFRMPOINTERSCANNERSETTINGS.CBVALUETYPE.TEXT=4 Byte
TFRMPOINTERSCANNERSETTINGS.RBFINDADDRESS.CAPTION=Scan for address
TFRMPOINTERSCANNERSETTINGS.RBFINDVALUE.CAPTION=Scan for addresses with value
TFRMPOINTERSCANNERSETTINGS.RBGENERATEPOINTERMAP.CAPTION=Generate pointermap
TFRMPOINTERSCANNERSETTINGS.CBUSELOADEDPOINTERMAP.HINT=Use this if you have created a pointermap on a system that runs the game, but you wish to do the scan on another system (or multiple systems).
Checking this option will open a dialog where you can select the pointermap
TFRMPOINTERSCANNERSETTINGS.CBUSELOADEDPOINTERMAP.CAPTION=Use saved pointermap
TFRMPOINTERSCANNERSETTINGS.CBCOMPARETOOTHERPOINTERMAPS.HINT=When ticked you can add other pointermaps which will be used to verify that the pointers it finds are correct. You will have to fill in the correct address for each pointermap you provide.
Note: expect at least the size of the game itself in memory for every pointermap used

TFRMPOINTERSCANNERSETTINGS.CBCOMPARETOOTHERPOINTERMAPS.CAPTION=Compare results with other saved pointermap(s)
TFRMPOINTERSCANNERSETTINGS.CBSHOWADVANCEDOPTIONS.CAPTION=Show advanced options
TFRMPOINTERSCANNERSETTINGS.CBINCLUDESYSTEMMODULES.CAPTION=Include system modules
TFRMPOINTERSCANNERSETTINGS.CBHEAPONLY.HINT=If the address you search for isn't a heap address, the scan will return 0 results
TFRMPOINTERSCANNERSETTINGS.CBHEAPONLY.CAPTION=Only allow static and heap addresses in the path
TFRMPOINTERSCANNERSETTINGS.CBUSEHEAPDATA.HINT=When this is checked the heap is used to figure out the offset sizes, instead of blindly guessing them.
pro: Greatly improve speed and a lot less useless results
con: if the game allocates gigantic chunks of heap memory, and then divides it up itself, this will give wrong results.

In other cases this will give perfect pointers 
TFRMPOINTERSCANNERSETTINGS.CBUSEHEAPDATA.CAPTION=Improve pointerscan with gathered heap data
TFRMPOINTERSCANNERSETTINGS.LABEL13.CAPTION=Pointer path may only be inside this region:
TFRMPOINTERSCANNERSETTINGS.CBONLYONESTATIC.HINT=When the pointerscanner goes through the list of pointervalues with a specific value, this will stop exploring other paths as soon as it encounters a static pointer to that value

pro: Fast
con: You may miss some valid results 
TFRMPOINTERSCANNERSETTINGS.CBONLYONESTATIC.CAPTION=Stop traversing a path when a static has been found
TFRMPOINTERSCANNERSETTINGS.CBNOREADONLY.HINT=When checked the pointerscan will throw away memory that is readonly. So when it looks for paths, it won't encounter paths that pass through read only memory blocks.

When it's unchecked, it does include readonly memory


pro: faster, less useless results
con: If the game decides to mark a pointer as readonly ce won't find it 
TFRMPOINTERSCANNERSETTINGS.CBNOREADONLY.CAPTION=Don't include pointers with read-only nodes
TFRMPOINTERSCANNERSETTINGS.CBSTATICONLY.HINT=When checked the pointerscan will only store a path when it starts with a static address. (or easily looked up address)
When it's disabled, it finds every single pointer path

pro: Fast
con: It may miss pointers that are accessed by special paths like thread local storage. (but even then they'd be useless for ce as they will change)
TFRMPOINTERSCANNERSETTINGS.CBSTATICONLY.CAPTION=Only find paths with a static address
TFRMPOINTERSCANNERSETTINGS.CBALLIGNED.HINT=When enabled, only pointers that are stored in an address dividable by 4 are looked at
When disabled, it won't bother.

pro: Fast scans
Con: On some horrible designed games that you shouldn't even play it won't find the paths
TFRMPOINTERSCANNERSETTINGS.CBALLIGNED.CAPTION=Addresses must be 32-bit alligned
TFRMPOINTERSCANNERSETTINGS.EDTREVERSESTART.TEXT=00000000
TFRMPOINTERSCANNERSETTINGS.LABEL10.CAPTION=From
TFRMPOINTERSCANNERSETTINGS.EDTREVERSESTOP.TEXT=7FFFFFFF
TFRMPOINTERSCANNERSETTINGS.LABEL11.CAPTION=To:
TFRMPOINTERSCANNERSETTINGS.CBACCEPTNONMODULEVTABLE.CAPTION=Also accept non-module addresses
TFRMPOINTERSCANNERSETTINGS.CBCLASSPOINTERSONLY.HINT=Object oriented programming languages tend to implement classobjects by having a pointer in the first element to something that describes the class
With this option enabled, ce will check if it's a classobject by checking that rule. If not, it won't see it as a pointer.
pro:Tremendous speed increase and almost perfect pointers
con:Doesn't work with runtime generated classes (java, .net) 
TFRMPOINTERSCANNERSETTINGS.CBCLASSPOINTERSONLY.CAPTION=First element of pointerstruct must point to module (e.g vtable)
TFRMPOINTERSCANNERSETTINGS.CBNOLOOP.HINT=This will filter out pointerpaths that ended up in a loop
e.g:
base->p1->p2->p3->p1->p4

you could just as well do base->p1->p4 then, so throw this one away (base->p1->p4 will be found another way)

pro: Less results so less diskspace used
con: slightly slows down the scan as it needs to check for loops every single iteration 
TFRMPOINTERSCANNERSETTINGS.CBNOLOOP.CAPTION=No looping pointers
TFRMPOINTERSCANNERSETTINGS.CBSTATICSTACKS.HINT=This allows the stack of threads to be seen as static addresses by the pointerscan.
The main thread is always a sure bet that it's the first one in the list. And often the second thread created is pretty stable as well.
With more there's a bigger change they get created and destroyed randomly

When a program enters a function and exits it, the stack pointer decreases and increases, and the data there gets written to.
The farther the game is inside function calls, the more static the older data will be.

With max stack offset: you can set the max size that can be deemed as static enough.

pro: It finds paths otherwise never found
con: More results, more diskspace 
TFRMPOINTERSCANNERSETTINGS.CBSTATICSTACKS.CAPTION=Allow stack addresses of the first thread(s) to be handled as static
TFRMPOINTERSCANNERSETTINGS.LBLNUMBEROFSTACKTHREADS.CAPTION=Number of threads from oldest to newest:
TFRMPOINTERSCANNERSETTINGS.EDTTHREADSTACKS.HINT=Fill in the total number of threads that should be allowed to be used as a stack lookup.
Thread 1 is usually the main thread of the game, but if that one spawns another thread for game related events, you might want to have that secondary thread as well.
More threads is not recommend as they may get created and destroyed on the fly, and are therefore useless as a lookup base, but it depends on the game.
TFRMPOINTERSCANNERSETTINGS.EDTTHREADSTACKS.TEXT=2
TFRMPOINTERSCANNERSETTINGS.EDTSTACKSIZE.TEXT=4096
TFRMPOINTERSCANNERSETTINGS.LBLSTACKSIZE.CAPTION=Max stackoffset to be deemed static enough:
TFRMPOINTERSCANNERSETTINGS.CBSTACKONLY.HINT=Enable this if you wish to only find pointer paths with a stack address.
Combine this with "Only find paths with a static address" (default on) else this option will have no effect

pro: You'll only get paths from the stack
con: You don't get get paths from random dll's or the .exe 
TFRMPOINTERSCANNERSETTINGS.CBSTACKONLY.CAPTION=Stack addresses as ONLY static address
TFRMPOINTERSCANNERSETTINGS.CBLIMITSCANTOREGIONFILE.CAPTION=Limit scan to specified region file
TFRMPOINTERSCANNERSETTINGS.CBCOMPRESSEDPOINTERSCANFILE.HINT=Compresses the generated .PTR files slightly so they take less space on the disk and less time writing to disk.
Most of the time the bottleneck of a pointerscan is disk writing, so it is recommended to use this option.

Compressed .PTR files can not be read out by older Cheat Engine versions
TFRMPOINTERSCANNERSETTINGS.CBCOMPRESSEDPOINTERSCANFILE.CAPTION=Compressed pointerscan file
TFRMPOINTERSCANNERSETTINGS.LABEL9.CAPTION=Nr of threads scanning:
TFRMPOINTERSCANNERSETTINGS.EDTTHREADCOUNT.TEXT=2
TFRMPOINTERSCANNERSETTINGS.EDITSTRUCTSIZE.TEXT=2047
TFRMPOINTERSCANNERSETTINGS.LABEL3.CAPTION=Maximum offset value:
TFRMPOINTERSCANNERSETTINGS.BTNOK.CAPTION=OK
TFRMPOINTERSCANNERSETTINGS.LABEL12.CAPTION=Max level
TFRMPOINTERSCANNERSETTINGS.COMBOBOX1.TEXT=Normal
TFRMPOINTERSCANNERSETTINGS.EDITMAXLEVEL.TEXT=5
TFRMPOINTERSCANNERSETTINGS.BTNCANCEL.CAPTION=Cancel
TFRMPOINTERSCANNERSETTINGS.CBMUSTSTARTWITHBASE.HINT=Will only mark the given range as valid base address (Will reduce the number of results)
This internally makes use of the "Only find paths with a static address" feature by marking the provided range as static only, so it must be enabled.
TFRMPOINTERSCANNERSETTINGS.CBMUSTSTARTWITHBASE.CAPTION=Base address must be in specific range
TFRMPOINTERSCANNERSETTINGS.CBMUSTENDWITHSPECIFICOFFSET.CAPTION=Pointers must end with specific offsets
TFRMPOINTERSCANNERSETTINGS.CBMAXOFFSETSPERNODE.HINT=When the pointerscan looks through the list of pointers with a specific value, it goes through every single pointer that has that value. Every time increasing the offset slightly.
With this feature enabled the pointerscan will only check the first few pointers with that value.

pro: Extremely fast, and the results have the lowest pointer paths possible.
con: You'll miss a lot of pointers that might be valid too 
TFRMPOINTERSCANNERSETTINGS.CBMAXOFFSETSPERNODE.CAPTION=Max different offsets per node:
TFRMPOINTERSCANNERSETTINGS.EDTMAXOFFSETSPERNODE.TEXT=2
TFRMPOINTERSCANNERSETTINGS.LABEL2.CAPTION=To
TFRMPOINTERSCANNERSETTINGS.LABEL4.CAPTION=From
TFRMPOINTERSCANNERSETTINGS.CBALLOWRUNTIMEWORKERS.HINT=Opens a port that other systems running the pointerscanner can connect to and help out with the scan
TFRMPOINTERSCANNERSETTINGS.CBALLOWRUNTIMEWORKERS.CAPTION=Allow scanners to connect at runtime
TFRMPOINTERSCANNERSETTINGS.LBLPORT.CAPTION=Port:
TFRMPOINTERSCANNERSETTINGS.EDTDISTRIBUTEDPORT.TEXT=52737
TFRMPOINTERSCANNERSETTINGS.LABEL1.CAPTION=Password
TFRMPOINTERSCANNERSETTINGS.CBCONNECTTONODE.HINT=When checked will send a broadcast message on the local network which will tell pointer scanner systems to join this scan if they are set to auto join

You can use "Setup specific IP's to notify" to notify systems of this scan that are outside of the local network
TFRMPOINTERSCANNERSETTINGS.CBCONNECTTONODE.CAPTION=Connect to pointerscan node