26721
"SymbolListDemo"
FF0000
Auto Assembler Script
[ENABLE]
{$lua}
DeleteUserdefinedSymbols()
{$asm}
[DISABLE]
{$lua}
{$asm}
26722
"CE compact mode"
FF0000
Auto Assembler Script
[ENABLE]
{$lua}
function ToggleCECompactMode()
local f = getMainForm()
local controls = {f.Splitter1, f.Panel4, f.Panel5}
for k,c in ipairs(controls) do c.Visible = not c.Visible end
end
ToggleCECompactMode()
{$asm}
[DISABLE]
{$lua}
ToggleCECompactMode()
26724
"CE compact mode 2"
FF0000
Auto Assembler Script
[ENABLE]
{$lua}
if not CheatTable then CheatTable = { } end
----
---- Disables compact mode for the cheat table.
function CheatTable.disableCompactMode()
MainForm.Splitter1.Visible = true
MainForm.Panel5.Visible = true
CheatTable.CompactModeEnabled = false
end
----
---- Enables compact mode for the cheat table.
function CheatTable.enableCompactMode()
MainForm.Splitter1.Visible = false
MainForm.Panel5.Visible = false
CheatTable.CompactModeEnabled = true
end
----
---- Toggles compact mode for the cheat table.
function CheatTable.toggleCompactMode()
if CheatTable.CompactModeEnabled then
CheatTable.disableCompactMode()
else
CheatTable.enableCompactMode()
end
end
----
---- Adds the compact mode menu item to the cheat table.
function CheatTable.addCompactModeMenu()
local name = 'miCTCompactMode'
local miCompactMode = nil
for i = 1, MainForm.Menu.Items.Count - 1 do
if MainForm.Menu.Items[i].Name == name then
miCompactMode = MainForm.Menu.Items[i]
break
end
end
if not miCompactMode then
miCompactMode = createMenuItem(MainForm.Menu.Items)
miCompactMode.Name = name
miCompactMode.Caption = translate('Toggle Compact Mode')
miCompactMode.OnClick = CheatTable.toggleCompactMode
MainForm.Menu.Items.add(miCompactMode)
end
end
CheatTable.toggleCompactMode()
{$asm}
[DISABLE]
{$lua}
CheatTable.toggleCompactMode()
9210
"Attach CE to game process"
FF0000
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
OpenProcess("OxygenNotIncluded.exe")
{$asm}
[DISABLE]
Activate
18
45
0
Activate
Deactivate
18
46
1
Deactivate
Toggle Activation
17
99
2
Activate
Deactivate
675
"Fast working"
Auto Assembler Script
define(bytes,F3 0F 10 85 00 FF FF FF)
[ENABLE]
{$lua}
mono_register("Workable","GetEfficiencyMultiplier","ptrGetEfficiencyMultiplier")
{$asm}
assert(ptrGetEfficiencyMultiplier+4f9,bytes)
alloc(memGetEfficiencyMultiplier,$1000,ptrGetEfficiencyMultiplier)
label(code)
label(return)
memGetEfficiencyMultiplier:
code:
mov [rbp-00000100],(float)100.0
movss xmm0,[rbp-00000100]
jmp return
ptrGetEfficiencyMultiplier+4f9:
jmp memGetEfficiencyMultiplier
nop 3
return:
[DISABLE]
ptrGetEfficiencyMultiplier+4f9:
db bytes
unregistersymbol(ptrGetEfficiencyMultiplier)
dealloc(memGetEfficiencyMultiplier)
{
// ORIGINAL CODE - INJECTION POINT: Workable:GetEfficiencyMultiplier+4f9
Workable:GetEfficiencyMultiplier+4b9: F3 0F 10 85 08 FF FF FF - movss xmm0,[rbp-000000F8]
Workable:GetEfficiencyMultiplier+4c1: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Workable:GetEfficiencyMultiplier+4c5: F2 0F 11 85 F8 FE FF FF - movsd [rbp-00000108],xmm0
Workable:GetEfficiencyMultiplier+4cd: F2 0F 10 85 F8 FE FF FF - movsd xmm0,[rbp-00000108]
Workable:GetEfficiencyMultiplier+4d5: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Workable:GetEfficiencyMultiplier+4d9: F3 0F 11 AD 00 FF FF FF - movss [rbp-00000100],xmm5
Workable:GetEfficiencyMultiplier+4e1: F3 0F 10 85 00 FF FF FF - movss xmm0,[rbp-00000100]
Workable:GetEfficiencyMultiplier+4e9: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Workable:GetEfficiencyMultiplier+4ed: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Workable:GetEfficiencyMultiplier+4f1: F3 0F 11 AD 00 FF FF FF - movss [rbp-00000100],xmm5
// ---------- INJECTING HERE ----------
Workable:GetEfficiencyMultiplier+4f9: F3 0F 10 85 00 FF FF FF - movss xmm0,[rbp-00000100]
// ---------- DONE INJECTING ----------
Workable:GetEfficiencyMultiplier+501: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Workable:GetEfficiencyMultiplier+505: F2 0F 5A C0 - cvtsd2ss xmm0,xmm0
Workable:GetEfficiencyMultiplier+509: 48 8B 75 D0 - mov rsi,[rbp-30]
Workable:GetEfficiencyMultiplier+50d: 48 8B 7D D8 - mov rdi,[rbp-28]
Workable:GetEfficiencyMultiplier+511: 4C 8B 65 E0 - mov r12,[rbp-20]
Workable:GetEfficiencyMultiplier+515: 4C 8B 6D E8 - mov r13,[rbp-18]
Workable:GetEfficiencyMultiplier+519: 4C 8B 75 F0 - mov r14,[rbp-10]
Workable:GetEfficiencyMultiplier+51d: 4C 8B 7D F8 - mov r15,[rbp-08]
Workable:GetEfficiencyMultiplier+521: 48 8D 65 00 - lea rsp,[rbp+00]
Workable:GetEfficiencyMultiplier+525: 5D - pop rbp
}
676
"Fast research"
Auto Assembler Script
define(bytes,F3 0F 10 86 7C 01 00 00)
[ENABLE]
{$lua}
mono_register("ResearchCenter","ConvertMassToResearchPoints","ptrConvertMassToResearchPoints")
{$asm}
assert(ptrConvertMassToResearchPoints+108,bytes)
alloc(memConvertMassToResearchPoints,$1000,ptrConvertMassToResearchPoints)
label(code)
label(return)
memConvertMassToResearchPoints:
code:
mov [rsi+0000017C],(float)0.99
movss xmm0,[rsi+0000017C]
jmp return
ptrConvertMassToResearchPoints+108:
jmp memConvertMassToResearchPoints
nop 3
return:
[DISABLE]
ptrConvertMassToResearchPoints+108:
db bytes
unregistersymbol(ptrConvertMassToResearchPoints)
dealloc(memConvertMassToResearchPoints)
{
// ORIGINAL CODE - INJECTION POINT: ResearchCenter:ConvertMassToResearchPoints+108
ResearchCenter:ConvertMassToResearchPoints+da: F3 0F 10 86 7C 01 00 00 - movss xmm0,[rsi+0000017C]
ResearchCenter:ConvertMassToResearchPoints+e2: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
ResearchCenter:ConvertMassToResearchPoints+e6: F2 0F 5A C0 - cvtsd2ss xmm0,xmm0
ResearchCenter:ConvertMassToResearchPoints+ea: 48 8D 6D 00 - lea rbp,[rbp+00]
ResearchCenter:ConvertMassToResearchPoints+ee: 49 BB 60 61 42 4D B8 01 00 00 - mov r11,UnityEngine.Mathf:FloorToInt
ResearchCenter:ConvertMassToResearchPoints+f8: 41 FF D3 - call r11
ResearchCenter:ConvertMassToResearchPoints+fb: 48 8B C8 - mov rcx,rax
ResearchCenter:ConvertMassToResearchPoints+fe: 48 8B 45 C0 - mov rax,[rbp-40]
ResearchCenter:ConvertMassToResearchPoints+102: 4C 8B F8 - mov r15,rax
ResearchCenter:ConvertMassToResearchPoints+105: 44 03 F9 - add r15d,ecx
// ---------- INJECTING HERE ----------
ResearchCenter:ConvertMassToResearchPoints+108: F3 0F 10 86 7C 01 00 00 - movss xmm0,[rsi+0000017C]
// ---------- DONE INJECTING ----------
ResearchCenter:ConvertMassToResearchPoints+110: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
ResearchCenter:ConvertMassToResearchPoints+114: F2 0F 11 45 C8 - movsd [rbp-38],xmm0
ResearchCenter:ConvertMassToResearchPoints+119: F3 0F 10 86 7C 01 00 00 - movss xmm0,[rsi+0000017C]
ResearchCenter:ConvertMassToResearchPoints+121: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
ResearchCenter:ConvertMassToResearchPoints+125: F2 0F 5A C0 - cvtsd2ss xmm0,xmm0
ResearchCenter:ConvertMassToResearchPoints+129: 48 8D 64 24 00 - lea rsp,[rsp+00]
ResearchCenter:ConvertMassToResearchPoints+12e: 49 BB 60 61 42 4D B8 01 00 00 - mov r11,UnityEngine.Mathf:FloorToInt
ResearchCenter:ConvertMassToResearchPoints+138: 41 FF D3 - call r11
ResearchCenter:ConvertMassToResearchPoints+13b: F2 0F 10 45 C8 - movsd xmm0,[rbp-38]
ResearchCenter:ConvertMassToResearchPoints+140: F3 0F 2A C8 - cvtsi2ss xmm1,eax
}
677
"Fast attribute leveling"
Auto Assembler Script
define(bytes,F3 0F 10 45 C8)
[ENABLE]
{$lua}
mono_register("AttributeLevels","AddExperience","ptrAddExperience")
{$asm}
assert(ptrAddExperience+7a,bytes)
alloc(memAddExperience,$1000,ptrAddExperience)
label(code)
label(return)
memAddExperience:
code:
mov [rbp-38],(float)1000.0 // multiplier
movss xmm0,[rbp-38]
jmp return
ptrAddExperience+7a:
jmp memAddExperience
return:
[DISABLE]
ptrAddExperience+7a:
db bytes
unregistersymbol(ptrAddExperience)
dealloc(memAddExperience)
{
// ORIGINAL CODE - INJECTION POINT: Klei.AI.AttributeLevels:AddExperience+7a
Klei.AI.AttributeLevels:AddExperience+46: 48 BA C0 60 74 4A B8 01 00 00 - mov rdx,000001B84A7460C0
Klei.AI.AttributeLevels:AddExperience+50: 48 8D 64 24 00 - lea rsp,[rsp+00]
Klei.AI.AttributeLevels:AddExperience+55: 90 - nop
Klei.AI.AttributeLevels:AddExperience+56: 49 BB E7 08 0E 4E B6 01 00 00 - mov r11,000001B64E0E08E7
Klei.AI.AttributeLevels:AddExperience+60: 41 FF D3 - call r11
Klei.AI.AttributeLevels:AddExperience+63: 48 8B C8 - mov rcx,rax
Klei.AI.AttributeLevels:AddExperience+66: 49 BB 19 3C CF FC B6 01 00 00 - mov r11,000001B6FCCF3C19
Klei.AI.AttributeLevels:AddExperience+70: 41 FF D3 - call r11
Klei.AI.AttributeLevels:AddExperience+73: 33 C0 - xor eax,eax
Klei.AI.AttributeLevels:AddExperience+75: E9 FD 00 00 00 - jmp Klei.AI.AttributeLevels:AddExperience+177
// ---------- INJECTING HERE ----------
Klei.AI.AttributeLevels:AddExperience+7a: F3 0F 10 45 C8 - movss xmm0,[rbp-38]
// ---------- DONE INJECTING ----------
Klei.AI.AttributeLevels:AddExperience+7f: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Klei.AI.AttributeLevels:AddExperience+83: F3 0F 10 4D C0 - movss xmm1,[rbp-40]
Klei.AI.AttributeLevels:AddExperience+88: F3 0F 5A C9 - cvtss2sd xmm1,xmm1
Klei.AI.AttributeLevels:AddExperience+8c: F2 0F 59 C1 - mulsd xmm0,xmm1
Klei.AI.AttributeLevels:AddExperience+90: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Klei.AI.AttributeLevels:AddExperience+94: F3 0F 11 6D C8 - movss [rbp-38],xmm5
Klei.AI.AttributeLevels:AddExperience+99: 48 8D 64 24 00 - lea rsp,[rsp+00]
Klei.AI.AttributeLevels:AddExperience+9e: 49 BB 30 7C BE 28 B7 01 00 00 - mov r11,Db:Get
Klei.AI.AttributeLevels:AddExperience+a8: 41 FF D3 - call r11
Klei.AI.AttributeLevels:AddExperience+ab: 48 8B 40 70 - mov rax,[rax+70]
}
681
"Edit experience of selected duplicant"
Auto Assembler Script
define(bytes,F3 0F 10 80 98 00 00 00)
[ENABLE]
{$lua}
mono_register("MinionResume","get_TotalSkillPointsGained","ptrTotalSkillPointsGained")
{$asm}
assert(ptrTotalSkillPointsGained+f,bytes)
alloc(memTotalSkillPointsGained,$1000,ptrTotalSkillPointsGained)
label(code)
label(return)
label(MinionResume)
memTotalSkillPointsGained:
code:
mov [MinionResume],rax
movss xmm0,[rax+00000098]
jmp return
MinionResume:
dd 0
ptrTotalSkillPointsGained+f:
jmp memTotalSkillPointsGained
nop 3
return:
registersymbol(MinionResume)
[DISABLE]
ptrTotalSkillPointsGained+f:
db bytes
unregistersymbol(MinionResume)
unregistersymbol(ptrTotalSkillPointsGained)
dealloc(memTotalSkillPointsGained)
{
// ORIGINAL CODE - INJECTION POINT: MinionResume:get_TotalSkillPointsGained+f
1B851867FB6: 00 00 - add [rax],al
1B851867FB8: 00 00 - add [rax],al
1B851867FBA: 00 00 - add [rax],al
1B851867FBC: 00 00 - add [rax],al
1B851867FBE: 00 00 - add [rax],al
MinionResume:get_TotalSkillPointsGained: 55 - push rbp
MinionResume:get_TotalSkillPointsGained+1: 48 8B EC - mov rbp,rsp
MinionResume:get_TotalSkillPointsGained+4: 48 83 EC 30 - sub rsp,30
MinionResume:get_TotalSkillPointsGained+8: 48 89 4D F0 - mov [rbp-10],rcx
MinionResume:get_TotalSkillPointsGained+c: 48 8B C1 - mov rax,rcx
// ---------- INJECTING HERE ----------
MinionResume:get_TotalSkillPointsGained+f: F3 0F 10 80 98 00 00 00 - movss xmm0,[rax+00000098]
// ---------- DONE INJECTING ----------
MinionResume:get_TotalSkillPointsGained+17: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
MinionResume:get_TotalSkillPointsGained+1b: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
MinionResume:get_TotalSkillPointsGained+1f: F3 0F 11 6D FC - movss [rbp-04],xmm5
MinionResume:get_TotalSkillPointsGained+24: F3 0F 10 45 FC - movss xmm0,[rbp-04]
MinionResume:get_TotalSkillPointsGained+29: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
MinionResume:get_TotalSkillPointsGained+2d: F2 0F 5A C0 - cvtsd2ss xmm0,xmm0
MinionResume:get_TotalSkillPointsGained+31: 48 8D 64 24 00 - lea rsp,[rsp+00]
MinionResume:get_TotalSkillPointsGained+36: 49 BB 50 80 86 51 B8 01 00 00 - mov r11,MinionResume:CalculateTotalSkillPointsGained
MinionResume:get_TotalSkillPointsGained+40: 41 FF D3 - call r11
MinionResume:get_TotalSkillPointsGained+43: 48 8D 65 00 - lea rsp,[rbp+00]
}
682
"Experience"
0
Float
MinionResume
98
683
"Massive skill points"
Auto Assembler Script
define(bytes,F3 0F 11 AE 98 00 00 00 0F)
[ENABLE]
{$lua}
mono_register("MinionResume","AddExperience","ptrAddSkillExperience")
{$asm}
assert(ptrAddSkillExperience+75,bytes)
alloc(memAddSkillExperience,$1000,ptrAddSkillExperience)
label(code)
label(return)
memAddSkillExperience:
code:
mov [rsi+00000098],(float)446618.0 // 32 skill points
jmp return
ptrAddSkillExperience+75:
jmp memAddSkillExperience
nop 3
return:
[DISABLE]
ptrAddSkillExperience+75:
db bytes
unregistersymbol(ptrAddSkillExperience)
dealloc(memAddSkillExperience)
{
// ORIGINAL CODE - INJECTION POINT: MinionResume:AddExperience+75
MinionResume:AddExperience+48: 41 FF D3 - call r11
MinionResume:AddExperience+4b: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
MinionResume:AddExperience+4f: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
MinionResume:AddExperience+53: F3 0F 11 6D F0 - movss [rbp-10],xmm5
MinionResume:AddExperience+58: F3 0F 10 86 98 00 00 00 - movss xmm0,[rsi+00000098]
MinionResume:AddExperience+60: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
MinionResume:AddExperience+64: F3 0F 10 4D E8 - movss xmm1,[rbp-18]
MinionResume:AddExperience+69: F3 0F 5A C9 - cvtss2sd xmm1,xmm1
MinionResume:AddExperience+6d: F2 0F 58 C1 - addsd xmm0,xmm1
MinionResume:AddExperience+71: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
// ---------- INJECTING HERE ----------
MinionResume:AddExperience+75: F3 0F 11 AE 98 00 00 00 - movss [rsi+00000098],xmm5
// ---------- DONE INJECTING ----------
MinionResume:AddExperience+7d: 0F B6 46 23 - movzx eax,byte ptr [rsi+23]
MinionResume:AddExperience+81: 85 C0 - test eax,eax
MinionResume:AddExperience+83: 0F 84 52 00 00 00 - je MinionResume:AddExperience+db
MinionResume:AddExperience+89: F3 0F 10 86 98 00 00 00 - movss xmm0,[rsi+00000098]
MinionResume:AddExperience+91: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
MinionResume:AddExperience+95: F3 0F 10 4D F0 - movss xmm1,[rbp-10]
MinionResume:AddExperience+9a: F3 0F 5A C9 - cvtss2sd xmm1,xmm1
MinionResume:AddExperience+9e: 66 0F 2F C8 - comisd xmm1,xmm0
MinionResume:AddExperience+a2: 0F 8A 33 00 00 00 - jp MinionResume:AddExperience+db
MinionResume:AddExperience+a8: 0F 87 2D 00 00 00 - ja MinionResume:AddExperience+db
}
686
"Infinite battery"
Auto Assembler Script
define(bytes,F3 0F 10 47 58)
[ENABLE]
{$lua}
mono_register("Battery","ConsumeEnergy","ptrConsumeEnergy")
{$asm}
assert(ptrConsumeEnergy+23,bytes)
alloc(memConsumeEnergy,$1000,ptrConsumeEnergy)
label(code)
label(return)
memConsumeEnergy:
code:
movss xmm0,[rdi+50] // capacity
movss [rdi+58],xmm0 // joulesAvailable
movss xmm0,[rdi+58]
jmp return
ptrConsumeEnergy+23:
jmp memConsumeEnergy
return:
[DISABLE]
ptrConsumeEnergy+23:
db bytes
unregistersymbol(ptrConsumeEnergy)
dealloc(memConsumeEnergy)
{
// ORIGINAL CODE - INJECTION POINT: Battery:ConsumeEnergy+23
Battery:ConsumeEnergy: 55 - push rbp
Battery:ConsumeEnergy+1: 48 8B EC - mov rbp,rsp
Battery:ConsumeEnergy+4: 48 83 EC 70 - sub rsp,70
Battery:ConsumeEnergy+8: 48 89 75 F0 - mov [rbp-10],rsi
Battery:ConsumeEnergy+c: 48 89 7D F8 - mov [rbp-08],rdi
Battery:ConsumeEnergy+10: 48 8B F9 - mov rdi,rcx
Battery:ConsumeEnergy+13: F3 0F 11 4D D0 - movss [rbp-30],xmm1
Battery:ConsumeEnergy+18: 49 8B F0 - mov rsi,r8
Battery:ConsumeEnergy+1b: 85 F6 - test esi,esi
Battery:ConsumeEnergy+1d: 0F 84 58 01 00 00 - je Battery:ConsumeEnergy+17b
// ---------- INJECTING HERE ----------
Battery:ConsumeEnergy+23: F3 0F 10 47 58 - movss xmm0,[rdi+58]
// ---------- DONE INJECTING ----------
Battery:ConsumeEnergy+28: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Battery:ConsumeEnergy+2c: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Battery:ConsumeEnergy+30: F3 0F 11 6D E4 - movss [rbp-1C],xmm5
Battery:ConsumeEnergy+35: F3 0F 10 4D E4 - movss xmm1,[rbp-1C]
Battery:ConsumeEnergy+3a: F3 0F 5A C9 - cvtss2sd xmm1,xmm1
Battery:ConsumeEnergy+3e: F3 0F 10 45 D0 - movss xmm0,[rbp-30]
Battery:ConsumeEnergy+43: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Battery:ConsumeEnergy+47: F2 0F 5A E9 - cvtsd2ss xmm5,xmm1
Battery:ConsumeEnergy+4b: F3 0F 11 6D E4 - movss [rbp-1C],xmm5
Battery:ConsumeEnergy+50: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
}
131
"No negative traits on new duplicants"
Auto Assembler Script
[ENABLE]
{$lua}
mono_register("MinionStartingStats","GenerateTraits","ptrGenerateTraits")
{$asm}
assert(ptrGenerateTraits+6c3,7D 20)
ptrGenerateTraits+6c3:
db EB // jmp
[DISABLE]
ptrGenerateTraits+6c3:
db 7D // jnl
unregisterSymbol(ptrGenerateTraits)
{
// ORIGINAL CODE - INJECTION POINT: MinionStartingStats:GenerateTraits+6c3
MinionStartingStats:GenerateTraits+69e: 7C A8 - jl MinionStartingStats:GenerateTraits+648
MinionStartingStats:GenerateTraits+6a0: 0F B6 45 88 - movzx eax,byte ptr [rbp-78]
MinionStartingStats:GenerateTraits+6a4: 85 C0 - test eax,eax
MinionStartingStats:GenerateTraits+6a6: 74 08 - je MinionStartingStats:GenerateTraits+6b0
MinionStartingStats:GenerateTraits+6a8: 41 FF C5 - inc r13d
MinionStartingStats:GenerateTraits+6ab: E9 60 00 00 00 - jmp MinionStartingStats:GenerateTraits+710
MinionStartingStats:GenerateTraits+6b0: 83 45 A0 01 - add dword ptr [rbp-60],01
MinionStartingStats:GenerateTraits+6b4: E9 57 00 00 00 - jmp MinionStartingStats:GenerateTraits+710
MinionStartingStats:GenerateTraits+6b9: 48 8D AD 00 00 00 00 - lea rbp,[rbp+00000000]
MinionStartingStats:GenerateTraits+6c0: 39 75 A0 - cmp [rbp-60],esi
// ---------- INJECTING HERE ----------
MinionStartingStats:GenerateTraits+6c3: 7D 20 - jnl MinionStartingStats:GenerateTraits+6e5 // if (num4 < num2 && func(DUPLICANTSTATS.BADTRAITS, arg2: false))
// ---------- DONE INJECTING ----------
MinionStartingStats:GenerateTraits+6c5: 48 B8 E8 9C B7 0A B7 01 00 00 - mov rax,000001B70AB79CE8
MinionStartingStats:GenerateTraits+6cf: 48 8B 10 - mov rdx,[rax]
MinionStartingStats:GenerateTraits+6d2: 49 8B CC - mov rcx,r12
MinionStartingStats:GenerateTraits+6d5: 45 33 C0 - xor r8d,r8d
MinionStartingStats:GenerateTraits+6d8: 41 FF 54 24 18 - call qword ptr [r12+18]
MinionStartingStats:GenerateTraits+6dd: 85 C0 - test eax,eax
MinionStartingStats:GenerateTraits+6df: 74 04 - je MinionStartingStats:GenerateTraits+6e5
MinionStartingStats:GenerateTraits+6e1: 83 45 A0 01 - add dword ptr [rbp-60],01
MinionStartingStats:GenerateTraits+6e5: 44 3B EB - cmp r13d,ebx
MinionStartingStats:GenerateTraits+6e8: 7D 22 - jnl MinionStartingStats:GenerateTraits+70c
}
696
"Massive attributes on new duplicants"
Auto Assembler Script
define(bytes,45 33 C0 48 8B 85 A8 FE FF FF)
[ENABLE]
{$lua}
mono_register("MinionStartingStats","GenerateAttributes","ptrGenerateAttributes")
{$asm}
assert(ptrGenerateAttributes+1fe,bytes)
alloc(memGenerateAttributes,$1000,ptrGenerateAttributes)
label(code)
label(return)
memGenerateAttributes:
code:
//xor r8d,r8d
mov r8d,[DesiredAttributeValue]
mov rax,[rbp-00000158]
jmp return
DesiredAttributeValue:
dd #100
ptrGenerateAttributes+1fe:
jmp memGenerateAttributes
nop 5
return:
[DISABLE]
ptrGenerateAttributes+1fe:
db bytes
unregistersymbol(ptrGenerateAttributes)
dealloc(memGenerateAttributes)
{
// ORIGINAL CODE - INJECTION POINT: MinionStartingStats:GenerateAttributes+1fe
MinionStartingStats:GenerateAttributes+1ca: 48 63 40 18 - movsxd rax,dword ptr [rax+18]
MinionStartingStats:GenerateAttributes+1ce: 39 85 98 FE FF FF - cmp [rbp-00000168],eax
MinionStartingStats:GenerateAttributes+1d4: 0F 83 FE 09 00 00 - jae MinionStartingStats:GenerateAttributes+bd8
MinionStartingStats:GenerateAttributes+1da: 48 8B 85 A0 FE FF FF - mov rax,[rbp-00000160]
MinionStartingStats:GenerateAttributes+1e1: 48 8B 40 10 - mov rax,[rax+10]
MinionStartingStats:GenerateAttributes+1e5: 48 63 8D 98 FE FF FF - movsxd rcx,dword ptr [rbp-00000168]
MinionStartingStats:GenerateAttributes+1ec: 48 63 C9 - movsxd rcx,ecx
MinionStartingStats:GenerateAttributes+1ef: 48 8D 44 C8 20 - lea rax,[rax+rcx*8+20]
MinionStartingStats:GenerateAttributes+1f4: 48 8B 10 - mov rdx,[rax]
MinionStartingStats:GenerateAttributes+1f7: 48 8B 8D A8 FE FF FF - mov rcx,[rbp-00000158]
// ---------- INJECTING HERE ----------
MinionStartingStats:GenerateAttributes+1fe: 45 33 C0 - xor r8d,r8d
// ---------- DONE INJECTING ----------
MinionStartingStats:GenerateAttributes+201: 48 8B 85 A8 FE FF FF - mov rax,[rbp-00000158]
MinionStartingStats:GenerateAttributes+208: 83 38 00 - cmp dword ptr [rax],00
MinionStartingStats:GenerateAttributes+20b: 66 66 90 - nop 3
MinionStartingStats:GenerateAttributes+20e: 49 BB F0 2B 2A 91 B6 01 00 00 - mov r11,System.Collections.Generic.Dictionary`2[System.String,System.Int32]:set_Item
MinionStartingStats:GenerateAttributes+218: 41 FF D3 - call r11
MinionStartingStats:GenerateAttributes+21b: 83 85 C8 FE FF FF 01 - add dword ptr [rbp-00000138],01
MinionStartingStats:GenerateAttributes+222: 48 8B 85 D0 FE FF FF - mov rax,[rbp-00000130]
MinionStartingStats:GenerateAttributes+229: 83 38 00 - cmp dword ptr [rax],00
MinionStartingStats:GenerateAttributes+22c: 48 63 40 18 - movsxd rax,dword ptr [rax+18]
MinionStartingStats:GenerateAttributes+230: 39 85 C8 FE FF FF - cmp [rbp-00000138],eax
}
{
// ORIGINAL CODE - INJECTION POINT: MinionStartingStats:GenerateAttributes+5ae
MinionStartingStats:GenerateAttributes+588: 41 FF D3 - call r11
MinionStartingStats:GenerateAttributes+58b: 4C 8B 77 50 - mov r14,[rdi+50]
MinionStartingStats:GenerateAttributes+58f: 4C 8B EB - mov r13,rbx
MinionStartingStats:GenerateAttributes+592: 49 8B CE - mov rcx,r14
MinionStartingStats:GenerateAttributes+595: 48 8B D3 - mov rdx,rbx
MinionStartingStats:GenerateAttributes+598: 41 83 3E 00 - cmp dword ptr [r14],00
MinionStartingStats:GenerateAttributes+59c: 66 90 - nop 2
MinionStartingStats:GenerateAttributes+59e: 49 BB 50 AA 63 95 63 02 00 00 - mov r11,System.Collections.Generic:Dictionary`2:get_Item
MinionStartingStats:GenerateAttributes+5a8: 41 FF D3 - call r11
MinionStartingStats:GenerateAttributes+5ab: 4C 8B C0 - mov r8,rax
// ---------- INJECTING HERE ----------
MinionStartingStats:GenerateAttributes+5ae: 44 03 85 F0 FE FF FF - add r8d,[rbp-00000110]
// ---------- DONE INJECTING ----------
MinionStartingStats:GenerateAttributes+5b5: 49 8B CE - mov rcx,r14
MinionStartingStats:GenerateAttributes+5b8: 48 8B D3 - mov rdx,rbx
MinionStartingStats:GenerateAttributes+5bb: 41 83 3E 00 - cmp dword ptr [r14],00
MinionStartingStats:GenerateAttributes+5bf: 48 8D AD 00 00 00 00 - lea rbp,[rbp+00000000]
MinionStartingStats:GenerateAttributes+5c6: 49 BB 10 67 90 D2 62 02 00 00 - mov r11,System.Collections.Generic:Dictionary`2:set_Item
MinionStartingStats:GenerateAttributes+5d0: 41 FF D3 - call r11
MinionStartingStats:GenerateAttributes+5d3: 48 63 85 F0 FE FF FF - movsxd rax,dword ptr [rbp-00000110]
MinionStartingStats:GenerateAttributes+5da: 29 85 C0 FE FF FF - sub [rbp-00000140],eax
MinionStartingStats:GenerateAttributes+5e0: 41 FF C4 - inc r12d
MinionStartingStats:GenerateAttributes+5e3: 83 3E 00 - cmp dword ptr [rsi],00
}
695
"No printing cooldown"
Auto Assembler Script
define(bytes,F3 0F 10 40 48)
[ENABLE]
{$lua}
mono_register("Telepad","Update","ptrUpdate")
{$asm}
assert(ptrUpdate+246,bytes)
alloc(memUpdate,$1000,ptrUpdate)
label(code)
label(return)
memUpdate:
code:
mov [rax+48],(float)0.0
movss xmm0,[rax+48]
jmp return
ptrUpdate+246:
jmp memUpdate
return:
[DISABLE]
ptrUpdate+246:
db bytes
unregistersymbol(ptrUpdate)
dealloc(memUpdate)
{
// ORIGINAL CODE - INJECTION POINT: Telepad:Update+246
Telepad:Update+217: 48 83 C2 E8 - add rdx,-18
Telepad:Update+21b: 48 89 74 24 20 - mov [rsp+20],rsi
Telepad:Update+220: 48 8B C8 - mov rcx,rax
Telepad:Update+223: 83 38 00 - cmp dword ptr [rax],00
Telepad:Update+226: 49 BB F0 F0 24 51 9C 01 00 00 - mov r11,KSelectable:SetStatusItem
Telepad:Update+230: 41 FF D3 - call r11
Telepad:Update+233: 48 B8 B0 35 56 EE 99 01 00 00 - mov rax,00000199EE5635B0
Telepad:Update+23d: 48 8B 00 - mov rax,[rax]
Telepad:Update+240: 48 8B C8 - mov rcx,rax
Telepad:Update+243: 83 39 00 - cmp dword ptr [rcx],00
// ---------- INJECTING HERE ----------
Telepad:Update+246: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
Telepad:Update+24b: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Telepad:Update+24f: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Telepad:Update+253: F3 0F 11 6D D4 - movss [rbp-2C],xmm5
Telepad:Update+258: F3 0F 10 45 D4 - movss xmm0,[rbp-2C]
Telepad:Update+25d: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Telepad:Update+261: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Telepad:Update+265: F3 0F 11 6D D4 - movss [rbp-2C],xmm5
Telepad:Update+26a: F3 0F 10 45 D4 - movss xmm0,[rbp-2C]
Telepad:Update+26f: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Telepad:Update+273: F3 0F 10 0D 85 00 00 00 - movss xmm1,[Telepad:Update+300]
}
697
"Enable debug commands"
Auto Assembler Script
define(bytes,0F B6 00 85 C0)
[ENABLE]
{$lua}
mono_register("DebugHandler","OnKeyDown","ptrDebugHandler")
{$asm}
assert(ptrDebugHandler+87,bytes)
alloc(memDebugHandler,$1000,ptrDebugHandler)
label(code)
label(return)
memDebugHandler:
code:
movzx eax,byte ptr [rax]
mov eax,1
test eax,eax
jmp return
ptrDebugHandler+87:
jmp memDebugHandler
return:
[DISABLE]
ptrDebugHandler+87:
db bytes
unregistersymbol(ptrDebugHandler)
dealloc(memDebugHandler)
{
// ORIGINAL CODE - INJECTION POINT: DebugHandler:OnKeyDown+87
DebugHandler:OnKeyDown+41: C7 85 38 FE FF FF 00 00 00 00 - mov [rbp-000001C8],00000000
DebugHandler:OnKeyDown+4b: 33 C0 - xor eax,eax
DebugHandler:OnKeyDown+4d: 48 89 85 40 FE FF FF - mov [rbp-000001C0],rax
DebugHandler:OnKeyDown+54: 48 89 85 48 FE FF FF - mov [rbp-000001B8],rax
DebugHandler:OnKeyDown+5b: 48 89 85 50 FE FF FF - mov [rbp-000001B0],rax
DebugHandler:OnKeyDown+62: 48 89 85 58 FE FF FF - mov [rbp-000001A8],rax
DebugHandler:OnKeyDown+69: 48 89 85 60 FE FF FF - mov [rbp-000001A0],rax
DebugHandler:OnKeyDown+70: 48 89 85 68 FE FF FF - mov [rbp-00000198],rax
DebugHandler:OnKeyDown+77: 89 85 00 FE FF FF - mov [rbp-00000200],eax
DebugHandler:OnKeyDown+7d: 48 B8 B3 67 08 E7 98 01 00 00 - mov rax,00000198E70867B3
// ---------- INJECTING HERE ----------
DebugHandler:OnKeyDown+87: 0F B6 00 - movzx eax,byte ptr [rax]
// ---------- DONE INJECTING ----------
DebugHandler:OnKeyDown+8a: 85 C0 - test eax,eax
DebugHandler:OnKeyDown+8c: 0F 84 3E 22 00 00 - je DebugHandler:OnKeyDown+22d0
DebugHandler:OnKeyDown+92: 48 8B CE - mov rcx,rsi
DebugHandler:OnKeyDown+95: BA AD 00 00 00 - mov edx,000000AD
DebugHandler:OnKeyDown+9a: 83 3E 00 - cmp dword ptr [rsi],00
DebugHandler:OnKeyDown+9d: 90 - nop
DebugHandler:OnKeyDown+9e: 49 BB 79 3C 8E 68 9B 01 00 00 - mov r11,0000019B688E3C79
DebugHandler:OnKeyDown+a8: 41 FF D3 - call r11
DebugHandler:OnKeyDown+ab: 85 C0 - test eax,eax
DebugHandler:OnKeyDown+ad: 74 19 - je DebugHandler:OnKeyDown+c8
}
687
"Invincible Duplicants (Health, Breath, Stamina, Calories, Bladder, Temperature, Stress)"
000080
Auto Assembler Script
[ENABLE]
{$lua}
if LaunchMonoDataCollector()==0 then
print("LaunchMonoDataCollector failed. :(")
end
function register_method(method, symbol)
ptr = mono_compile_method(method)
unregisterSymbol(symbol)
registerSymbol(symbol, ptr)
if counter ~= nil then counter = counter + 1 end
end
local counter = 0
local assemblies=mono_enumAssemblies(mono_enumDomains()[1])
for i=1, #assemblies do
local image=mono_getImageFromAssembly(assemblies[i])
if mono_image_get_name(image)=="Assembly-CSharp" then
classes=mono_image_enumClasses(image)
for j=1, #classes do
if classes[j].classname=="Instance" then
methods=mono_class_enumMethods(classes[j].class)
class_name = mono_class_getFullName(classes[j].class)
--print(class_name)
for k=1,#methods do
--print(methods[k].name)
if methods[k].name=="GetCalories0to1" and class_name=="CalorieMonitor+Instance" then
register_method(methods[k].method,"ptrGetCalories")
elseif methods[k].name=="NeedsToPee" and class_name=="BladderMonitor+Instance" then
ptrNeedsToPee = mono_compile_method(methods[k].method)
register_method(methods[k].method,"ptrNeedsToPee")
elseif methods[k].name=="NeedsToSleep" and class_name=="StaminaMonitor+Instance" then
register_method(methods[k].method,"ptrNeedsToSleep")
elseif methods[k].name=="GetBreath" and class_name=="BreathMonitor+Instance" then
register_method(methods[k].method,"ptrGetBreath")
elseif methods[k].name=="UpdateTemperature" and class_name=="TemperatureMonitor+Instance" then
register_method(methods[k].method,"ptrUpdateTemperature")
elseif methods[k].name=="OnHealthChanged" and class_name=="WoundMonitor+Instance" then
register_method(methods[k].method,"ptrOnHealthChanged")
elseif methods[k].name=="ReportStress" and class_name=="StressMonitor+Instance" then
register_method(methods[k].method,"ptrReportStress")
end
if counter >= 7 then
return --break loop if all methods found.
end
end
end
end
end
end
{$asm}
[DISABLE]
unregistersymbol(ptrGetCalories)
unregistersymbol(ptrNeedsToPee)
unregistersymbol(ptrNeedsToSleep)
unregistersymbol(ptrGetBreath)
unregistersymbol(ptrUpdateTemperature)
unregistersymbol(ptrOnHealthChanged)
unregistersymbol(ptrReportStress)
694
"No Stress"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,48 8B 86 C8 00 00 00)
[ENABLE]
assert(ptrReportStress+28,bytes)
alloc(memReportStress,$1000,ptrReportStress)
label(code)
label(return)
memReportStress:
code:
mov rax,[rsi+000000C8]
mov [rax+48],(float)0.0
jmp return
ptrReportStress+28:
jmp memReportStress
nop 2
return:
registersymbol(memReportStress)
[DISABLE]
ptrReportStress+28:
db bytes
// mov rax,[rsi+000000C8]
dealloc(memReportStress)
unregistersymbol(memReportStress)
{
// ORIGINAL CODE - INJECTION POINT: StressMonitor+Instance:ReportStress+28
StressMonitor+Instance:ReportStress+1: 48 8B EC - mov rbp,rsp
StressMonitor+Instance:ReportStress+4: 48 83 EC 70 - sub rsp,70
StressMonitor+Instance:ReportStress+8: 48 89 75 E8 - mov [rbp-18],rsi
StressMonitor+Instance:ReportStress+c: 48 89 7D F0 - mov [rbp-10],rdi
StressMonitor+Instance:ReportStress+10: 4C 89 7D F8 - mov [rbp-08],r15
StressMonitor+Instance:ReportStress+14: 48 8B F1 - mov rsi,rcx
StressMonitor+Instance:ReportStress+17: F3 0F 11 4D D8 - movss [rbp-28],xmm1
StressMonitor+Instance:ReportStress+1c: 45 33 FF - xor r15d,r15d
StressMonitor+Instance:ReportStress+1f: E9 2A 01 00 00 - jmp StressMonitor+Instance:ReportStress+14e
StressMonitor+Instance:ReportStress+24: 48 8D 6D 00 - lea rbp,[rbp+00]
// ---------- INJECTING HERE ----------
StressMonitor+Instance:ReportStress+28: 48 8B 86 C8 00 00 00 - mov rax,[rsi+000000C8]
// ---------- DONE INJECTING ----------
StressMonitor+Instance:ReportStress+2f: 48 8B 48 30 - mov rcx,[rax+30]
StressMonitor+Instance:ReportStress+33: 48 85 C9 - test rcx,rcx
StressMonitor+Instance:ReportStress+36: 0F 84 67 01 00 00 - je StressMonitor+Instance:ReportStress+1a3
StressMonitor+Instance:ReportStress+3c: 48 83 C1 30 - add rcx,30
StressMonitor+Instance:ReportStress+40: 49 BA 18 AD 94 B4 B5 01 00 00 - mov r10,000001B5B494AD18
StressMonitor+Instance:ReportStress+4a: 49 8B D7 - mov rdx,r15
StressMonitor+Instance:ReportStress+4d: 90 - nop
StressMonitor+Instance:ReportStress+4e: 49 BB B0 F4 AA DA B4 01 00 00 - mov r11,ArrayRef`1[T_REF]:get_Item
StressMonitor+Instance:ReportStress+58: 41 FF D3 - call r11
StressMonitor+Instance:ReportStress+5b: 48 8B F8 - mov rdi,rax
}
693
"Infinite Health"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,F3 0F 10 40 48)
[ENABLE]
assert(ptrOnHealthChanged+62,bytes)
alloc(memOnHealthChanged,$1000,ptrOnHealthChanged)
label(code)
label(return)
memOnHealthChanged:
code:
mov [rax+48],(float)100.0
movss xmm0,[rax+48]
jmp return
ptrOnHealthChanged+62:
jmp memOnHealthChanged
return:
registersymbol(memOnHealthChanged)
[DISABLE]
ptrOnHealthChanged+62:
db bytes
// movss xmm0,[rax+48]
dealloc(memOnHealthChanged)
unregistersymbol(memOnHealthChanged)
{
// ORIGINAL CODE - INJECTION POINT: Instance:OnHealthChanged+62
Instance:OnHealthChanged+36: 48 3B C1 - cmp rax,rcx
Instance:OnHealthChanged+39: 0F 85 82 00 00 00 - jne Instance:OnHealthChanged+c1
Instance:OnHealthChanged+3f: F3 0F 10 46 10 - movss xmm0,[rsi+10]
Instance:OnHealthChanged+44: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:OnHealthChanged+48: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Instance:OnHealthChanged+4c: F3 0F 11 6D EC - movss [rbp-14],xmm5
Instance:OnHealthChanged+51: 48 8B 87 C0 00 00 00 - mov rax,[rdi+000000C0]
Instance:OnHealthChanged+58: 48 8B C8 - mov rcx,rax
Instance:OnHealthChanged+5b: 83 39 00 - cmp dword ptr [rcx],00
Instance:OnHealthChanged+5e: 48 8B 40 38 - mov rax,[rax+38]
// ---------- INJECTING HERE ----------
Instance:OnHealthChanged+62: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
Instance:OnHealthChanged+67: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:OnHealthChanged+6b: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0
Instance:OnHealthChanged+6f: F3 0F 11 6D E8 - movss [rbp-18],xmm5
Instance:OnHealthChanged+74: F3 0F 10 45 E8 - movss xmm0,[rbp-18]
Instance:OnHealthChanged+79: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:OnHealthChanged+7d: 66 0F 57 C9 - xorpd xmm1,xmm1
Instance:OnHealthChanged+81: 66 0F 2F C8 - comisd xmm1,xmm0
Instance:OnHealthChanged+85: 7A 06 - jp Instance:OnHealthChanged+8d
Instance:OnHealthChanged+87: 0F 84 26 00 00 00 - je Instance:OnHealthChanged+b3
Instance:OnHealthChanged+8d: F3 0F 10 45 EC - movss xmm0,[rbp-14]
}
688
"Infinite Breath"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,F3 0F 10 40 48)
[ENABLE]
assert(ptrGetBreath+16,bytes)
alloc(memGetBreath,$1000,ptrGetBreath)
label(code)
label(return)
memGetBreath:
code:
mov [rax+48],(float)100.0
movss xmm0,[rax+48]
jmp return
ptrGetBreath+16:
jmp memGetBreath
return:
registersymbol(memGetBreath)
[DISABLE]
ptrGetBreath+16:
db bytes
// movss xmm0,[rax+48]
dealloc(memGetBreath)
unregistersymbol(memGetBreath)
{
// ORIGINAL CODE - INJECTION POINT: Instance:GetBreath+16
1AAEBE694C8: 00 00 - add [rax],al
1AAEBE694CA: 00 00 - add [rax],al
1AAEBE694CC: 00 00 - add [rax],al
1AAEBE694CE: 00 00 - add [rax],al
ptrGetBreath: 55 - push rbp
Instance:GetBreath+1: 48 8B EC - mov rbp,rsp
Instance:GetBreath+4: 48 83 EC 30 - sub rsp,30
Instance:GetBreath+8: 48 89 75 F8 - mov [rbp-08],rsi
Instance:GetBreath+c: 48 8B F1 - mov rsi,rcx
Instance:GetBreath+f: 48 8B 86 C0 00 00 00 - mov rax,[rsi+000000C0]
// ---------- INJECTING HERE ----------
Instance:GetBreath+16: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
Instance:GetBreath+1b: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:GetBreath+1f: F2 0F 11 45 F0 - movsd [rbp-10],xmm0
Instance:GetBreath+24: 48 8B 86 C0 00 00 00 - mov rax,[rsi+000000C0]
Instance:GetBreath+2b: 48 8B C8 - mov rcx,rax
Instance:GetBreath+2e: 83 38 00 - cmp dword ptr [rax],00
Instance:GetBreath+31: 48 8D 64 24 00 - lea rsp,[rsp+00]
Instance:GetBreath+36: 49 BB D0 2A AC EB AA 01 00 00 - mov r11,Klei.AI:AmountInstance:GetMax
Instance:GetBreath+40: 41 FF D3 - call r11
Instance:GetBreath+43: F3 0F 5A C8 - cvtss2sd xmm1,xmm0
Instance:GetBreath+47: F2 0F 10 45 F0 - movsd xmm0,[rbp-10]
}
690
"Infinite Stamina"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,F3 0F 10 40 48)
[ENABLE]
assert(ptrNeedsToSleep+12,bytes)
alloc(memNeedsToSleep,$1000,ptrNeedsToSleep)
label(code)
label(return)
memNeedsToSleep:
code:
mov [rax+48],(float)100.0
movss xmm0,[rax+48]
jmp return
ptrNeedsToSleep+12:
jmp memNeedsToSleep
return:
registersymbol(memNeedsToSleep)
[DISABLE]
ptrNeedsToSleep+12:
db bytes
// movss xmm0,[rax+48]
dealloc(memNeedsToSleep)
unregistersymbol(memNeedsToSleep)
{
// ORIGINAL CODE - INJECTION POINT: Instance:NeedsToSleep+12
1AAEBE695D0: 01 04 02 - add [rdx+rax],eax
1AAEBE695D3: 05 04 03 01 50 - add eax,50010304
1AAEBE695D8: 00 00 - add [rax],al
1AAEBE695DA: 00 00 - add [rax],al
1AAEBE695DC: 00 00 - add [rax],al
1AAEBE695DE: 00 00 - add [rax],al
ptrNeedsToSleep: 48 83 EC 08 - sub rsp,08
Instance:NeedsToSleep+4: 48 89 0C 24 - mov [rsp],rcx
Instance:NeedsToSleep+8: 48 8B C1 - mov rax,rcx
Instance:NeedsToSleep+b: 48 8B 80 D0 00 00 00 - mov rax,[rax+000000D0]
// ---------- INJECTING HERE ----------
Instance:NeedsToSleep+12: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
Instance:NeedsToSleep+17: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:NeedsToSleep+1b: 66 0F 57 C9 - xorpd xmm1,xmm1
Instance:NeedsToSleep+1f: 48 33 C0 - xor rax,rax
Instance:NeedsToSleep+22: 66 0F 2F C8 - comisd xmm1,xmm0
Instance:NeedsToSleep+26: 40 0F 92 C0 - setb al
Instance:NeedsToSleep+2a: 85 C0 - test eax,eax
Instance:NeedsToSleep+2c: 40 0F 94 C0 - sete al
Instance:NeedsToSleep+30: 48 0F B6 C0 - movzx rax,al
Instance:NeedsToSleep+34: 48 83 C4 08 - add rsp,08
Instance:NeedsToSleep+38: C3 - ret
}
691
"Infinite Calories"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,F3 0F 10 40 48)
[ENABLE]
assert(ptrGetCalories+16,bytes)
alloc(memGetCalories,$1000,ptrGetCalories)
label(code)
label(return)
memGetCalories:
code:
mov [rax+48],(float)4000000.0
movss xmm0,[rax+48]
jmp return
ptrGetCalories+16:
jmp memGetCalories
return:
registersymbol(memGetCalories)
[DISABLE]
ptrGetCalories+16:
db bytes
// movss xmm0,[rax+48]
dealloc(memGetCalories)
unregistersymbol(memGetCalories)
{
// ORIGINAL CODE - INJECTION POINT: Instance:GetCalories0to1+16
1AAEBE69569: 00 00 - add [rax],al
1AAEBE6956B: 00 00 - add [rax],al
1AAEBE6956D: 00 00 - add [rax],al
1AAEBE6956F: 00 55 48 - add [rbp+48],dl
Instance:GetCalories0to1+2: 8B EC - mov ebp,esp
Instance:GetCalories0to1+4: 48 83 EC 30 - sub rsp,30
Instance:GetCalories0to1+8: 48 89 75 F8 - mov [rbp-08],rsi
Instance:GetCalories0to1+c: 48 8B F1 - mov rsi,rcx
Instance:GetCalories0to1+f: 48 8B 86 C0 00 00 00 - mov rax,[rsi+000000C0]
// ---------- INJECTING HERE ----------
Instance:GetCalories0to1+16: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
Instance:GetCalories0to1+1b: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:GetCalories0to1+1f: F2 0F 11 45 F0 - movsd [rbp-10],xmm0
Instance:GetCalories0to1+24: 48 8B 86 C0 00 00 00 - mov rax,[rsi+000000C0]
Instance:GetCalories0to1+2b: 48 8B C8 - mov rcx,rax
Instance:GetCalories0to1+2e: 83 38 00 - cmp dword ptr [rax],00
Instance:GetCalories0to1+31: 48 8D 64 24 00 - lea rsp,[rsp+00]
Instance:GetCalories0to1+36: 49 BB D0 2A AC EB AA 01 00 00 - mov r11,Klei.AI:AmountInstance:GetMax
Instance:GetCalories0to1+40: 41 FF D3 - call r11
Instance:GetCalories0to1+43: F3 0F 5A C8 - cvtss2sd xmm1,xmm0
Instance:GetCalories0to1+47: F2 0F 10 45 F0 - movsd xmm0,[rbp-10]
Instance:GetCalories0to1+4c: F2 0F 5E C1 - divsd xmm0,xmm1
}
689
"Empty Bladder"
Auto Assembler Script
define(bytes,F3 0F 10 40 48)
[ENABLE]
assert(ptrNeedsToPee+12e,bytes)
alloc(memNeedsToPee,$1000,ptrNeedsToPee)
label(code)
label(return)
memNeedsToPee:
code:
mov [rax+48],(float)0.0
movss xmm0,[rax+48]
jmp return
ptrNeedsToPee+12e:
jmp memNeedsToPee
return:
registersymbol(memNeedsToPee)
[DISABLE]
ptrNeedsToPee+12e:
db bytes
// movss xmm0,[rax+48]
dealloc(memNeedsToPee)
unregistersymbol(memNeedsToPee)
{
// ORIGINAL CODE - INJECTION POINT: BladderMonitor+Instance:NeedsToPee+12e
BladderMonitor+Instance:NeedsToPee+105: 83 38 00 - cmp dword ptr [rax],00
BladderMonitor+Instance:NeedsToPee+108: 48 8D 64 24 00 - lea rsp,[rsp+00]
BladderMonitor+Instance:NeedsToPee+10d: 90 - nop
BladderMonitor+Instance:NeedsToPee+10e: 49 BB 40 5D 5A A8 B4 01 00 00 - mov r11,KPrefabID:HasTag
BladderMonitor+Instance:NeedsToPee+118: 41 FF D3 - call r11
BladderMonitor+Instance:NeedsToPee+11b: 85 C0 - test eax,eax
BladderMonitor+Instance:NeedsToPee+11d: 0F 84 04 00 00 00 - je BladderMonitor+Instance:NeedsToPee+127
BladderMonitor+Instance:NeedsToPee+123: 33 C0 - xor eax,eax
BladderMonitor+Instance:NeedsToPee+125: EB 38 - jmp BladderMonitor+Instance:NeedsToPee+15f
BladderMonitor+Instance:NeedsToPee+127: 48 8B 86 C8 00 00 00 - mov rax,[rsi+000000C8]
// ---------- INJECTING HERE ----------
BladderMonitor+Instance:NeedsToPee+12e: F3 0F 10 40 48 - movss xmm0,[rax+48]
// ---------- DONE INJECTING ----------
BladderMonitor+Instance:NeedsToPee+133: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
BladderMonitor+Instance:NeedsToPee+137: F3 0F 10 0D 31 00 00 00 - movss xmm1,[BladderMonitor+Instance:NeedsToPee+170]
BladderMonitor+Instance:NeedsToPee+13f: F3 0F 5A C9 - cvtss2sd xmm1,xmm1
BladderMonitor+Instance:NeedsToPee+143: 48 33 C0 - xor rax,rax
BladderMonitor+Instance:NeedsToPee+146: 66 0F 2F C8 - comisd xmm1,xmm0
BladderMonitor+Instance:NeedsToPee+14a: 7A 06 - jp BladderMonitor+Instance:NeedsToPee+152
BladderMonitor+Instance:NeedsToPee+14c: 40 0F 97 C0 - seta al
BladderMonitor+Instance:NeedsToPee+150: EB 03 - jmp BladderMonitor+Instance:NeedsToPee+155
BladderMonitor+Instance:NeedsToPee+152: 48 FF C0 - inc rax
BladderMonitor+Instance:NeedsToPee+155: 85 C0 - test eax,eax
}
692
"Normal Body Temperature"
Auto Assembler Script
{ Game : OxygenNotIncluded.exe
Version:
Date : 2021-06-11
Author : mece
This script does blah blah blah
}
define(bytes,48 8D 64 24 00)
[ENABLE]
assert(ptrUpdateTemperature+1c1,bytes)
alloc(memUpdateTemperature,$1000,ptrUpdateTemperature)
label(code)
label(return)
memUpdateTemperature:
code:
mov [rax+000000E8],(float)310.15
movss xmm1,[rax+000000E8]
lea rsp,[rsp+00]
jmp return
ptrUpdateTemperature+1c1:
jmp memUpdateTemperature
return:
registersymbol(memUpdateTemperature)
[DISABLE]
ptrUpdateTemperature+1c1:
db bytes
// lea rsp,[rsp+00]
dealloc(memUpdateTemperature)
unregistersymbol(memUpdateTemperature)
{
// ORIGINAL CODE - INJECTION POINT: Instance:UpdateTemperature+1c1
Instance:UpdateTemperature+190: 48 B9 78 59 C7 E1 A9 01 00 00 - mov rcx,000001A9E1C75978
Instance:UpdateTemperature+19a: 48 3B C1 - cmp rax,rcx
Instance:UpdateTemperature+19d: 0F 85 46 00 00 00 - jne Instance:UpdateTemperature+1e9
Instance:UpdateTemperature+1a3: 48 8B C6 - mov rax,rsi
Instance:UpdateTemperature+1a6: F3 0F 10 80 E8 00 00 00 - movss xmm0,[rax+000000E8]
Instance:UpdateTemperature+1ae: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:UpdateTemperature+1b2: 49 8B CF - mov rcx,r15
Instance:UpdateTemperature+1b5: F2 0F 10 C8 - movsd xmm1,xmm0
Instance:UpdateTemperature+1b9: F2 0F 5A C9 - cvtsd2ss xmm1,xmm1
Instance:UpdateTemperature+1bd: 41 83 3F 00 - cmp dword ptr [r15],00
// ---------- INJECTING HERE ----------
Instance:UpdateTemperature+1c1: 48 8D 64 24 00 - lea rsp,[rsp+00]
// ---------- DONE INJECTING ----------
Instance:UpdateTemperature+1c6: 49 BB B0 26 AC EB AA 01 00 00 - mov r11,Klei.AI:AmountInstance:SetValue
Instance:UpdateTemperature+1d0: 41 FF D3 - call r11
Instance:UpdateTemperature+1d3: F3 0F 5A C0 - cvtss2sd xmm0,xmm0
Instance:UpdateTemperature+1d7: 48 8B 75 E8 - mov rsi,[rbp-18]
Instance:UpdateTemperature+1db: 48 8B 7D F0 - mov rdi,[rbp-10]
Instance:UpdateTemperature+1df: 4C 8B 7D F8 - mov r15,[rbp-08]
Instance:UpdateTemperature+1e3: 48 8D 65 00 - lea rsp,[rbp+00]
Instance:UpdateTemperature+1e7: 5D - pop rbp
Instance:UpdateTemperature+1e8: C3 - ret
Instance:UpdateTemperature+1e9: BA 66 00 00 00 - mov edx,00000066
}
---
Info about this table:
- Game Process: OxygenNotIncluded.exe
- Game Version: see history below (tested with the Steam version, without DLC)
- Author: mece
- CE Version: 7.4
---
Features:
- Fast Working: almost instant digging, building etc.
- Fast Research: reserach point earning every tick.
- Fast Attribute Leveling: almost instant attribute leveling.
- Edit experience of selected duplicant: edit duplicant skill XP value manually.
- Massive skill points: sets duplicant XP to get 32 skill points.
- Infinite Battery
- No negative traits on new duplicants
- Massive attributes on new duplicants
- No printing cooldown
- Enable debug commands (more info https://oxygennotincluded.fandom.com/wiki/Debug_Commands)
- Invincible Duplicants (Health, Breath, Stamina, Calories, Bladder, Temperature, Stress)
---
History:
- 2022-02-22: improved compatibility
- 2022-02-20: update for build: U40-494396-V
- 2021-06-13: added massive attributes, no negative traits, no printing cooldown, enable debug
- 2021-06-12: added infinite battery, invincible duplicants
- 2021-06-08: added fast attribute leveling, massive skill experience, edit experience.
- 2021-06-06: added fast working and research; game build: CS-466292
---
More info & last table version at:
- https://opencheattables.org/index.php
GetLuaEngine().MenuItem5.doClick()
function mono_register(class_name,method_name,symbol)
if monopipe then
monopipe.OnTimeout()
end
if (monopipe==nil) or (monopipe.Connected==false) then
LaunchMonoDataCollector()
end
if (monopipe==nil) or (monopipe.Connected==false) then
return nil,print("The mono handler failed to initialize")
end
--[[
local ProcessAddr = 0x7FF700421297
registerSymbol("ProcessAddr",ProcessAddr)
local sl = getMainSymbolList()
sl.clear()
if LaunchMonoDataCollector()==0 then
print("LaunchMonoDataCollector failed!")
return
end
class = mono_findClass('Assembly-CSharp', class_name)
--if class == nil
method = mono_class_findMethod(class, method_name)
ptr = mono_compile_method(method)
]]--
--local ptr = monoAA_FINDMONOMETHOD()
--unregisterSymbol(symbol)
--registerSymbol(symbol, ptr)
end
-- slNotUserdefinedSymbol
local function printSymbolName(str)
if str then
print(str)
end
end
if urs ~= nil then
unregisterSymbolLookupCallback(urs)
end
--urs=registerSymbolLookupCallback(printSymbolName, slNotUserdefinedSymbol)
local ProcessAddr = 0x7FF700421297
registerSymbol("ProcessAddr1",ProcessAddr)
registerSymbol("ProcessAddr2",ProcessAddr)
registerSymbol("ProcessAddr3",ProcessAddr)
registerSymbol("ProcessAddr4",ProcessAddr)
--------------------------------------------------------------------------------
function Shallowcopy(orig)
local orig_type = type(orig)
local copy
if orig_type == 'table' then
copy = {}
for orig_key, orig_value in pairs(orig) do
copy[orig_key] = orig_value
end
else -- number, string, boolean, etc
copy = orig
end
return copy
end
function table.print(tab)
for k, v in pairs(tab) do print(k,v) end
end
--------------------------------------------------------------------------------