Gaming/CheatEngine/Portable/App/ProgramFiles/autorun/SpeedhackV3.lua

--Copyright Cheat Engine

--local 
UnityEngineTimeSetTimeScaleMethod=nil

function getOriginalCodeAndFiller(address, farjmp)
  local original,filler

  if type(address)~='number' then
    address=getAddressSafe(address)
  end

  if address==nil then
    return nil, 'invalid address'
  end

  local sl=createStringList()
  local d=createDisassembler()
  local size=0
  local jmpsize=not farjmp and 5 or 14
  
  
  while size<jmpsize do
    d.disassemble(address)
    local ldd=d.LastDisassembleData
    local inst=ldd.opcode..' '..ldd.parameters
    sl.add(inst)
    size=size+#ldd.bytes
    address=address+#ldd.bytes
  end

  original=sl.Text
  if size-jmpsize>0 then
    filler=string.format("nop %x", size-jmpsize)
  else
    filler=''
  end

  sl.destroy()
  d.destroy()
  return original,filler
end


function hookSpeedFunctions()
  --print("hookSpeedFunctions")
  if getAddressSafe("speedhack_wantedspeed")~=nil then
  --  print("already hooked")
    return true
  end
  
  UnityEngineTimeSetTimeScaleMethod=nil
  
  local r,r2=injectCEHelperLib()
  
  if not r then
    messageDialog('error in injectCEHelperLib(): '..r2, mtError,mbOK)
    return false
  end
  
  local result, data=autoAssemble([[
    globalalloc(speedhack_wantedspeed,4)
    speedhack_wantedspeed:
    dd (float)1
    
    globalalloc(speedhack_unityspeedhackmethod,4)
    speedhack_unityspeedhackmethod:
    dd 1
{$asm}

  ]])

  if not result then
    messageDialog(data)
    return
  end

 -- print("allocated speedhack_wantedspeed")
 
  if monoSettings.Value["SkipMonoSpeedhack"]~='1' then
    local hasMono=getAddressSafe('mono_thread_attach',false,true) or getAddressSafe('il2cpp_thread_attach',false,true)

    if hasMono then
      LaunchMonoDataCollector()
      
      local r=mono_findClass("UnityEngine","Time")
      if r then

        UnityEngineTimeSetTimeScaleMethod=mono_class_findMethod(r,"set_timeScale")
        if UnityEngineTimeSetTimeScaleMethod then    

          local set_timeScale
 
          
          if mono_isil2cpp() then
            set_timeScale=mono_compile_method(UnityEngineTimeSetTimeScaleMethod)
          else          
            set_timeScale=getAddressSafe("UnityEngine.Time:set_timeScale")
          end 
          
          if set_timeScale then   
            local originalcode,filler=getOriginalCodeAndFiller(set_timeScale, true)
          
            if originalcode then            
              local s=string.format([[
{$c}  
extern int speedhack_unityspeedhackmethod; 
extern float speedhack_wantedspeed;
float getNewSpeed(float newspeed)
{
  float wanted=speedhack_wantedspeed; //bug in tcc needs local first
  int method=speedhack_unityspeedhackmethod;
  
  if (method==0) //method 0 : If speed==0, return 0, else return the speedhack speed
  {
    if (newspeed>0)
      newspeed=wanted;    
  }
  else //method 1: multiply the wanted speed by the speedhack speed. 0*wanted==0, 1*wanted=speedhack speed, 2*wanted=double speedhack speed.  Only issue is if it where to read the old speed and apply it's own multiplication
    newspeed=newspeed*wanted;

  return newspeed;
}
{$asm}
alloc(set_timeScaleEntryHook,128)
registersymbol(set_timeScaleEntryHook)
label(returnhere)
set_timeScaleEntryHook:
sub rsp,20
call getNewSpeed //will change xmm0
add rsp,20


//previous version's implementation
 // mov rax,speedhack_wantedspeed 
//  movss xmm0,[rax]

%s
jmp returnhere

%x:
jmp far set_timeScaleEntryHook
%s

returnhere:]], originalcode, set_timeScale, filler) 
              local r,err=autoAssemble(s)
              if r then return true end --just this should be enough
 
              --print(s)
              
              return true
            end
          end
        else
          print("no UnityEngineTimeSetTimeScaleMethod")
        end
      end
    end
  end
  
    

  local gtcaddress=getAddressSafe('kernel32.gettickcount64')
  if gtcaddress==nil then
    waitforExports()
    gtcaddress=getAddressSafe('kernel32.gettickcount64')

    if (gtcaddress==nil) then
      reinitializeSymbolhandler()
      gtcaddress=getAddressSafe('kernel32.gettickcount64')
      if (gtcaddress==nil) then
        messageDialog('Failure finding kernel32.gettickcount64', mtError, mbOK)
        return false
      end
    end
  end


  local originalcode,filler=getOriginalCodeAndFiller(gtcaddress)

  if originalcode then
    local s=string.format([[

alloc(gtc_originalcode,64,"kernel32.gettickcount64")
label(gtc_returnhere)
label(gtchook_exit)

{$c}

#include <stdint.h>
#include <stddef.h>
#include <celib.h>
#include <windowslite.h>

__stdcall uint64_t gtc_originalcode(void);
float gtc_speed=1.0f;
uint64_t gtc_initialtime=0;
uint64_t gtc_initialoffset=0;
CRITICAL_SECTION gtc_cs;

void *gtc_initonce=(void*)0;
int gtc_intialized=0;


extern float speedhack_wantedspeed;

__stdcall int InitOnceExecuteOnce(void *InitOnce, void* InitFn, void* Parameter, void *Context);


__stdcall int initgtc_cs(void *InitOnce, void *Parameter, void *lpContext) {
  InitializeCriticalSection(&gtc_cs);
  gtc_intialized=1;
  return TRUE;
}



__stdcall uint64_t new_gettickcount(void)
{
  uint64_t newtime;

  uint64_t currenttime;
  float wantedspeed; //small issue with tcc where you can not compare against extern directly


  currenttime=gtc_originalcode();

  if (gtc_intialized==0) //only set to true once the cs has been initialized
    InitOnceExecuteOnce(&gtc_initonce, initgtc_cs, NULL, NULL);

  //after here, gtc_cs is initialized
  EnterCriticalSection(&gtc_cs);




  //csenter(&gtc_cs);
  wantedspeed=speedhack_wantedspeed;

  if (gtc_initialtime==0)
  {
    gtc_initialtime=currenttime;
    gtc_initialoffset=currenttime;
  }

  newtime=(currenttime-gtc_initialtime)*gtc_speed;
  newtime=newtime+gtc_initialoffset; //don't put in in the calculation above, as it gets converted to float, and truncated

  if (gtc_speed!=wantedspeed)
  {
    //the user wants to change the speed
    gtc_initialoffset=newtime;
    gtc_initialtime=currenttime;
    gtc_speed=speedhack_wantedspeed;
  }



  LeaveCriticalSection(&gtc_cs);


  return newtime;

}
{$asm}


gtc_originalcode:
%s

gtchook_exit:
jmp gtc_returnhere

kernel32.gettickcount64:
jmp new_gettickcount
%s

gtc_returnhere:

{$ifdef kernel32.timegettime}
kernel32.timeGetTime:
jmp new_gettickcount
{$endif}

kernel32.getTickCount:
jmp new_gettickcount

]],originalcode, filler)

    local result, data=autoAssemble(s) 

    if not result then
      if data==nil then
        data=' (no reason)'
      end
      messageDialog('Failure hooking kernel32.gettickcount64:'..data, mtError, mbOK)
    end
  end;


