9083
"enable"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
//vng21092's aobscan lua script
{$lua}
function lua_aobscan(name,module,bytes,index)
index = index - 1
if(module == "") then
local resultSet = AOBScan(bytes)
if(resultSet == nil) then
unregisterSymbol(name)
print(name.." not found")
else
unregisterSymbol(name)
registerSymbol(name,resultSet[index])
resultSet.destroy()
end
else
if(getModuleSize(module) == nil) then
print("Module "..module.." not found")
else
local memScanner = createMemScan()
local memFoundList = createFoundList(memScanner)
memScanner.firstScan(
soExactValue,vtByteArray,rtRounded,bytes,nil,
getAddress(module),(getAddress(module)+getModuleSize(module)),"",
fsmNotAligned,"",true,false,false,false)
memScanner.waitTillDone()
memFoundList.initialize()
if(memFoundList.Count == 0) then
unregisterSymbol(name)
print(name.." in module "..module.." not found")
else
unregisterSymbol(name)
registerSymbol(name,memFoundList.Address[index])
end
memScanner.destroy()
memFoundList.destroy()
end
end
end
{$asm}
///
aobscan(playerHealthReadAOB,85 C0 0F 84 ** ** ** ** 8B ** ** ** ** ** 89 ** ** 33 D2)
registersymbol(playerHealthReadAOB)
label(pPlayer)
registersymbol(pPlayer)
label(bHealPlayer)
registersymbol(bHealPlayer)
alloc(newmem,2048)
label(returnhere)
label(originalcode_enable)
registersymbol(originalcode_enable)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
mov [pPlayer],ecx
cmp byte ptr [bHealPlayer],1
jne end
//
pushad
sub esp,10
movdqu dqword [esp],xmm5
sub esp,10
movdqu dqword [esp],xmm4
sub esp,10
movdqu dqword [esp],xmm3
sub esp,10
movdqu dqword [esp],xmm2
sub esp,10
movdqu dqword [esp],xmm1
sub esp,10
movdqu dqword [esp],xmm0
//
push 'T'
call GetAsyncKeyState
shr ax,#15
cmp ax,1
jne @f
mov byte ptr [bHealPlayer+1],1
@@:
//
movdqu xmm0,dqword [esp]
add esp,10
movdqu xmm1,dqword [esp]
add esp,10
movdqu xmm2,dqword [esp]
add esp,10
movdqu xmm3,dqword [esp]
add esp,10
movdqu xmm4,dqword [esp]
add esp,10
movdqu xmm5,dqword [esp]
add esp,10
popad
//
cmp byte ptr [bHealPlayer+1],1
jne @f
mov byte ptr [bHealPlayer+1],0
lea edx,[ecx+d8]
mov edx,[edx+4]
mov [ecx+d8],edx
end:
originalcode_enable:
readmem(playerHealthReadAOB+8,6)
//mov edx,[ecx+000000D8]
exit:
jmp returnhere
///
pPlayer:
dd 0
bHealPlayer:
dd 0
///
playerHealthReadAOB+8: //0892ECF6:
jmp newmem
nop
returnhere:
///******************************************///
aobscan(goldReadNearShopAOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 8B ** ** 3B ** ** 0F 84 ** ** ** ** 8B)
registersymbol(goldReadNearShopAOB)
label(pGold)
registersymbol(pGold)
alloc(newmem2,2048)
label(returnhere2)
label(originalcode2_enable)
registersymbol(originalcode2_enable)
label(exit2)
newmem2: //this is allocated memory, you have read,write,execute access
//place your code here
mov [pGold],ecx
originalcode2_enable:
readmem(goldReadNearShopAOB+6,6)
//mov edx,[ecx+34]
//mov [ebp-54],edx
exit2:
jmp returnhere2
///
pGold:
dd 0
///
goldReadNearShopAOB+6: //08BC8865:
jmp newmem2
nop
returnhere2:
///******************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
playerHealthReadAOB+8: //0892ECF6:
readmem(originalcode_enable,6)
//db 8B 91 D8 00 00 00
//Alt: mov edx,[ecx+000000D8]
unregistersymbol(originalcode_enable)
unregistersymbol(pPlayer)
unregistersymbol(bHealPlayer)
///******************************************///
dealloc(newmem2)
goldReadNearShopAOB+6: //08BC8865:
readmem(originalcode2_enable,6)
//db 8B 51 34 89 55 AC
//Alt: mov edx,[ecx+34]
//Alt: mov [ebp-54],edx
unregistersymbol(originalcode2_enable)
unregistersymbol(pGold)
///******************************************///
9084
"undead .2"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(healthCalOnHitAOB,8B ** ** 2B ** ** ** ** ** 89 ** ** 8B ** ** 89 ** ** ** ** ** 8B ** ** 8B ** 8B)
registersymbol(healthCalOnHitAOB)
label(dMinHealth)
registersymbol(dMinHealth)
alloc(newmem,2048)
label(returnhere)
label(originalcode_undead)
registersymbol(originalcode_undead)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
readmem(healthCalOnHitAOB+c,3)
//mov eax,[ebp+8]
cmp [pPlayer],eax
jne @f
readmem(healthCalOnHitAOB,9)
//mov edx,[ebp-8]
//sub edx,[ebp-84]
cmp edx,[dMinHealth]
jge @f
mov edx,[dMinHealth]
db 03
readmem(healthCalOnHitAOB+4,5)
//add edx,[ebp-84]
db 89
readmem(healthCalOnHitAOB+1,2)
//mov [ebp-8],edx
originalcode_undead:
readmem(healthCalOnHitAOB,9)
//mov edx,[ebp-08]
//sub edx,[ebp-00000084]
exit:
jmp returnhere
///
dMinHealth:
dd #1
///
healthCalOnHitAOB: //08458D97:
jmp newmem
nop
nop
nop
nop
returnhere:
///***************************************///
aobscan(curseSetDeadCallerAOB,33 D2 8A ** ** ** ** ** 84 D2 0F 84 ** ** ** ** 83 ** ** FF ** ** E8)
registersymbol(curseSetDeadCallerAOB)
curseSetDeadCallerAOB+a: //0867124A:
db 90 E9
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
healthCalOnHitAOB: //08458D97:
readmem(originalcode_undead,9)
//db 8B 55 F8 2B 95 7C FF FF FF
//Alt: mov edx,[ebp-08]
//Alt: sub edx,[ebp-00000084]
unregistersymbol(originalcode_undead)
unregistersymbol(dMinHealth)
///***************************************///
curseSetDeadCallerAOB+a: //0867124A:
db 0F 84
//Alt: je
9178
"no curse"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(curseSetCallAOB,55 8B EC 81 EC ** ** ** ** 33 C0 89 ** ** 3B ** ** 0F 8C ** ** ** ** 8B ** ** 81 C4 ** ** ** ** 5D C3)
registersymbol(curseSetCallAOB)
alloc(originalcode_nocurse,8)
registersymbol(originalcode_nocurse)
originalcode_nocurse:
readmem(curseSetCallAOB+11,6)
///
curseSetCallAOB+11: //08714471:
db 90 90 90 90 90 90
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
curseSetCallAOB+11: //08714471:
readmem(originalcode_nocurse,6)
//db 0F 8C 0B 00 00 00
//Alt: jl 08714482
dealloc(originalcode_nocurse)
unregistersymbol(originalcode_nocurse)
9173
"damage multiplier"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(attackDamageBaseReadRetAOB,B8 ** ** ** ** FF D0 89 ** ** ** 83 ** ** DD ** ** F2 0F 10 ** ** F2 0F 11 ** ** E9 ** ** ** ** 68)
registersymbol(attackDamageBaseReadRetAOB)
label(qDamageMultiplier)
registersymbol(qDamageMultiplier)
alloc(newmem,2048)
label(returnhere)
label(originalcode_damagemultiplier)
registersymbol(originalcode_damagemultiplier)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
mov edx,[pPlayer]
cmp [esp+130],edx
je @f
fmul qword ptr [qDamageMultiplier]
originalcode_damagemultiplier:
readmem(attackDamageBaseReadRetAOB+7,7)
//mov [esp-04],ebp
//add esp,0C
exit:
jmp returnhere
///
qDamageMultiplier:
dq (double)2
///
attackDamageBaseReadRetAOB+7: //08256A53:
jmp newmem
nop
nop
returnhere:
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
attackDamageBaseReadRetAOB+7: //08256A53:
readmem(originalcode_damagemultiplier,7)
//db 89 6C 24 FC 83 C4 0C
//Alt: mov [esp-04],ebp
//Alt: add esp,0C
unregistersymbol(originalcode_damagemultiplier)
unregistersymbol(qDamageMultiplier)
9174
"x?"
008000
Double
qDamageMultiplier
9086
"heal key"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
bHealPlayer:
db 1
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
bHealPlayer:
db 0
9087
"press T"
808080
1
9164
"ignore health flask"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(healthFlaskRead1OnUseAttemptAOB,8B ** ** 8B ** ** ** ** ** 89 ** ** 33 C0 89 ** ** 3B C2 0F 8C)
registersymbol(healthFlaskRead1OnUseAttemptAOB)
healthFlaskRead1OnUseAttemptAOB+13: //088372CC:
db 90 E9
///************************************///
aobscan(healthFlaskRead2OnUseAttemptAOB,8B ** ** 8B ** ** ** ** ** 89 ** ** 33 D2 89 ** ** 3B D1 0F 8D ** ** ** ** 8B ** ** ** ** ** 89)
registersymbol(healthFlaskRead2OnUseAttemptAOB)
alloc(originalcode2_ignorehealthflask,8)
registersymbol(originalcode2_ignorehealthflask)
originalcode2_ignorehealthflask:
readmem(healthFlaskRead2OnUseAttemptAOB+13,6)
///
healthFlaskRead2OnUseAttemptAOB+13: //087FBB89:
db 90 90 90 90 90 90
///************************************///
aobscan(healthFlaskCalOnUseAOB,8B ** ** 8B ** ** ** ** ** 89 ** ** ** ** ** 4A 89 ** ** ** ** ** 89 ** ** ** ** ** 33 D2)
registersymbol(healthFlaskCalOnUseAOB)
alloc(newmem6,2048)
label(returnhere6)
label(originalcode6_ignorehealthflask)
registersymbol(originalcode6_ignorehealthflask)
label(exit6)
newmem6: //this is allocated memory, you have read,write,execute access
//place your code here
jns @f
xor edx,edx
originalcode6_ignorehealthflask:
readmem(healthFlaskCalOnUseAOB+10,6)
//mov [ebp-0000008C],edx
exit6:
jmp returnhere6
///
healthFlaskCalOnUseAOB+10: //087FC4E6:
jmp newmem6
nop
returnhere6:
///************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
healthFlaskRead1OnUseAttemptAOB+13: //088372CC:
db 0F 8C
//Alt: jl
///************************************///
healthFlaskRead2OnUseAttemptAOB+13: //087FBB89:
readmem(originalcode2_ignorehealthflask,6)
//db 0F 8D 8A 01 00 00
//Alt: jnl 088EBD19
dealloc(originalcode2_ignorehealthflask)
unregistersymbol(originalcode2_ignorehealthflask)
///************************************///
dealloc(newmem6)
healthFlaskCalOnUseAOB+10: //087FC4E6:
readmem(originalcode6_ignorehealthflask,6)
//db 89 95 74 FF FF FF
//Alt: mov [ebp-0000008C],edx
unregistersymbol(originalcode6_ignorehealthflask)
///************************************///
9077
"ignore ammo .2"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(ammoChkZeroOnFireAOB,8B ** ** 89 ** ** 33 C9 89 ** ** 3B C8 0F 8C ** ** ** ** 8B ** ** 8B ** ** 89 ** ** 85 C0 75 ** 83 ** ** B8)
registersymbol(ammoChkZeroOnFireAOB)
ammoChkZeroOnFireAOB+d: //094364D6:
db 90 E9
///***************************************///
aobscan(ammoChkEmptyForMultiArrowsBow1AOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 33 C0 89 ** ** 3B C2 0F 8C ** ** ** ** 33 C0)
registersymbol(ammoChkEmptyForMultiArrowsBow1AOB)
ammoChkEmptyForMultiArrowsBow1AOB+13: //0931E340:
db 90 E9
///***************************************///
aobscan(ammoChkEmptyForMultiArrowsBow2AOB,8B ** ** 89 ** ** BA ** ** ** ** 89 ** ** 2B CA 89 ** ** 8B ** ** 89 ** ** 85 C9 75)
registersymbol(ammoChkEmptyForMultiArrowsBow2AOB)
ammoChkEmptyForMultiArrowsBow2AOB+1b: //0931E383:
db EB
///***************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
ammoChkZeroOnFireAOB+d: //094364D6:
db 0F 8C
//Alt: jl
/*
09436487 - 88 45 DB - mov [ebp-25],al
0943648A - E9 08000000 - jmp 09436497
0943648F - B9 01000000 - mov ecx,00000001 { 1 }
09436494 - 88 4D DB - mov [ebp-25],cl
09436497 - E9 05000000 - jmp 094364A1
0943649C - 33 D2 - xor edx,edx
0943649E - 88 55 DB - mov [ebp-25],dl
094364A1 - 33 C0 - xor eax,eax
094364A3 - 8A 45 DB - mov al,[ebp-25]
094364A6 - 84 C0 - test al,al
094364A8 - 0F84 B0060000 - je 09436B5E
094364AE - 8B 4D 08 - mov ecx,[ebp+08]
094364B1 - 8B 51 08 - mov edx,[ecx+08]
094364B4 - 89 55 F4 - mov [ebp-0C],edx
094364B7 - 85 D2 - test edx,edx
094364B9 - 75 0E - jne 094364C9
094364BB - 83 EC 0C - sub esp,0C { 12 }
094364BE - B8 B05BAA00 - mov eax,deadcells.exe+5BB0 { [68EC8B55] }
094364C3 - FF D0 - call eax
094364C5 - 89 6C 24 FC - mov [esp-04],ebp
>>>094364C9 - 8B 42 18 - mov eax,[edx+18]
094364CC - 89 45 F0 - mov [ebp-10],eax
094364CF - 33 C9 - xor ecx,ecx
094364D1 - 89 4D B4 - mov [ebp-4C],ecx
094364D4 - 3B C8 - cmp ecx,eax
>>>094364D6 - 0F8C 82060000 - jl 09436B5E
094364DC - 8B 4D 08 - mov ecx,[ebp+08]
094364DF - 8B 41 04 - mov eax,[ecx+04]
094364E2 - 89 45 B0 - mov [ebp-50],eax
094364E5 - 85 C0 - test eax,eax
094364E7 - 75 0E - jne 094364F7
094364E9 - 83 EC 0C - sub esp,0C { 12 }
094364EC - B8 B05BAA00 - mov eax,deadcells.exe+5BB0 { [68EC8B55] }
094364F1 - FF D0 - call eax
094364F3 - 89 6C 24 FC - mov [esp-04],ebp
094364F7 - 8B 0D 38042B06 - mov ecx,[062B0438] { [00A53500] }
094364FD - 89 4D A8 - mov [ebp-58],ecx
09436500 - 8B 51 24 - mov edx,[ecx+24]
09436503 - 89 55 AC - mov [ebp-54],edx
09436506 - 85 D2 - test edx,edx
09436508 - 75 0E - jne 09436518
0943650A - 83 EC 0C - sub esp,0C { 12 }
0943650D - B8 B05BAA00 - mov eax,deadcells.exe+5BB0 { [68EC8B55] }
09436512 - FF D0 - call eax
09436514 - 89 6C 24 FC - mov [esp-04],ebp
09436518 - 83 EC 08 - sub esp,08 { 8 }
*/
///***************************************///
ammoChkEmptyForMultiArrowsBow1AOB+13: //0931E340:
db 0F 8C
//Alt: jl
///***************************************///
ammoChkEmptyForMultiArrowsBow2AOB+1b: //0931E383:
db 75
//Alt: jne
///***************************************///
9100
"ignore skill cooldown"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
luaCall(lua_aobscan("rightSkillCaller","","83 ** ** 51 E8 ** ** ** ** 89 **** ** 83 ** ** 88 ** ** 84 C0 0F 84 ** ** ** ** 33 D2",2))
luaCall(lua_aobscan("leftSkillCaller","","83 ** ** 51 E8 ** ** ** ** 89 **** ** 83 ** ** 88 ** ** 84 C0 0F 84 ** ** ** ** 33 D2",1))
///
aobscan(skillCooldownReadOnUseAOB,83 ** ** 8B ** ** F2 0F 10 ** ** F2 0F 11 ** ** 33 D2 89 ** ** F2 0F 2A ** F2 0F 11 ** ** 66 ** ** ** 7B ** 33 C9 0F 82 ** ** ** ** F2 0F 10)
registersymbol(skillCooldownReadOnUseAOB)
alloc(newmem,2048)
label(returnhere)
label(originalcode_ignoreskillcooldown)
registersymbol(originalcode_ignoreskillcooldown)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
//cmp eax,0DF8FAF8
//jne @f
//movsd xmm1,[eax+78]
//
//@@:
mov edx,rightSkillCaller
lea edx,[edx+9]
cmp [ebp+4],edx
je @f
mov edx,leftSkillCaller
lea edx,[edx+9]
cmp [ebp+4],edx
je @f
jmp end
@@:
xorps xmm1,xmm1
readmem(skillCooldownReadOnUseAOB+6,2)
db 11
readmem(skillCooldownReadOnUseAOB+9,2)
//movsd [eax+78],xmm1
end:
originalcode_ignoreskillcooldown:
readmem(skillCooldownReadOnUseAOB+6,5)
//movsd xmm1,[eax+78]
exit:
jmp returnhere
///
skillCooldownReadOnUseAOB+6: //0946BBA9:
jmp newmem
returnhere:
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
skillCooldownReadOnUseAOB+6: //0946BBA9:
readmem(originalcode_ignoreskillcooldown,5)
//db F2 0F 10 48 78
//Alt: movsd xmm1,[eax+78]
unregistersymbol(originalcode_ignoreskillcooldown)
9081
"inf double jump"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(airJumpCountCalOnAirJumpAOB,8B ** ** 8B ** ** ** ** ** 89 ** ** 42 89 ** ** 89 ** ** ** ** ** 33 C0)
registersymbol(airJumpCountCalOnAirJumpAOB)
alloc(newmem,2048)
label(returnhere)
label(originalcode_infdoublejump)
registersymbol(originalcode_infdoublejump)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
xor edx,edx
originalcode_infdoublejump:
readmem(airJumpCountCalOnAirJumpAOB+d,9)
//mov [ebp-0C],edx
//mov [ecx+00000290],edx
exit:
jmp returnhere
///
airJumpCountCalOnAirJumpAOB+d: //088B893B:
jmp newmem
nop
nop
nop
nop
returnhere:
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
airJumpCountCalOnAirJumpAOB+d: //088B893B:
readmem(originalcode_infdoublejump,9)
//db 89 55 F4 89 91 90 02 00 00
//Alt: mov [ebp-0C],edx
//Alt: mov [ecx+00000290],edx
unregistersymbol(originalcode_infdoublejump)
/*
088B88F8 - 89 55 D0 - mov [ebp-30],edx
088B88FB - 85 D2 - test edx,edx
088B88FD - 0F84 2B000000 - je 088B892E
088B8903 - 8B 91 30020000 - mov edx,[ecx+00000230]
088B8909 - 89 55 D0 - mov [ebp-30],edx
088B890C - 85 D2 - test edx,edx
088B890E - 75 0E - jne 088B891E
088B8910 - 83 EC 0C - sub esp,0C { 12 }
088B8913 - B8 B05BAA00 - mov eax,deadcells.exe+5BB0 { [68EC8B55] }
088B8918 - FF D0 - call eax
088B891A - 89 6C 24 FC - mov [esp-04],ebp
088B891E - 83 EC 08 - sub esp,08 { 8 }
088B8921 - 52 - push edx
088B8922 - E8 793CCF00 - call 095AC5A0
088B8927 - 89 6C 24 FC - mov [esp-04],ebp
088B892B - 83 C4 0C - add esp,0C { 12 }
>>>088B892E - 8B 4D 08 - mov ecx,[ebp+08]
088B8931 - 8B 91 90020000 - mov edx,[ecx+00000290]
088B8937 - 89 55 F4 - mov [ebp-0C],edx
088B893A - 42 - inc edx
>>>088B893B - 89 55 F4 - mov [ebp-0C],edx
088B893E - 89 91 90020000 - mov [ecx+00000290],edx
088B8944 - 33 C0 - xor eax,eax
088B8946 - 89 45 CC - mov [ebp-34],eax
088B8949 - 89 81 4C010000 - mov [ecx+0000014C],eax
088B894F - 8B 51 4C - mov edx,[ecx+4C]
088B8952 - 89 55 F4 - mov [ebp-0C],edx
088B8955 - F2 0F2A FA - cvtsi2sd xmm7,edx
088B8959 - F2 0F11 7D C0 - movsd [ebp-40],xmm7
088B895E - F2 0F10 41 58 - movsd xmm0,[ecx+58]
088B8963 - F2 0F11 45 B8 - movsd [ebp-48],xmm0
088B8968 - F2 0F58 F8 - addsd xmm7,xmm0
088B896C - F2 0F11 7D C0 - movsd [ebp-40],xmm7
088B8971 - BA 18000000 - mov edx,00000018 { 24 }
088B8976 - 89 55 F4 - mov [ebp-0C],edx
088B8979 - F2 0F2A C2 - cvtsi2sd xmm0,edx
088B897D - F2 0F11 45 B8 - movsd [ebp-48],xmm0
088B8982 - F2 0F59 F8 - mulsd xmm7,xmm0
088B8986 - F2 0F11 7D C0 - movsd [ebp-40],xmm7
088B898B - F2 0F11 B9 50010000 - movsd [ecx+00000150],xmm7
088B8993 - F2 0F10 49 78 - movsd xmm1,[ecx+78]
*/
9095
"ignore gold .4"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(goldReadOnDoorAttemptAOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 83 ** ** FF ** ** E8 ** ** ** ** 89)
registersymbol(goldReadOnDoorAttemptAOB)
alloc(newmem,2048)
label(returnhere)
label(originalcode_ignoregold)
registersymbol(originalcode_ignoregold)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
mov [pGold],eax
originalcode_ignoregold:
readmem(goldReadOnDoorAttemptAOB+6,6)
//mov ecx,[eax+34]
//mov [ebp-04],ecx
exit:
jmp returnhere
///
goldReadOnDoorAttemptAOB+6: //08C36A11:
jmp newmem
nop
returnhere:
///******************************************///
aobscan(goldChkOnDoorOpenAttemptAOB,8B D5 83 ** ** 52 B8 ** ** ** ** FF D0 89 ** ** ** 83 ** ** 89 ** ** 8B ** ** 3B C8 0F 8D ** ** ** ** 8B)
registersymbol(goldChkOnDoorOpenAttemptAOB)
goldChkOnDoorOpenAttemptAOB+1c: //08A86A52:
db 90 E9
///******************************************///
aobscan(goldChkOnBuyAttemptAOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 8B ** ** 8B ** ** ** ** ** 89 ** ** 3B C8 0F 8C)
registersymbol(goldChkOnBuyAttemptAOB)
alloc(originalcode6_ignoregold,8)
registersymbol(originalcode6_ignoregold)
originalcode6_ignoregold:
readmem(goldChkOnBuyAttemptAOB+1a,6)
///
goldChkOnBuyAttemptAOB+1a: //08A09713:
db 90 90 90 90 90 90
///******************************************///
aobscan(goldChkOnMutationsResetAttempt1AOB,8B ** ** 89 ** ** 83 ** ** FF ** ** E8 ** ** ** ** 89 ** ** ** 83 ** ** 89 ** ** 8B ** ** 3B D0 0F 8D)
registersymbol(goldChkOnMutationsResetAttempt1AOB)
goldChkOnMutationsResetAttempt1AOB+20: //096D1BA7:
db 90 E9
///******************************************///
aobscan(goldChkOnMutationsResetAttempt2AOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 83 ** ** FF ** ** E8 ** ** ** ** 89 ** ** ** 83 ** ** 89 ** ** 8B ** ** 3B C8 0F 8D ** ** ** ** 8B ** ** 83 ** ** 5D C3)
registersymbol(goldChkOnMutationsResetAttempt2AOB)
goldChkOnMutationsResetAttempt2AOB+26: //096D8B40:
db 90 E9
///******************************************///
aobscan(goldCalOnChangeAOB,75 ** 83 ** ** B8 ** ** ** ** FF D0 89 ** ** ** 8B ** ** 89 ** ** 3B ** ** 0F 8D ** ** ** ** 83 ** ** 68 ** ** ** ** B8)
registersymbol(goldCalOnChangeAOB)
alloc(newmem24,2048)
label(returnhere24)
label(originalcode24_ignoregold)
registersymbol(originalcode24_ignoregold)
label(exit24)
newmem24: //this is allocated memory, you have read,write,execute access
//place your code here
db 8B
readmem(goldCalOnChangeAOB+17,2)
//mov ecx,[ebp+c]
db 39
readmem(goldCalOnChangeAOB+11,2)
//cmp [eax+34],ecx
jge @f
readmem(goldCalOnChangeAOB+13,1)
readmem(goldCalOnChangeAOB+11,2)
//mov [eax+34],ecx
originalcode24_ignoregold:
readmem(goldCalOnChangeAOB+10,6)
//mov ecx,[eax+34]
//mov [ebp-0C],ecx
exit24:
jmp returnhere24
///
goldCalOnChangeAOB+10: //08811CD4:
jmp newmem24
nop
returnhere24:
///******************************************///
aobscan(goldChkOnUpgradeInMinorForgeAOB,8B ** ** 89 ** ** 8B ** ** 8B ** ** 89 ** ** 3B C8 0F 8D ** ** ** ** 33 C9)
registersymbol(goldChkOnUpgradeInMinorForgeAOB)
goldChkOnUpgradeInMinorForgeAOB+11: //094D5848:
db 90 E9
///******************************************///
aobscan(goldChkOnReforgeInMinorForgeAOB,FF D0 89 ** ** ** 8B ** ** 89 ** ** 3B ** ** 0F 8D ** ** ** ** 33 C9 88 ** ** 8B C1 81 ** ** ** ** ** 5D C3)
registersymbol(goldChkOnReforgeInMinorForgeAOB)
goldChkOnReforgeInMinorForgeAOB+f: //094D4865:
db 90 E9
///******************************************///
aobscan(goldChkOnRestockAttemptAOB,F2 0F 11 ** ** E8 ** ** ** ** 89 ** ** ** 83 ** ** 89 ** ** 8B ** ** 3B C8 0F 8D)
registersymbol(goldChkOnRestockAttemptAOB)
goldChkOnRestockAttemptAOB+19: //08C3349F:
db 90 E9
///******************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
goldReadOnDoorAttemptAOB+6: //08C36A11:
readmem(originalcode_ignoregold,6)
//db 8B 48 34 89 4D FC
//Alt: mov ecx,[eax+34]
//Alt: mov [ebp-04],ecx
unregistersymbol(originalcode_ignoregold)
///******************************************///
goldChkOnDoorOpenAttemptAOB+1c: //08A86A52:
db 0F 8D
//Alt: jnl
///******************************************///
goldChkOnBuyAttemptAOB+1a: //08A09713:
db 0F 8C AD 00 00 00
//Alt: jl 08A097C6
dealloc(originalcode6_ignoregold)
unregistersymbol(originalcode6_ignoregold)
///******************************************///
goldChkOnMutationsResetAttempt1AOB+20: //096D1BA7:
db 0F 8D
//Alt: jnl
///******************************************///
goldChkOnMutationsResetAttempt2AOB+26: //096D8B40:
db 0F 8D
//Alt: jnl
///******************************************///
dealloc(newmem24)
goldCalOnChangeAOB+10: //08811CD4:
readmem(originalcode24_ignoregold,6)
//db 8B 48 34 89 4D F4
//Alt: mov ecx,[eax+34]
//Alt: mov [ebp-0C],ecx
unregistersymbol(originalcode24_ignoregold)
///******************************************///
goldChkOnUpgradeInMinorForgeAOB+11: //094D5848:
db 0F 8D
//Alt: jnl
///******************************************///
goldChkOnReforgeInMinorForgeAOB+f: //094D4865:
db 0F 8D
//Alt: jnl
///******************************************///
goldChkOnRestockAttemptAOB+19: //08C3349F:
db 0F 8D
//Alt: jnl
///******************************************///
9105
"ignore cell .2"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(cellsReadOnUseAOB,8B ** ** ** ** ** 89 ** ** 33 C9 89 ** ** 3B ** ** 0F 8D ** ** ** ** 8B ** ** 33 C0)
registersymbol(cellsReadOnUseAOB)
alloc(originalcode_ignorecell,8)
registersymbol(originalcode_ignorecell)
originalcode_ignorecell:
readmem(cellsReadOnUseAOB+11,6)
///
cellsReadOnUseAOB+11: //095A3DF8:
db 90 90 90 90 90 90
///****************************************///
aobscan(cellChkOnUse2AOB,8B ** ** ** ** ** 89 ** ** 33 C0 89 ** ** 3B ** ** 0F 8C ** ** ** ** 33 C0)
registersymbol(cellChkOnUse2AOB)
cellChkOnUse2AOB+11: //094C968B:
db 90 E9
///****************************************///
aobscan(cellCalOnUse2AOB,FF D0 89 ** ** ** 8B ** ** ** ** ** 89 ** ** 49 89 ** ** 89 ** ** ** ** ** 8B ** ** ** ** ** 89 ** ** 8B ** ** 89 ** ** 85 C0 75)
registersymbol(cellCalOnUse2AOB)
alloc(newmem6,2048)
label(returnhere6)
label(originalcode6_ignorecell)
registersymbol(originalcode6_ignorecell)
label(exit6)
newmem6: //this is allocated memory, you have read,write,execute access
//place your code here
jns @f
xor ecx,ecx
originalcode6_ignorecell:
readmem(cellCalOnUse2AOB+10,9)
//mov [ebp-04],ecx
//mov [eax+0000031C],ecx
exit6:
jmp returnhere6
///
cellCalOnUse2AOB+10: //094C97AC:
jmp newmem6
nop
nop
nop
nop
returnhere6:
///****************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
cellsReadOnUseAOB+11: //095A3DF8:
readmem(originalcode_ignorecell,6)
//db 0F 8D 16 00 00 00
//Alt: jnl 095A3E14
dealloc(originalcode_ignorecell)
unregistersymbol(originalcode_ignorecell)
///****************************************///
cellChkOnUse2AOB+11: //094C968B:
db 0F 8C
//Alt: jl
///****************************************///
dealloc(newmem6)
cellCalOnUse2AOB+10: //094C97AC:
readmem(originalcode6_ignorecell,9)
//db 89 4D FC 89 88 1C 03 00 00
//Alt: mov [ebp-04],ecx
//Alt: mov [eax+0000031C],ecx
unregistersymbol(originalcode6_ignorecell)
///****************************************///
9133
"unlock timed door"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(timeChkForTimeDoorUnlock,F2 0F 10 ** ** F2 0F 11 ** ** F2 0F 5C FB F2 0F 11 ** ** 33 C9)
registersymbol(timeChkForTimeDoorUnlock)
alloc(newmem,2048)
label(returnhere)
label(originalcode_unlocktimedoor)
registersymbol(originalcode_unlocktimedoor)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
comisd xmm7,[mdone]
jae @f
movsd xmm7,[mdone]
originalcode_unlocktimedoor:
readmem(timeChkForTimeDoorUnlock+e,5)
//movsd [ebp-38],xmm7
exit:
jmp returnhere
///
mdone:
dq (double)1
///
timeChkForTimeDoorUnlock+e: //08ADBEE2:
jmp newmem
returnhere:
///***********************************///
aobscan(timeReadForTimeDoorUnlockTimeAOB,F2 0F 10 ** ** F2 0F 11 ** ** ** ** ** F2 0F 5C E9 F2 0F 11 ** ** ** ** ** B8 01 00 00 00)
registersymbol(timeReadForTimeDoorUnlockTimeAOB)
alloc(newmem2,2048)
label(returnhere2)
label(originalcode2_unlocktimedoor)
registersymbol(originalcode2_unlocktimedoor)
label(exit2)
newmem2: //this is allocated memory, you have read,write,execute access
//place your code here
comisd xmm5,[mdzero]
jae @f
movsd xmm5,[mdzero]
originalcode2_unlocktimedoor:
readmem(timeReadForTimeDoorUnlockTimeAOB+11,8)
//movsd [ebp-000000C0],xmm5
exit2:
jmp returnhere2
///
mdzero:
dq 0
///
timeReadForTimeDoorUnlockTimeAOB+11: //08D3D101:
jmp newmem2
nop
nop
nop
returnhere2:
///***********************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
timeChkForTimeDoorUnlock+e: //08ADBEE2:
readmem(originalcode_unlocktimedoor,5)
//db F2 0F 11 7D C8
//Alt: movsd [ebp-38],xmm7
unregistersymbol(originalcode_unlocktimedoor)
///***********************************///
dealloc(newmem2)
timeReadForTimeDoorUnlockTimeAOB+11: //08D3D101:
readmem(originalcode2_unlocktimedoor,8)
//db F2 0F 11 AD 40 FF FF FF
//Alt: movsd [ebp-000000C0],xmm5
unregistersymbol(originalcode2_unlocktimedoor)
///***********************************///
9140
"sprint key .2"
FF0000
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
aobscan(consecutiveKillsReadOnMoveAOB,8B ** ** ** ** ** 89 ** ** F2 0F 2A ** F2 0F 11 ** ** ** ** ** ** 08 00 00 00 89 ** ** F2 0F 2A ** F2 0F 11 ** ** ** ** ** 66 0F 2F E8 7B ** 33 D2)
registersymbol(consecutiveKillsReadOnMoveAOB)
label(bSprintKeyID)
registersymbol(bSprintKeyID)
label(qSprintSpeed)
registersymbol(qSprintSpeed)
alloc(newmem,2048)
label(returnhere)
label(originalcode_sprintkey)
registersymbol(originalcode_sprintkey)
label(exit)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
//
pushad
sub esp,10
movdqu dqword [esp],xmm5
sub esp,10
movdqu dqword [esp],xmm4
sub esp,10
movdqu dqword [esp],xmm3
sub esp,10
movdqu dqword [esp],xmm2
sub esp,10
movdqu dqword [esp],xmm1
sub esp,10
movdqu dqword [esp],xmm0
//
push [bSprintKeyID]
call GetAsyncKeyState
shr ax,#15
cmp ax,1
jne @f
mov byte ptr [bSprintKeyID+4],1
@@:
//
movdqu xmm0,dqword [esp]
add esp,10
movdqu xmm1,dqword [esp]
add esp,10
movdqu xmm2,dqword [esp]
add esp,10
movdqu xmm3,dqword [esp]
add esp,10
movdqu xmm4,dqword [esp]
add esp,10
movdqu xmm5,dqword [esp]
add esp,10
popad
//
cmp byte ptr [bSprintKeyID+4],1
jne end
mov byte ptr [bSprintKeyID+4],0
cmp ecx,32
jge @f
mov ecx,32
@@:
movsd xmm5,[qSprintSpeed]
subsd xmm5,[qSprintSpeed+8]
movsd [ebp-40],xmm5
end:
originalcode_sprintkey:
readmem(consecutiveKillsReadOnMoveAOB+6,7)
//mov [ebp-14],ecx
//cvtsi2sd xmm5,ecx
exit:
jmp returnhere
///
bSprintKeyID:
dd 10
dd 0
qSprintSpeed:
dq (double)2
dq (double)1
///
consecutiveKillsReadOnMoveAOB+6: //0888F02D:
jmp newmem
nop
nop
returnhere:
///********************************************///
aobscan(consecutiveKillsRead1AOB,8B ** ** ** ** ** 89 ** ** F2 0F 2A ** F2 0F 11 ** ** ** 08 00 00 00 89 ** ** F2 0F 2A ** F2 0F 11 ** ** 66 0F 2F D3 7B ** 33 C9)
registersymbol(consecutiveKillsRead1AOB)
alloc(newmem2,2048)
label(returnhere2)
label(originalcode2_sprintkey)
registersymbol(originalcode2_sprintkey)
label(exit2)
newmem2: //this is allocated memory, you have read,write,execute access
//place your code here
//
pushad
sub esp,10
movdqu dqword [esp],xmm5
sub esp,10
movdqu dqword [esp],xmm4
sub esp,10
movdqu dqword [esp],xmm3
sub esp,10
movdqu dqword [esp],xmm2
sub esp,10
movdqu dqword [esp],xmm1
sub esp,10
movdqu dqword [esp],xmm0
//
push [bSprintKeyID]
call GetAsyncKeyState
shr ax,#15
cmp ax,1
jne @f
mov byte ptr [bSprintKeyID+4],1
@@:
//
movdqu xmm0,dqword [esp]
add esp,10
movdqu xmm1,dqword [esp]
add esp,10
movdqu xmm2,dqword [esp]
add esp,10
movdqu xmm3,dqword [esp]
add esp,10
movdqu xmm4,dqword [esp]
add esp,10
movdqu xmm5,dqword [esp]
add esp,10
popad
//
cmp byte ptr [bSprintKeyID+4],1
jne @f
mov byte ptr [bSprintKeyID+4],0
cmp eax,32
jge @f
mov eax,32
originalcode2_sprintkey:
readmem(consecutiveKillsRead1AOB+6,7)
//mov [ebp-10],eax
//cvtsi2sd xmm2,eax
exit2:
jmp returnhere2
///
consecutiveKillsRead1AOB+6: //087C4804:
jmp newmem2
nop
nop
returnhere2:
///********************************************///
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(newmem)
consecutiveKillsReadOnMoveAOB+6: //0888F02D:
readmem(originalcode_sprintkey,7)
//db 89 4D EC F2 0F 2A E9
//Alt: mov [ebp-14],ecx
//Alt: cvtsi2sd xmm5,ecx
unregistersymbol(originalcode_sprintkey)
unregistersymbol(bSprintKeyID)
unregistersymbol(qSprintSpeed)
///********************************************///
dealloc(newmem2)
consecutiveKillsRead1AOB+6: //087C4804:
readmem(originalcode2_sprintkey,7)
//db 89 45 F0 F2 0F 2A D0
//Alt: mov [ebp-10],eax
//Alt: cvtsi2sd xmm2,eax
unregistersymbol(originalcode2_sprintkey)
///********************************************///
173
"key"
10:SHIFT key
11:CTRL key
12:ALT key
14:CAPS LOCK key
1
008000
Byte
bSprintKeyID
9146
"speed (x?)"
008000
Double
qSprintSpeed
http://fearlessrevolution.com/threads/dead-cells-v1-0-cheat-engine-table-v4-1-final.1790/page-7#post-54593