MasterGH

procedure TForm1.ListBox1DrawItem(Control: TWinControl; Index: Integer;
  ARect: TRect; State: TOwnerDrawState);
begin
  with ListBox1.Canvas do begin
    if odFocused in State then
      Brush.Color := clHighlight else
      Brush.Color := clWindow;
    FillRect(ARect);
    TextOut(ARect.left, ARect.Top, Listbox1.Items[Index]);
    if odFocused in State then
      DrawFocusRect(ARect);
  end
end;

Открывать исходники Cheat Engine и разбираться как вообще это делается, а потом думать как это сделать в текущей версии CE. Проще спросить у DarkByte

http://airtest.netease.com/changelog.html

Цитата

[Start running..]
do not connect device
save log in 'C:\Users\Andrew\AppData\Local\Temp\AirtestIDE\scripts\85cd626315484cdf6cffe357149cae40'
[12:09:22][DEBUG]<airtest.core.android.adb> C:\AirtestIDE\airtest\core\android\static\adb\windows\adb.exe devices
[12:09:22][DEBUG]<airtest.core.android.adb> C:\AirtestIDE\airtest\core\android\static\adb\windows\adb.exe devices
3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 16:02:32) [MSC v.1900 64 bit (AMD64)]
----------------------------------------------------------------------
Ran 1 test in 0.303s

OK
[Finished]

# -*- encoding=utf8 -*-
__author__ = "gzliuxin"
__title__ = "test script title"
__desc__ = """
this is a test script.
"""

# install demo apk
PKG = "com.NetEase.PocoDemo"
if PKG not in device().list_app():
    import os
    path = os.path.join(args.script, "poco-demo.apk")
    device().install_app(path)