--queryPerformanceCounter
  local qpcaddress=getAddressSafe('ntdll.RtlQueryPerformanceCounter')
  if qpcaddress==nil then
    waitforExports()
    qpcaddress=getAddressSafe('ntdll.RtlQueryPerformanceCounter')

    if (qpcaddress==nil) then
      reinitializeSymbolhandler()
      qpcaddress=getAddressSafe('ntdll.RtlQueryPerformanceCounter')
      if (qpcaddress==nil) then
        messageDialog('Failure finding kernel32.gettickcount64', mtError, mbOK)
        return false
      end
    end
  end


  local originalcode,filler=getOriginalCodeAndFiller(qpcaddress)

  if originalcode then


  --speedhack does not disable. Just sets speed to 1 when done

    local s=string.format([[

alloc(qpc_originalcode,64,"ntdll.RtlQueryPerformanceCounter")
label(qpc_returnhere)
label(qpchook_exit)

{$c}
#include <stdint.h>
#include <stddef.h>
#include <celib.h>
#include <windowslite.h>


__stdcall int  qpc_originalcode(uint64_t *count);
float qpc_speed=1.0f;
uint64_t qpc_initialtime=0;
uint64_t qpc_initialoffset=0;
CRITICAL_SECTION qpc_cs;

void *qpc_initonce=(void*)0;
int qpc_intialized=0;


uint64_t qpc_lastresult=0;

extern float speedhack_wantedspeed;

__stdcall int InitOnceExecuteOnce(void *InitOnce, void* InitFn, void* Parameter, void *Context);


__stdcall int initqpc_cs(void *InitOnce, void *Parameter, void *lpContext) {
  InitializeCriticalSection(&qpc_cs);
  qpc_intialized=1;
  return TRUE;
}





__stdcall int  new_RtlQueryPerformanceCounter(uint64_t *count)
{
  uint64_t newtime;

  uint64_t currenttime;
  uint64_t newwantedspeed;


  float wantedspeed; //small issue with tcc where you can not compare against extern directly

  if (qpc_intialized==0) //only set to true once the cs has been initialized
    InitOnceExecuteOnce(&qpc_initonce, initqpc_cs, NULL, NULL);

  //after here, gtc_cs is initialized
  EnterCriticalSection(&qpc_cs);


  int result=qpc_originalcode(&currenttime);


  
  
  wantedspeed=speedhack_wantedspeed;

  if (qpc_initialtime==0)
  {
    qpc_initialtime=currenttime;
    qpc_initialoffset=currenttime;
  }

  newtime=(currenttime-qpc_initialtime)*qpc_speed;

  newtime=newtime+qpc_initialoffset;
  if (qpc_speed!=wantedspeed)
  {
    //the user wants to change the speed
    qpc_initialoffset=newtime;
    qpc_initialtime=currenttime;
    qpc_speed=speedhack_wantedspeed;
  }
  
  LeaveCriticalSection(&qpc_cs);

  

  *count=newtime;

  return result;

}
{$asm}


qpc_originalcode:
%s

qpchook_exit:
jmp qpc_returnhere

ntdll.RtlQueryPerformanceCounter:
jmp new_RtlQueryPerformanceCounter
%s

qpc_returnhere:


]],originalcode, filler)

    local result2, data2=autoAssemble(s)
    
    if not result2 then
      if data2==nil then
        data2=' (no reason)'
      end
      messageDialog('Failure hooking ntdll.RtlQueryPerformanceCounter:'..data2, mtError, mbOK)
    end
    
  end;

  return result or result2
end



registerSpeedhackCallbacks(function() --OnActivate
  if (not isConnectedToCEServer()) and targetIsX86() then
    local result, errormsg
    
    
    if getAddressSafe("speedhack_wantedspeed")==nil then
      --still needs hooking
      result,errormsg=hookSpeedFunctions()
    else
      result=true
    end
        
    return true, result, errormsg
  else
    return false
  end
end,

function(speed) --OnSetSpeed(speed)
  if (not isConnectedToCEServer()) and targetIsX86() then
    local result, errormsg
    if getAddressSafe("new_gettickcount")==nil or getAddressSafe("speedhack_wantedspeed")==nil then

      result,errormsg=hookSpeedFunctions()
      if not result then return true, false, errormsg end
    end

    writeFloat("speedhack_wantedspeed", speed)
    
    if UnityEngineTimeSetTimeScaleMethod then
      mono_invoke_method(nil,UnityEngineTimeSetTimeScaleMethod,nil,{speed}) 
    end
    
    result=true      
    
    return true, true
  else
    return false
  end
end)