148
"Player Interaction (grab pointer)"
Auto Assembler Script
[ENABLE]
//code from here to '[DISABLE]' will be used to enable the cheat
alloc(newmem,2048,"GameAssembly.dll"+40C829)
label(returnhere)
label(originalcode)
label(exit)
alloc(jump,8)
registersymbol(jump)
newmem: //this is allocated memory, you have read,write,execute access
//place your code here
mov [jump],rcx
originalcode:
mov rbx,rcx
mov rdx,[rax+00000190]
exit:
jmp returnhere
"GameAssembly.dll"+40C829:
jmp newmem
nop 5
returnhere:
[DISABLE]
//code from here till the end of the code will be used to disable the cheat
dealloc(*)
unregistersymbol(*)
"GameAssembly.dll"+40C829:
db 48 8B D9 48 8B 90 90 01 00 00
//mov rbx,rcx
//mov rdx,[rax+00000190]
Activate
16
32
0
Activate
97
1
149
"Pointer"
0
4 Bytes
[jump]
150
"is jumping (Shift + Space)"
1:Yes
0:No
0
4 Bytes
[jump]+172
Set Value
16
32
1
0
151
"set height"
0
Float
[jump]+130
Set Value
100
-10
0
Set Value
103
10
1
323
"Grab Sprint Instance"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local namespace = "MFPP"
local class_name = "SprintSettings"
local filter_field = "speedMultiplier"
local filter_value = 1.5
local tolerance = 0.01
-- Fields we want to track
local targets = { ["speedMultiplier"] = true, ["allowSprint"] = true }
local class = mono_findClass(namespace, class_name)
if not class or class == 0 then return end
local instances = mono_class_findInstancesOfClassListOnly(class)
if not instances or #instances == 0 then return end
local fields = mono_class_enumFields(class)
local filter_off = nil
for _, f in ipairs(fields) do
if f.name == filter_field then filter_off = f.offset break end
end
if not filter_off then return end
-- Initialize storage for restoration
if not _G["SS_Data"] then _G["SS_Data"] = { records = {}, originals = {} } end
local storage = _G["SS_Data"]
local al = getAddressList()
for _, inst in ipairs(instances) do
local val = readFloat(inst + filter_off) or 0
if math.abs(val - filter_value) <= tolerance then
for _, f in ipairs(fields) do
if targets[f.name] then
local f_addr = inst + f.offset
-- FORCE TYPE DETECTION: Avoid monoTypeToVarType if it's unreliable
local vType = vtDword
if string.find(f.typename, "Single") or string.find(f.name, "Multiplier") then
vType = vtSingle
elseif string.find(f.typename, "Boolean") or string.find(f.name, "allow") then
vType = vtByte
end
-- Store originals
local orig
if vType == vtSingle then orig = readFloat(f_addr)
elseif vType == vtByte then orig = readByte(f_addr)
else orig = readInteger(f_addr) end
table.insert(storage.originals, { addr = f_addr, val = orig, vType = vType })
-- CREATE AND FORCE TYPE
local mr = al.createMemoryRecord()
mr.Description = f.name
mr.Address = string.format("%X", f_addr)
-- CRITICAL: Set VarType AFTER Address
mr.VarType = vType
mr.Parent = memrec
if vType == vtByte then
mr.DropDownList.Text = "0:No\n1:Yes"
mr.DropDownReadOnly = true
mr.DropDownDescriptionOnly = true
mr.DisplayAsDropDownListItem = true
end
table.insert(storage.records, mr)
end
end
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
local storage = _G["SS_Data"]
if not storage then return end
-- Restore original values using the exactly saved type
for _, data in ipairs(storage.originals) do
if data.vType == vtSingle then writeFloat(data.addr, data.val)
elseif data.vType == vtByte then writeByte(data.addr, data.val)
else writeInteger(data.addr, data.val) end
end
-- Cleanup UI
for _, mr in ipairs(storage.records) do
mr.delete()
end
_G["SS_Data"] = nil
{$asm}
292
"Grab Jump Instance"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local namespace = "MFPP"
local scriptEntry = memrec
local class_name = "JumpSettings"
local fields_to_add = { "power" }
local field_vartypes = {
power = vtSingle,
}
local filter_field = "power"
local filter_value = 3.0
local tolerance = 0.001
local class = mono_findClass(namespace, class_name)
if not class then return end
local instances = mono_class_findInstancesOfClassListOnly(class)
if not instances or #instances == 0 then return end
local fields = mono_class_enumFields(class)
local offset_filter = nil
for _, f in ipairs(fields) do
if f.name == filter_field then
offset_filter = f.offset
break
end
end
if not offset_filter then return end
local correct_instances = {}
for i = 1, #instances do
local inst = instances[i]
local current_val = readFloat(inst + offset_filter) or 999999
if math.abs(current_val - filter_value) <= tolerance then
table.insert(correct_instances, inst)
end
end
if #correct_instances == 0 then return end
if not _G["ce_script_data"] then _G["ce_script_data"] = {} end
_G["ce_script_data"]["jumpsettings_temp"] = { instances_data = {} }
local al = getAddressList()
for _, correct_instance in ipairs(correct_instances) do
local originals = {}
local added_records = {}
for _, f in ipairs(fields) do
if f.isStatic then goto skip end
local wanted = false
for _, n in ipairs(fields_to_add) do
if f.name == n then wanted = true; break end
end
if not wanted then goto skip end
local field_addr = correct_instance + f.offset
local orig_val = readFloat(field_addr) or 0.0
local mt = f.type or ""
originals[f.name] = {addr = field_addr, value = orig_val, monotype = mt}
local mr = al.createMemoryRecord()
mr.Description = "Jump Power"
mr.Address = field_addr
mr.Active = true
mr.VarType = vtSingle
mr.Active = false
mr.Parent = scriptEntry
table.insert(added_records, mr)
::skip::
end
table.insert(_G["ce_script_data"]["jumpsettings_temp"].instances_data, {
originals = originals,
records = added_records,
instance = correct_instance
})
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
local data = _G["ce_script_data"] and _G["ce_script_data"]["jumpsettings_temp"]
if not data then goto cleanup end
-- Restore original values
for _, inst_data in ipairs(data.instances_data or {}) do
for fname, info in pairs(inst_data.originals or {}) do
if info.addr then
writeFloat(info.addr, info.value or 0.0)
end
end
end
-- Delete added records
for _, inst_data in ipairs(data.instances_data or {}) do
for _, mr in ipairs(inst_data.records or {}) do
pcall(function() mr.delete() end)
end
end
_G["ce_script_data"]["jumpsettings_temp"] = nil
::cleanup::
{$asm}
41
"ClipBoardManager"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'ClipBoardManager'
local fieldsToAdd = {
{ fieldName = 'currentMarkCount', recordName = 'Current Mark Count', type = vtWord },
{ fieldName = 'incMarkTotal', recordName = 'Total Marks', type = vtWord },
{ fieldName = 'doneRecordingMarks', recordName = 'Done Recording Marks', type = vtByte },
}
if not _G.ClipBoard_Instance or not _G.ClipBoard_Offsets then
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', className)
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.ClipBoard_Instance = instances[1]
_G.ClipBoard_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.ClipBoard_Offsets[f.name] = f.offset
end
end
if not _G.ClipBoard_Records then
_G.ClipBoard_Records = {}
end
for _, def in ipairs(fieldsToAdd) do
local record = _G.ClipBoard_Records[def.recordName]
if not record then
local al = getAddressList()
record = al.createMemoryRecord()
record.Description = def.recordName
record.Type = def.type
record.ShowAsHex = false
record.appendToEntry(scriptEntry)
_G.ClipBoard_Records[def.recordName] = record
end
if def.type == vtByte then
record.DropDownList.Text = "0:No\n1:Yes"
record.DropDownReadOnly = true
record.DropDownDescriptionOnly = true
record.DisplayAsDropDownListItem = true
end
if _G.ClipBoard_Offsets[def.fieldName] then
local liveAddress = string.format("%X", _G.ClipBoard_Instance + _G.ClipBoard_Offsets[def.fieldName])
record.Address = liveAddress
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.ClipBoard_Records then
for _, rec in pairs(_G.ClipBoard_Records) do
if rec then rec.destroy() end
end
_G.ClipBoard_Records = nil
end
_G.ClipBoard_Instance = nil
_G.ClipBoard_Offsets = nil
{$asm}
93
"Embalming"
1
18
"EmbalmingRunner"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'EmbalmingRunner'
local fieldsToAdd = {
{ fieldName = 'totalEmbalmSteps', recordName = 'Total Embalm Steps', type = vtDword },
{ fieldName = 'currentEmbalmingStep', recordName = 'Current Embalming Step', type = vtDword }
}
if not _G.Embalming_Instance or not _G.Embalming_Offsets then
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', className)
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.Embalming_Instance = instances[1]
_G.Embalming_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.Embalming_Offsets[f.name] = f.offset
end
end
if not _G.Embalming_Records then
_G.Embalming_Records = {}
end
for _, def in ipairs(fieldsToAdd) do
local record = _G.Embalming_Records[def.recordName]
if not record then
local al = getAddressList()
record = al.createMemoryRecord()
record.Description = def.recordName
record.Type = def.type
record.ShowAsHex = false
record.appendToEntry(scriptEntry)
_G.Embalming_Records[def.recordName] = record
end
if _G.Embalming_Offsets[def.fieldName] then
local liveAddress = string.format("%X", _G.Embalming_Instance + _G.Embalming_Offsets[def.fieldName])
record.Address = liveAddress
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.Embalming_Records then
for _, rec in pairs(_G.Embalming_Records) do
if rec then rec.destroy() end
end
_G.Embalming_Records = nil
end
_G.Embalming_Instance = nil
_G.Embalming_Offsets = nil
{$asm}
583
"Total Embalm Steps"
4 Bytes
17F42859CA8
584
"Current Embalming Step"
4 Bytes
17F42859CAC
39
"Invoke Methods"
1
29
"Body is Done"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'EmbalmingRunner')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'FinishBody')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
101
"Print Embalming Report"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Printout')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'RunLocalEvent')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
102
"Start New Embalming"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'EmbalmingRunner')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'StartNewEmbalming')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
40
"Start Pump"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'EmbalmingRunner')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'StartPump')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
47
"Haunt (Invoke paranormal events)"
1
326
"Environmental"
1
324
"Lights"
1
60
"Turn Off Nearby Light"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ToggleLightNear')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
[DISABLE]
59
"Turn Off Room Light"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ToggleSpecificLight')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
120
"Turn Off Light at Player"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ToggleLightAtPlayer')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
[DISABLE]
63
"Reset Lights (breaker?)"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ResetLighting')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
51
"Flicker the Lights"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'LightFlicker')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
325
"Objects"
1
49
"Lightning"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'FireLightning')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
327
"Player"
1
69
"Blink"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'Directorblink')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 1}})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'Haunt')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'Directorblink')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
121
"Toggle Filter"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'TogglePictureCorrection')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 1}})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'Haunt')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'TogglePictureCorrection')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
57
"Shake it"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ToggleShake')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 1}})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'Haunt')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ToggleShake')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
50
"Go to black"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'GoToBlack')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return
end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'Haunt')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'GoFromBlack')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
118
"Background Music"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'Haunt')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'PlayBackgroundMusic')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return
end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'Haunt')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'StopBackgroundMusic')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
68
"Force cutscene events"
1
67
"Has seen all story"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'HasSeenAllStory')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
61
"Ending"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'StepToEnding')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
66
"Body burning"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'GoToBurnEvent')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
48
"Do a distraction"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'DoDistraction')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
15
"Neck Grab"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then
end
local classId = mono_findClass('', 'DemonicEventsHandler')
if not classId then
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'NeckGrab')
if not methodId then
end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 1}})
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if mono_enumDomains == nil then return end
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', 'DemonicEventsHandler')
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'NeckGrab')
if not methodId then return end
mono_invoke_method(domain, methodId, instance, {{type = monoTypeToVartypeLookup[MONO_TYPE_BOOLEAN], value = 0}})
{$asm}
70
"End demon event"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'Haunt')
if not classId then return
end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'EndDemonEvent')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, {})
{$asm}
[DISABLE]
127
"Sub Events"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'SubEventSlinger'
local fieldsToAdd = {
{ fieldName = 'timeSinceEvent', recordName = 'Time Since Last Sub Event (resets at 300)', type = vtSingle },
{ fieldName = 'eventsFired', recordName = 'Events Fired', type = vtDword },
{ fieldName = 'currentEventChoice', recordName = 'Current Event (when not forced)', type = vtDword },
{ fieldName = 'canFireEvents', recordName = 'Can Fire Events', type = vtByte },
{ fieldName = 'tryCount', recordName = 'Try Count', type = vtDword },
{ fieldName = 'tryingForEvent', recordName = 'Trying for Event', type = vtByte },
{ fieldName = 'sizeOfEvent', recordName = 'Size of Event', type = vtQword },
}
if not _G.SubEvent_Instance or not _G.SubEvent_Offsets then
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', className)
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.SubEvent_Instance = instances[1]
_G.SubEvent_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.SubEvent_Offsets[f.name] = f.offset
end
end
if not _G.SubEvent_Records then
_G.SubEvent_Records = {}
end
for _, def in ipairs(fieldsToAdd) do
local record = _G.SubEvent_Records[def.recordName]
if not record then
local al = getAddressList()
record = al.createMemoryRecord()
record.Description = def.recordName
record.Type = def.type
record.ShowAsHex = false
record.appendToEntry(scriptEntry)
_G.SubEvent_Records[def.recordName] = record
end
if def.type == vtByte then
record.DropDownList.Text = "0:No\n1:Yes"
record.DropDownReadOnly = true
record.DropDownDescriptionOnly = true
record.DisplayAsDropDownListItem = true
end
if def.recordName == 'Current Event Choice' then
record.ShowAsHex = true
end
if _G.SubEvent_Offsets[def.fieldName] then
local liveAddress = string.format("%X", _G.SubEvent_Instance + _G.SubEvent_Offsets[def.fieldName])
record.Address = liveAddress
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.SubEvent_Records then
for _, rec in pairs(_G.SubEvent_Records) do
if rec then rec.destroy() end
end
_G.SubEvent_Records = nil
end
_G.SubEvent_Instance = nil
_G.SubEvent_Offsets = nil
{$asm}
423
"Haunt Events"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'Haunt'
local fieldsToAdd = {
{ fieldName = 'forceSubEvent', recordName = 'Force Sub Event(must be yes before choosing events)', type = vtByte },
{ fieldName = 'forceEventSize', recordName = 'Force Event Size(has dropdown of all sub events)', type = vtQword },
{ fieldName = 'froceEventChoice', recordName = 'Force Event Choice', type = vtDword },
{ fieldName = 'runningSubEvent', recordName = 'Running Sub Event', type = vtByte },
{ fieldName = 'runningTellEvent', recordName = 'Running Tell Event', type = vtByte },
{ fieldName = 'currentPack', recordName = 'Current Pack (event info)', type = vtQword },
{ fieldName = 'blockEvent', recordName = 'Block Event', type = vtByte },
{ fieldName = 'currentHauntingLocation', recordName = 'Current Haunting Location', type = vtDword },
{ fieldName = 'checkForReq', recordName = 'Check For Req', type = vtByte },
}
local packSubFields = {
{ subOffset = 0x10, recordName = 'EventNote', type = vtString, isCSharpString = true },
{ subOffset = 0x20, recordName = 'Inside Only', type = vtByte },
{ subOffset = 0x21, recordName = 'Outside Only', type = vtByte },
{ subOffset = 0x23, recordName = 'Must Have Clipboard', type = vtByte },
{ subOffset = 0x30, recordName = 'Must Meet All Conditions', type = vtByte },
{ subOffset = 0x50, recordName = 'Can Fail', type = vtByte },
{ subOffset = 0x54, recordName = 'Fail Time', type = vtSingle },
{ subOffset = 0x58, recordName = 'Auto Complete', type = vtByte },
{ subOffset = 0x5C, recordName = 'Auto Complete Time', type = vtSingle },
{ subOffset = 0x68, recordName = 'No Shaken Voice', type = vtByte },
{ subOffset = 0x69, recordName = 'Quick Event', type = vtByte },
{ subOffset = 0x6A, recordName = 'Chosen From Higher Level', type = vtByte },
{ subOffset = 0x6B, recordName = 'Reset Body After Event', type = vtByte },
{ subOffset = 0x6C, recordName = 'Stop Music After Event', type = vtByte },
{ subOffset = 0x6D, recordName = 'Lights Off Cover', type = vtByte },
{ subOffset = 0x6E, recordName = 'Resume Rain Sound', type = vtByte },
{ subOffset = 0x6F, recordName = 'End On Zone Entry', type = vtByte },
}
if not _G.HauntEvent2_Instance or not _G.HauntEvent2_Offsets then
local domains = mono_enumDomains()
if not domains or #domains == 0 then return end
local domain = domains[1]
local classId = mono_findClass('', className)
if not classId or classId == 0 then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.HauntEvent2_Instance = instances[1]
_G.HauntEvent2_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.HauntEvent2_Offsets[f.name] = f.offset
end
end
_G.HauntEvent2_Records = _G.HauntEvent2_Records or {}
local al = getAddressList()
-- Create Main Fields
for _, def in ipairs(fieldsToAdd) do
local record = _G.HauntEvent2_Records[def.recordName]
if not record then
record = al.createMemoryRecord()
record.Description = def.recordName
record.VarType = def.type
record.appendToEntry(scriptEntry)
_G.HauntEvent2_Records[def.recordName] = record
end
if def.fieldName == 'currentPack' then
record.Options = '[moManualExpandCollapse, moAlwaysHideChildren]'
record.Collapsed = true
end
if def.type == vtByte then
record.DropDownList.Text = "0:No\n1:Yes"
record.DropDownReadOnly = true
record.DropDownDescriptionOnly = true
record.DisplayAsDropDownListItem = true
end
if def.fieldName == "forceEventSize" then
record.ShowAsHex = true
record.DropDownList.Text = [[
Event Size 0 ---------------------------
0000000000000000:Light Flicker
0000000100000000:Hall Sound One SFX
0000000200000000:Footsteps Above SFX
0000000300000000:CS SFX
0000000400000000:Already Died SFX
0000000500000000:CloseDoor Knock
0000000600000000:Light Near Player
0000000700000000:???
0000000800000000:Front Door Open
0000000900000000:Floor Creak
0000000A00000000:Window Tap
0000000B00000000:Window Bang
0000000C00000000:Computer Sit Up
0000000D00000000:Rise At Computer Mimic
0000000E00000000:Walk To Computer
0000000F00000000:Rise At Computer Demon Driven
0000001000000000:You're going to die
0000001100000000:Please Help Me CS
0000001200000000:Phone Call Rebecca
0000001300000000:Kid Voices
0000001400000000:Cabinets Open
0000001500000000:???
0000001600000000:Shadow Bathroom Door
0000001700000000:Shadow Man Oproom door
0000001800000000:Mimic Cold Storage
0000001900000000:Cut Right Arm
0000001A00000000:Cut Left Arm
0000001B00000000:Knock
0000001C00000000:Doorway Stand Far
0000001D00000000:voice1
0000001E00000000:laugh
0000001F00000000:Look During Jaw
0000002000000000:HOLIDAY_Christmas Bell
0000002100000000:???
0000002200000000:Thumps
0000002300000000:ShadowInDark
0000002400000000:Thumps
Event Size 1 ---------------------------
0000000000000001:Phone Call ("I'm going to kill you")
0000000100000001:Computer Sit Up
0000000200000001:Mimic On Cabinet
0000000300000001:White Spirit Window Look
0000000400000001:Cabinet Lean - Demon Driven
0000000500000001:Cabinet Lean - Mimic
0000000600000001:Pull Back Under
0000000700000001:WalkPastCart
0000000800000001:CS Hall Lean
0000000900000001:CS Hall Ceiling Look
0000000A00000001:Crawl On Door CSHall
0000000B00000001:Walk To Computer
0000000C00000001:Rise At Computer Demon Driven
0000000D00000001:Rise At Computer Mimic
0000000E00000001:Mimic Crouch
0000000F00000001:Window Look Low
0000001000000001:Light Cling
0000001100000001:Cabinet Look Lower
0000001200000001:Door Look Hall
0000001300000001:Door Look Bathroom
0000001400000001:Mimic Inside
0000001500000001:Door Slam
0000001600000001:Slam cs Door
0000001700000001:Mimic Ceiling Climb
0000001800000001:Demon Driven Crouch
0000001900000001:Back Rot
0000001A00000001:FootSteps Door Slam
0000001B00000001:Door Look Lady
0000001C00000001:Cart Look
0000001D00000001:Mimic Cart Lean
0000001E00000001:ShadowManLightsOut
0000001F00000001:Entity Under Desk
0000002000000001:Speak Blood
0000002100000001:Spak Pray
0000002200000001:Do the Dead Comfort You
0000002300000001:Look During Jaw
0000002400000001:HOLIDAY_ChristmasHoHo
0000002500000001:WalkBy
0000002600000001:Throw Body
0000002700000001:Body Walk By Op
0000002800000001:Body Walk By CS
0000002900000001:Body Walk By Hall
0000002A00000001:WallCrawl
Event Size 2 ---------------------------
0000000000000002:Shadow Call Out (Rebecca!)
0000000100000002:Body Hall Walk (Jumps you)
0000000200000002:Light Toggle Spirit Rush
0000000300000002:Shadow Man Rush
0000000400000002:Cs Slam Drag
0000000500000002:Throw Items
0000000600000002:Shadow Teleport
0000000700000002:Arm Stab
0000000800000002:Throw Into Wall
0000000900000002:Mirror Climb
0000000A00000002:Door Look Drag
0000000B00000002:Pull Back
0000000C00000002:Dead Body Walk By
0000000D00000002:Looping Hall
Event Size 3 ---------------------------
0000000000000003:Grandma
0000000100000003:The Knock
0000000200000003:Endless Hall mimic ]]
record.DropDownReadOnly = true
record.DropDownDescriptionOnly = true
record.DisplayAsDropDownListItem = true
end
if _G.HauntEvent2_Offsets[def.fieldName] then
record.Address = string.format("%X+%X", _G.HauntEvent2_Instance, _G.HauntEvent2_Offsets[def.fieldName])
end
end
-- Create Sub Fields under Current Pack
local packParent = _G.HauntEvent2_Records['Current Pack (event info)']
if packParent and _G.HauntEvent2_Offsets['currentPack'] then
local basePointer = string.format("[%X+%X]", _G.HauntEvent2_Instance, _G.HauntEvent2_Offsets['currentPack'])
for _, sub in ipairs(packSubFields) do
local subRec = _G.HauntEvent2_Records[sub.recordName]
if not subRec then
subRec = al.createMemoryRecord()
subRec.Description = sub.recordName
subRec.VarType = sub.type
subRec.appendToEntry(packParent)
_G.HauntEvent2_Records[sub.recordName] = subRec
end
if sub.type == vtByte then
subRec.DropDownList.Text = "0:No\n1:Yes"
subRec.DropDownDescriptionOnly = true
subRec.DropDownReadOnly = true
subRec.DisplayAsDropDownListItem = true
end
if sub.type == vtString then
subRec.String.Size = 64
subRec.String.Unicode = true
end
if sub.isCSharpString then
subRec.Address = string.format("[%s+%X]+14", basePointer, sub.subOffset)
else
subRec.Address = basePointer .. "+" .. string.format("%X", sub.subOffset)
end
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.HauntEvent2_Records then
for _, rec in pairs(_G.HauntEvent2_Records) do
if rec then rec.destroy() end
end
_G.HauntEvent2_Records = nil
end
_G.HauntEvent2_Instance = nil
_G.HauntEvent2_Offsets = nil
{$asm}
574
"Reset Event Time (Ctrl + T, Starts New Sub Event)"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local domain = mono_enumDomains()[1]
if not domain then return
end
local classId = mono_findClass('', 'SubEventSlinger')
if not classId then return
end
local arg1 = {300}
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then
end
local instance = instances[1]
local methodId = mono_class_findMethod(classId, 'ResetEventTime')
if not methodId then return
end
mono_invoke_method(domain, methodId, instance, arg1)
{$asm}
[DISABLE]
Activate
17
84
0
117
"Possession Informer"
1
92
"Possession Time"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'Haunt'
local fieldsToAdd = {
{ fieldName = 'possessionTimeModifier', recordName = 'Possession Time', type = vtSingle },
}
if not _G.Haunt_Instance or not _G.Haunt_Offsets then
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', className)
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.Haunt_Instance = instances[1]
_G.Haunt_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.Haunt_Offsets[f.name] = f.offset
end
end
if not _G.Haunt_Records then
_G.Haunt_Records = {}
end
for _, def in ipairs(fieldsToAdd) do
local record = _G.Haunt_Records[def.recordName]
if not record then
local al = getAddressList()
record = al.createMemoryRecord()
record.Description = def.recordName
record.Type = def.type
record.ShowAsHex = false
record.appendToEntry(scriptEntry)
_G.Haunt_Records[def.recordName] = record
end
if _G.Haunt_Offsets[def.fieldName] then
local liveAddress = string.format("%X", _G.Haunt_Instance + _G.Haunt_Offsets[def.fieldName])
record.Address = liveAddress
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.Haunt_Records then
for _, rec in pairs(_G.Haunt_Records) do
if rec then rec.destroy() end
end
_G.Haunt_Records = nil
end
_G.Haunt_Instance = nil
_G.Haunt_Offsets = nil
{$asm}
24
"PossessionInformer Fields"
Auto Assembler Script
[ENABLE]
{$lua}
if syntaxcheck then return end
LaunchMonoDataCollector()
local scriptEntry = memrec
local className = 'PossessionInformer'
local fieldsToAdd = {
{ fieldName = '_transitionTime', recordName = 'Transition Time', type = vtSingle },
{ fieldName = 'triggered', recordName = 'Possession Triggered', type = vtByte }
}
if not _G.Possession_Instance or not _G.Possession_Offsets then
local domain = mono_enumDomains()[1]
if not domain then return end
local classId = mono_findClass('', className)
if not classId then return end
local instances = mono_class_findInstancesOfClassListOnly(domain, classId)
if not instances or #instances == 0 then return end
_G.Possession_Instance = instances[1]
_G.Possession_Offsets = {}
local classFields = mono_class_enumFields(classId)
for _, f in ipairs(classFields) do
_G.Possession_Offsets[f.name] = f.offset
end
end
if not _G.Possession_Records then
_G.Possession_Records = {}
end
for _, def in ipairs(fieldsToAdd) do
local record = _G.Possession_Records[def.recordName]
if not record then
local al = getAddressList()
record = al.createMemoryRecord()
record.Description = def.recordName
record.Type = def.type
record.ShowAsHex = false
record.appendToEntry(scriptEntry)
_G.Possession_Records[def.recordName] = record
end
if def.type == vtByte then
record.DropDownList.Text = "0:No\n1:Yes"
record.DropDownReadOnly = true
record.DropDownDescriptionOnly = true
record.DisplayAsDropDownListItem = true
end
if _G.Possession_Offsets[def.fieldName] then
local liveAddress = string.format("%X", _G.Possession_Instance + _G.Possession_Offsets[def.fieldName])
record.Address = liveAddress
end
end
{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end
if _G.Possession_Records then
for _, rec in pairs(_G.Possession_Records) do
if rec then rec.destroy() end
end
_G.Possession_Records = nil
end
_G.Possession_Instance = nil
_G.Possession_Offsets = nil
{$asm}
Change of mov qword ptr [rdi],00000000
GameAssembly.dll+48C712
BB
80
01
00
00
48
C7
07
00
00
00
00
4C
8D
35
A0
93
Code :mov [rax+70],r15d
GameAssembly.dll+4909A0
48
85
C0
74
47
44
89
78
70
4C
8B
74
24
70
Change of je GameAssembly.dll+49C240
GameAssembly.dll+49C200
FF
80
7B
2B
00
74
3E
48
8B
05
3F
16
Change of mov [rdi],rax
GameAssembly.dll+48C8A9
7B
7E
6B
02
00
48
89
07
74
3D
4C
8B
C7
Change of mov [rdi],r15
GameAssembly.dll+4908E1
3D
43
3E
6B
02
4C
89
3F
74
45
48
C1
EF
Change of cmp dword ptr [GameAssembly.dll+2B44724],00
GameAssembly.dll+48C8A2
E8
BE
B0
07
00
83
3D
7B
7E
6B
02
00
48
89
07
74
3D
Change of jb GameAssembly.dll+509B76
GameAssembly.dll+509B20
0F
2F
7C
00
20
72
54
80
3D
BC
CF
63
Change of comiss xmm7,[rax+r8+20]
GameAssembly.dll+509B1A
00
48
6B
C2
1C
42
0F
2F
7C
00
20
72
54
80
3D
BC