# restart app
stop_app(PKG)
start_app(PKG)
wait(Template(file:///C:/AirtestIDE/Scripts Poco/unitydemo.air/tpl1522812811402.png, record_pos=(0.001, -0.084), resolution=(1920, 1080)))

# init UnityPoco
from poco.drivers.unity3d import UnityPoco
poco = UnityPoco()

poco(text="Start").click()
poco(text="basic").click()

# assert empty
result = poco(type="Text", name="Text").get_text()
assert_equal(bool(result), False)

# input text
poco(type="InputField").set_text("Hello World")
sleep(1.0)

# assert text 
result = poco(type="Text", name="Text").get_text()
assert_equal(result, "Hello World")

poco(text="Back").click()

import asyncio

@asyncio.coroutine
def hello_world():
    print("Hello World!")

loop = asyncio.get_event_loop()
# Blocking call which returns when the hello_world() coroutine is done
loop.run_until_complete(hello_world())
loop.close()

Цитата

June 23 2018:Cheat Engine 6.8.1 Released:

Apparently 6.8 contained a couple of annoying bugs, so here's an update that should hopefully resolve most issues.
Also a few new features that can come handy
Download: Cheat Engine 6.8.1

Fixes:

• Fixed several issues with the structure compare
• Fixed the commonality scanner from picking up unrelated registers for comparison
• Fixed speedhack hotkeys
• Fixed ultimap 1
• Fixed a bunch of random access violations
• Fixed Lua dissectCode.getStringReferences now also returns the string
• Fixed Lua breakpoints that specify a specific function
• Fixed Lua toAddress when the 2nd parameter is an address
• Fixed assembling xmm,m32
• Fixed issue when disassembling AVX instructions
• Fixed rightclicking r8-r9 in the registers window
• Fixed the plugin system for DBVM
• Fixed DBVM memory allocations when smaller than 4KB


• Additions and changes:


• Added translation strings for the all type settings
• You can now drop files into the auto assembler
• auto assembler commands allocnx (allocate no execute) and allocxo (allocate execute only)
• The memoryview windows's hexadecimalview now shows the allocationbase as well, and can be doubleclicked to go there
• Added support for mono dll's that do not export g_free
• Changed "make page writable" to multiple options
• Improved DBVM speed slightly


• Lua:


• added RemoteThread class object

for x = 1, 3 do
  local address = 0x009E93E0 + x * 4
  local stringValue = CEEditsnowbt[x].Text
  local intValue = tonumber(stringValue)  
  writeInteger(address, intValue)
end

for x = 1, 3 do
  local address = 0x009E93E0 + x * 4
  local stringValue = CEEditsnowbt[x].Text
  local intValue = tonumber(stringValue,16)  
  writeInteger(address, intValue)
end

function DecToHex(stringValue)  return string.format('0x%08X', stringValue) end
function HexToDec(stringValue)  return tonumber(stringValue) end

function CEButton1Click(sender)
  UDF1.CEEdit1.Text = DecToHex(100)
end

function CEButton2Click(sender)
  local value =  HexToDec(UDF1.CEEdit1.Text)
  print(value)
end

writePointer(address,value)
writePointerLocal(address,value)

У enumModules(processid OPTIONAL):
  Name : String containing the modulename  
  
  
reinitializeSelfSymbolhandler(waittilldone: BOOLEAN OPTIONAL, default=TRUE): reinitializes the selfsymbolhandler. E.g when new modules have been loaded to CE process


registerStructureAndElementListCallback(function StructureListCallback(), function elementlistcallback(id1,id2) ) : Registers a function to be called when a structure needs to be dissected 
  function StructureListCallback() will be a function that returns an array of list of structures in table format
  the entries are build up as:
    name: string - name of the structure
    id1: integer - id you can use for whatever(e.g moduleid). It will be passed on to elementlistcallback when this structure is picked
    id2: integer - id you can use for whatever(e.g structureid inside the module). It will be passed on to elementlistcallback when this structure is picked

  
  function elementlistcallback(id1,id2) will be a function that returns an array of structure elements in table format
  the entries are build up as:
    name: string
    offset: integer
    vartype: variabletype (look up vtByte, vtWord, etc..)

  tip: If you return an empty table the structure will not be created. You can use this to create the structure layout yourself and register that instead

unregisterStructureAndElementListCallback(ID)


showSelectionList(title, caption, stringlist, allowCustomInput OPTIONAL): integer,string - Shows a menu with the given list. It returns the linenumber (starting at 0) and the selected string.  Linenumber is -1 if the user was allowed to enter custom input


getWindowlist(): Returns a table with the windowlist (pid - window caption ).  The table is formatted as : {pid,{id,caption}}



MainForm.OnProcessOpened: function(processid, processhandle, caption) - Define this if you want to be notified when a new process has been opened. Called only once from the main thread. It is recommended to use this instead of onOpenProcess


cpuid(EAX,ECX): returns a table with CPUID info (EAX, EBX, ECX, EDX)

gc_setPassive(state: boolean): enables/disables the passive garbage collector
gc_setActive(state: boolean, interval: integer, minsize: integer): enables/disables the active garbage collector and lets you configure the interval and minimim size


Form Class: (Inheritance: ScrollingWinControl->CustomControl->WinControl->Control->Component->Object)
properties
  FormState: FormState string ReadOnly - The current state of the form. Possible values: fsCreating, fsVisible, fsShowing, fsModal, fsCreatedMDIChild, fsBorderStyleChanged, fsFormStyleChanged, fsFirstShow, fsDisableAutoSize 

  
  ListItems class : (Inheritance: TObject)
methods
  displayRect(code): returns the displayed rectangle of the listitem. code can be: drBounds(0), drIcon(1), drLabel(2), drSelectBounds(3)
  displayRectSubItem(code): returns the displayed rectangle of the listitem. code can be: drBounds(0), drIcon(1), drLabel(2), drSelectBounds(3)

  
  
Stream Class
methods
  readByte(): integer
  writeByte(integer)
  readWord(): integer
  writeWord(integer)
  readDword(): integer
  writeDword(integer)
  readQword(): integer
  writeQword(integer)
  
  
  
MemoryRecord Class:
properties
  AddressString: string - Get the address string shown in CE (ReadOnly)
  VarType: ValueType (string) - The variable type of this record. See vtByte to vtCustom
  Type: ValueType (number) - The variable type of this record. See vtByte to vtCustom
  CustomTypeName: String - If the type is vtCustom this will contain the name of the CustomType
  
  Options: String set - a string enclosed by square brackets filled with the options seperated by a comma. Valid options are: moHideChildren, moActivateChildrenAsWell, moDeactivateChildrenAsWell, moRecursiveSetValue, moAllowManualCollapseAndExpand, moManualExpandCollapse
  
  DropDownLinked: boolean - if dropdown list refers to list of another memory record eg. (memrec name)
  DropDownLinkedMemrec: string - Description of linked memrec or emptystring if not linked
  DropDownList : StringList - list of "value:description" lines, lists are still separate objects when linked, read-write
  DropDownReadOnly: boolean - true if 'Disallow manual user input' is set
  DropDownDescriptionOnly: boolean - self explanatory
  DisplayAsDropDownListItem: boolean - self explanatory
  DropDownCount: integer - equivalent to .DropDownList.Count
  DropDownValue[index] : Array to access values in DropDownList (ReadOnly)
  DropDownDescription[index] : Array to access Descriptions in DropDownList (ReadOnly)

  Parent: MemoryRecord - self explanatory
  
  
  
StructureFrm class:
createStructureForm(address, groupname OPTIONAL, structurename OPTIONAL)
enumStructureForms() : returns a table of StructureFrm objects (can be useful for finding a structure window with the wanted structure)


properties:
MainStruct: structure - The currently selected structure

ColumnCount: integer - the number of columns (columns=address)
Column[index]: structColumn - Fetches a structColumn object from the structure form

GroupCount: integer - The number of groups
Group[index]: structGroup - Fetches a structGroup object from the structure form



StructureElement class: (Inheritance: Object)
Methods:
  getValue(address) : Gets the memory from the specified address and interprets it according to the element type
  setValue(address,value): Sets the memory at the specified address to the interpreted value according to the element type
  getValueFromBase(baseaddress): same as getValue but uses the offset to calculate the final address
  setValueFromBase(baseaddress,value): same as setValue but uses the offset to calculate the final address

dbk_readMSR(msr): Reads the msr
dbk_writeMSR(msr, msrvalue): Writes the msr 
dbk_executeKernelMemory(address, parameter) :
  Executes a routine from kernelmode (e.g a routine written there with auto assembler)
  parameter can be a value or an address. It's up to your code how it's handled


dbvm_initialize(offloados:Boolean OPTIONAL, reason:String OPTIONAL) : Initializes the dbvm functions (dbk_initialize also calls this) offloados is a boolean that when set will offload the system onto dbvm if it's not yet running (and only IF the dbk driver is loaded)
dbvm_readMSR(msr): See dbk_readMSR but then using dbvm
dbvm_writeMSR(msr, value): See dbk_writeMSR
dbvm_getCR4(): Returns the real Control Register 4 state

dbvm_readPhysicalMemory(address, size): bytetable
dbvm_writePhysicalMemory(address, size, bytetable)

dbvm_watch_writes(PhysicalAddress, bytesize OPTIONAL, OPTIONS OPTIONAL,  internalentrycount OPTIONAL) : 
  Starts watching writes to the given address range
  OPTIONS is a binary field.
    (1 << 0): Log the same RIP multiple times (if different registers)
    (1 << 1): Ignore the size field and log everything in the specified page
    (1 << 2): Logs record the floating point state
    (1 << 3): Logs contain a 4KB stack snapshot
    (1 << 4): does nothing
    (1 << 5): If the number of recorded entries gets bigger than internalentrycount, grow the list instead of discarding the entries

  On success returns an ID to use with dbvm_watch_retrievelog and dbvm_watch_disable


dbvm_watch_reads(PhysicalAddress, bytesize OPTIONAL, OPTIONS OPTIONAL,  internalentrycount OPTIONAL) : see dbvm_watch_writes but then for reads and writes
dbvm_watch_retrievelog(ID) : Returns an array of watch event data. (Context of the system at the time of the event, like registers)
dbvm_watch_disable(ID) : Disables the watch operation


dbvm_cloak_activate(physicalbase, virtualbase OPTIONAL): 
  Hides an executable memory range (4096 bytes) from snooping eyes
  Note: It is recommended to cause a copy-on-write on the target first, else this will affect all processes that have this memory block loaded
dbvm_cloak_deactivate(physicalbase): Disables the cloak and restores the executable memory to what the system thinks it is
dbvm_cloak_readOriginal(physicalbase): Reads the memory that will get executed.  On success returns a 4096 byte long bytetable (remember, lua indexes start at 1, so offset 0 is index 1)
dbvm_cloak_writeOriginal(physicalbase, bytetable[4096]): Writes the memory that will get executed. 

dbvm_changeregonbp(physicaladdress, changereginfo, virtualaddress OPTIONAL): boolean
  sets a breakpoint at the given position. When a breakpoint hits the registers will be changed according to the changereginfo table
    changereginfo table:  (set the field to nil, or don't define it, if you don't want to change it)
      newCF: integer/boolean (false=0, true=1) 
      newPF: integer/boolean (false=0, true=1) 
      newAF: integer/boolean (false=0, true=1) 
      newZF: integer/boolean (false=0, true=1) 
      newSF: integer/boolean (false=0, true=1) 
      newOF: integer/boolean (false=0, true=1)
      newRAX: integer
      newRBX: integer
      newRCX: integer 
      newRDX: integer
      newRSI: integer 
      newRDI: integer
      newRBP: integer 
      newRSP: integer
      newRIP: integer
      newR8:  integer
      newR9:  integer
      newR10: integer
      newR11: integer
      newR12: integer
      newR13: integer
      newR14: integer
      newR15: integer

dbvm_log_cr3_start() : Tells DBVM to record (up to 512) unique CR3 values it encounters
dbvm_log_cr3_stop() : Stops the logging and returns the results as a table


getPhysicalAddressCR3(CR3, address): Looks up the physical address for the given virtual address in the given pagetable base. Returns nil if not paged
readProcessMemoryCR3(CR3, address, size): Reads the virtual memory of the given process's CR3 value. Returns a bytetable on success, nil if fail to read (paged out)
writeProcessMemoryCR3(CR3, address, bytetable): Reads the virtual memory of the given process's CR3 value
 
 
createD3DHook(textureandcommandlistsize OPTIONAL, hookmessages OPTIONAL)
methods
  enableConsole(virtualkey): Adds a (lua)console to the specific game. The given key will bring it up (0xc0=tilde(`~))

Disassembler Class (Inheritance: Object)
Methods
      commentsoverride: string - If set, this will be the comments/LastParamatersToString result
      
HotkeyHandlerThread(Inheritence: Thread)
getHotkeyHandlerThread() : Returns the hotkey handler thread used internally by CE

properties
  state: 0 ('htsActive')=Active , 1('htsMemrecOnly')=Memory records only, 2('htsNoMemrec')=Everything except memoryrecords, 3('htsDisabled')=disabled

methods
  -

using System.Collections;
using UnityEngine;

public class AutoScreenSize : MonoBehaviour
{
    private static bool forceResize = true;
    private static AutoScreenSize instance = null;
 
    private static int width = 1024;
    private static int height = 768;

    private static WaitForSeconds waitForSeconds = new WaitForSeconds(1f);

    private void Start()
    {
        if (instance != null)
        {
            Destroy(gameObject);
            return;
        }

        DontDestroyOnLoad(this);

        StartCoroutine(UpdateScreenMode());
	}

    private IEnumerator UpdateScreenMode()
    {
        while (true)
        {
            if (Screen.fullScreen || (forceResize && (Screen.width != width || Screen.height != height)))
            {
                Screen.SetResolution(width, height, false);
            }
            yield return waitForSeconds;
        }
	}

    public static void InitComponent()
    {
        if(instance == null)
        {
            GameObject newGameObject = new GameObject("AutoScreenSize");
            newGameObject.AddComponent<AutoScreenSize>();
        }

    }
}