1 "Toggle Compact View" Auto Assembler Script [ENABLE] {$lua} if syntaxcheck then return end if not toggleCompactView then function toggleCompactView(sender, forceEnable) local isCompactMode = not (compactViewMenuItem.Caption == 'Compact View Mode') if forceEnable ~= nil then isCompactMode = not forceEnable end synchronize(function() compactViewMenuItem.Caption = isCompactMode and 'Compact View Mode' or 'Full View Mode' getMainForm().Splitter1.Visible = isCompactMode getMainForm().Panel4.Visible = isCompactMode getMainForm().Panel5.Visible = isCompactMode end) end end if not createCompactViewMenu then function createCompactViewMenu() if isCompactMenuCreated then return end synchronize(function() local mainMenu = getMainForm().Menu.Items compactViewMenuItem = createMenuItem(mainMenu) compactViewMenuItem.Caption = 'Compact View Mode' compactViewMenuItem.OnClick = toggleCompactView mainMenu.add(compactViewMenuItem) end) isCompactMenuCreated = true end end createCompactViewMenu() toggleCompactView(nil, true) [DISABLE] {$lua} if toggleCompactView then toggleCompactView(nil, false) end 0 "Enable mono" Auto Assembler Script [ENABLE] {$asm} { define(ResourceManagerClearItemCountsProc, "ResourceManager.ClearItemCounts") registersymbol(ResourceManagerClearItemCountsProc) } {$lua} if syntaxcheck then return end -- 📏 SafeMonoDestroy: Clean up all Mono-related state if _G.SafeMonoDestroy == nil then _G.SafeMonoDestroy = function() print("🪚 SafeMonoDestroy: Begin cleanup...") -- 1. Stop symbol enumeration thread if running if monoSymbolEnum then print("🚬 Terminating monoSymbolEnum thread...") pcall(function() monoSymbolEnum.terminate() if not monoSymbolEnum.waitfor(3000) then print("⚠ Timeout: monoSymbolEnum didn't terminate in time") end monoSymbolEnum.destroy() monoSymbolEnum = nil end) end -- 2. Stop progressbar timer if monoSymbolList and monoSymbolList.progressbar then monoSymbolList.progressbar.OnTimer = nil end -- 3. Unlock pipe (try unlock even if uncertain) print("🔓 Attempting to unlock pipe...") pcall(function() if monopipe and monopipe.unlock then monopipe.unlock() end end) -- 4. Delay before destroy to let MonoCollector finish its work print("⌛ Waiting before destroy (sleep 250ms)...") sleep(250) -- let it flush pipe state -- 5. Destroy main pipe local t0 = os.clock() print(string.format("🚨 Destroying monopipe，This may take several minutes (or longer)👺👺👺... [Start: %.3fs]", t0)) pcall(function() if monopipe then monopipe.destroy() monopipe = nil end end) local t1 = os.clock() print(string.format("👻 monopipe.destroy() completed [End: %.3fs | Duration: %.3fs]", t1, t1 - t0)) -- 6. Destroy symbol list if monoSymbolList then monoSymbolList.destroy() monoSymbolList = nil end -- 7. Destroy event pipe if exists if monoeventpipe then monoeventpipe.destroy() monoeventpipe = nil end print("👻 SafeMonoDestroy: Cleanup complete.") end end -- 列出指定 class 中、同名方法的所有 overload，回傳詳盡資訊（不註冊符號） if _G.mono_listMethodsByName == nil then _G.mono_listMethodsByName = function(namespace, classname, methodname) local cls = mono_findClass(namespace, classname) if not cls then print(string.format("💔 Class not found: %s.%s", namespace, classname)) return {} end local mtds = mono_class_enumMethods(cls) if not mtds then print(string.format("💔 No methods in: %s.%s", namespace, classname)) return {} end local out = {} local cnt = 0 for _, v in ipairs(mtds) do if v.name == methodname then local entry = { name = v.name, method = v.method } -- 參數/回傳型別（用 CE 提供的 parameters API，比較穩） local okP, p = pcall(mono_method_get_parameters, v.method) if okP and p and p.parameters then entry.params = p.parameters -- array of {typename=..., name=...} entry.paramnames = {} for i, pi in ipairs(p.parameters) do entry.paramnames[i] = pi.name end entry.returntype = p.returntype and p.returntype.name or nil else -- 後備：某些版本 mono_method_getSignature 可能回傳字串或多返回值 local okS, a, b, c = pcall(mono_method_getSignature, v.method) if okS then -- 嘗試相容 ijm_mtd_by_sig 的 (params, paramnames, returntype) entry.params = a entry.paramnames = b entry.returntype = c entry.signature = type(a) == "string" and a or nil end end -- 編譯 JIT 取得地址 local addr = mono_compile_method(v.method) entry.address = addr cnt = cnt + 1 out[cnt] = entry end end print(string.format("🔎 Found %d overload(s) for %s.%s.%s", cnt, namespace, classname, methodname)) return out end end -- 產生欄位 offset 對照表（若 CE 版本支援欄位列舉/offset 取得） if _G.mono_offsetsTable == nil then _G.mono_offsetsTable = function(cacheTable, classname, namespace, opts) -- 行為與 ijm_offset_table 類似：若已有表且非空就直接回傳 if cacheTable and type(cacheTable) == "table" then local hasAny = next(cacheTable) ~= nil if hasAny then return cacheTable end end local t = {} local cls = mono_findClass(namespace or "", classname) if not cls then print(string.format("💔 Class not found: %s.%s", namespace or "", classname)) return t end -- 嘗試列舉欄位 local fields = nil if mono_class_enumFields then local okF, res = pcall(mono_class_enumFields, cls) if okF then fields = res end end if not fields or #fields == 0 then print("⚠ 無法列舉欄位（當前 CE/Mono 外掛可能不支援 mono_class_enumFields）。") return t end for _, f in ipairs(fields) do local fname = f.name or ("<noname_"..tostring(_)..">") local off = nil if mono_field_get_offset then local okO, o = pcall(mono_field_get_offset, f.field) if okO then off = o end end t[fname] = off end -- 若需要標註是 Mono 單例/IL2CPP Enum 等，可透過 opts 設定，這裡僅示意保留 if opts and opts.meta then t.__meta = opts.meta end return t end end --[[ Example: PlayerDataC = _G.mono_offsetsTable(PlayerDataC, "PlayerData", "") HeroControllerC = _G.mono_offsetsTable(HeroControllerC, "HeroController", "") GameManagerC = _G.mono_offsetsTable(GameManagerC, "GameManager", "") HealthManagerC = _G.mono_offsetsTable(HealthManagerC, "HealthManager", "") GameplayC = _G.mono_offsetsTable(GameplayC, "Gameplay", "GlobalSettings") --]] -- 📏 Register symbol by parameter type array (exact match) if _G.mono_registerSymbolEx == nil then _G.mono_registerSymbolEx = function(symbolname, namespace, classname, methodname, paramTypes) local cls = mono_findClass(namespace, classname) if not cls then print(string.format("💔 Error: Class not found - %s.%s", namespace, classname)) return end local methods = mono_class_enumMethods(cls) for _, m in ipairs(methods) do if m.name == methodname then local p = mono_method_get_parameters(m.method) local matched = true if #p.parameters ~= #paramTypes then matched = false else for i = 1, #paramTypes do if not string.find(p.parameters[i].typename, paramTypes[i], 1, true) then matched = false break end end end if matched then local addr = mono_compile_method(m.method) if addr == 0 then print("💔 Error: Method found but failed to compile.") return end registerSymbol(symbolname, addr) print(string.format("🪧 Symbol registered: %s = %X", symbolname, addr)) return end end end print(string.format("💔 Error: No matching method found - %s.%s.%s", namespace, classname, methodname)) end end -- 📏 Register symbol by partial signature match (overload-safe, with excludes and match info) if _G.mono_registerSymbolBySignatureMatch == nil then _G.mono_registerSymbolBySignatureMatch = function(symbolname, namespace, classname, methodname, sigContains, sigExcludes) local cls = mono_findClass(namespace, classname) if not cls then print(string.format("💔 Error: Class not found - %s.%s", namespace, classname)) return end local methods = mono_class_enumMethods(cls) if not methods then print(string.format("💔 Error: No methods found in %s.%s", namespace, classname)) return end for _, m in ipairs(methods) do if m.name == methodname then local sig = mono_method_getSignature(m.method) local matched = true -- Check required substrings for _, kw in ipairs(sigContains) do if not string.find(sig, kw, 1, true) then matched = false break end end -- Check excluded substrings (if given) if matched and sigExcludes then for _, ex in ipairs(sigExcludes) do if string.find(sig, ex, 1, true) then matched = false break end end end if matched then local addr = mono_compile_method(m.method) if addr == 0 then print("💔 Error: Signature matched but failed to compile method.") return end registerSymbol(symbolname, addr) print(string.format("🪧 Symbol registered: %s = %X", symbolname, addr)) print(string.format("🔎 Matched Signature: %s", sig)) return end end end print(string.format("💔 Error: No matching signature found - %s.%s.%s", namespace, classname, methodname)) end end -- 📏 Register symbol by simple method name (first match) if _G.mono_registerSymbol == nil then _G.mono_registerSymbol = function(symbolname, namespace, classname, methodname) local m = mono_findMethod(namespace, classname, methodname) if m == nil or m == 0 then print(string.format("💔 Error: Method not found - %s.%s.%s", namespace, classname, methodname)) return end local addr = mono_compile_method(m) if addr == 0 then print(string.format("💔 Error: Could not compile method - %s.%s.%s", namespace, classname, methodname)) return end registerSymbol(symbolname, addr) print(string.format("🪧 Symbol registered: %s = %X", symbolname, addr)) end end -- 🌀 Attach Mono if needed local pid = getOpenedProcessID() if pid == 0 then print("⚠ Warning: No process is currently open.") return end if _G.lastMonoPID == nil then _G.lastMonoPID = -1 end if monopipe == nil or _G.lastMonoPID ~= pid then if monopipe ~= nil then pcall(_G.SafeMonoDestroy) end pcall(LaunchMonoDataCollector) _G.lastMonoPID = pid end -- ⚡ Example usage - Register Mono methods to CE symbol table -- These functions compile (JIT) a Mono method and register it as a CE symbol -- 🔹 1. mono_registerSymbol(symbolname, namespace, classname, methodname) -- Description: Registers the first matched method with given name. -- ⚠ Use this only when there's no overload (or you're fine with the first one). -- Params: -- symbolname: The name you want to register (used in CE as a label) -- namespace: Mono namespace of the class (can be "" if none) -- classname: Class name that contains the method -- methodname: Method name to find (first match will be used) -- Example: --_G.mono_registerSymbol("MyAttack", "Game.Logic", "BattleManager", "Attack") --_G.mono_registerSymbol("UseAbility_Any", "Elin", "Chara", "UseAbility") -- 🔹 2. mono_registerSymbolEx(symbolname, namespace, classname, methodname, paramTypes) -- Description: Registers a method that exactly matches the provided parameter types. -- Use this when there are multiple overloads of a method. -- Params: -- symbolname: The name to register -- namespace: Mono namespace -- classname: Class name -- methodname: Method name (exact match) -- paramTypes: Array of expected parameter type strings (must match count & order) -- These are matched using `string.find`, so partial match is allowed. -- Example: -- UseAbility(string idAct, Card tc, Point pos, bool pt) --[[ _G.mono_registerSymbolEx("UseAbility_Exact", "Elin", "Chara", "UseAbility", { "System.String", "Card", "Point", "System.Boolean" }) --]] -- 🔹 3. mono_registerSymbolBySignatureMatch(symbolname, namespace, classname, methodname, sigContains, sigExcludes) -- Description: Registers the method whose signature contains all given substrings. -- Flexible, and suitable when exact type names vary or signature format is uncertain. -- Params: -- symbolname: The symbol name to register -- namespace: Mono namespace -- classname: Class name -- methodname: Method name (will scan all overloads) -- sigContains: Array of strings that should all appear in the method signature -- e.g., { "Act", "Card", "Point", "bool" } -- sigExcludes: Signatures to exclude -- Example: -- Will match method like: UseAbility(Act a, Card tc, Point pos, bool pt) --[[ _G.mono_registerSymbolBySignatureMatch("UseAbility_Act", "Elin", "Chara", "UseAbility", { "Act", "Card", "Point", "bool" }) _G.mono_registerSymbolBySignatureMatch("GetItemCount_Item", "Assembly-CSharp", "ItemStorage", "GetItemCount", {"Item"}, -- sigContains {"List"} -- sigExcludes ) Signatures above: System.Collections.Generic.List<Item> Item ** Both have "Item" but first one have "List" --]] --[[ Type Mapping (for overload filtering) ------------------------------------- String System.String C#: string int System.Int32 C#: int float System.Single C#: float bool System.Boolean C#: bool Vector3 UnityEngine.Vector3 Color UnityEngine.Color Point (Game defined) Card (Game defined) Act (Game defined) --]] [DISABLE] {$lua} if syntaxcheck then return end --pcall(_G.SafeMonoDestroy) {$asm} //unregistersymbol(*) 5 "Fill HP" Auto Assembler Script { Generated by AOBMaker, bbfox@https://opencheattables.com Date : 2026/03/13 } [ENABLE] aobscanregion(INJECT_INF_HP,HonoHime.CharacterSystem.IStatus:damageHandle+224,HonoHime.CharacterSystem.IStatus:damageHandle+308,F3 0F 11 ?? A8 00 00 00 0F B6) // raw AOB: 48 8B CE BA 03 00 00 00 83 3E 00 48 8D AD 00 00 00 00 49 BB 0D 3A 4A 2E EF 01 00 00 41 FF D3 48 8B CF 49 BB 25 E5 A0 26 ED 01 00 00 41 FF D3 E9 ?? ?? ?? ?? F3 0F 10 87 A8 00 00 00 F3 0F 5A C0 F3 0F 10 8E A4 00 00 00 F3 0F 5A C9 F2 0F 5C C1 F2 0F 5A E8 F3 0F 11 AF A8 00 00 00 0F B6 86 FB 00 00 00 85 C0 74 ?? F3 0F 10 87 A0 00 00 00 F3 0F 5A C0 48 8B CF F2 0F 10 C8 F2 0F 5A C9 48 8D 6D 00 49 BB 22 53 4A 2E EF 01 00 00 41 FF D3 48 8B CE 33 D2 83 3E 00 66 66 90 49 BB 70 53 4A 2E EF 01 00 00 // injection point AOB: F3 0F 11 ?? A8 00 00 00 0F B6 ?? FB 00 00 00 85 ?? 74 ?? F3 0F 10 ?? A0 00 00 00 F3 0F 5A ?? ?? 8B ?? F2 0F 10 ?? F2 0F 5A ?? ?? 8D ?? ?? ?? ?? 22 53 4A 2E EF 01 00 00 ?? FF ?? ?? 8B ?? 33 ?? 83 ?? 00 66 66 90 ?? ?? 70 53 4A 2E EF 01 00 00 alloc(newmem,$1000,INJECT_INF_HP) alloc(INJECT_INF_HPo, $8) label(code) label(return) INJECT_INF_HPo: readmem(INJECT_INF_HP, 8) newmem: cmp dword ptr [rdi+000000A0], 0 //InvincibleTime je code cmp dword ptr [rdi+000000BC], 0 //defaultGuardPointTime je code cmp dword ptr [rdi+00000114], 0 //SP je code cmp qword ptr [rdi+00000078], 0 //OnGuardWindowExit je code movss xmm5,[rdi+00000084] code: // movss [rdi+000000A8],xmm5 reassemble(INJECT_INF_HP) jmp return align 10 cc INJECT_INF_HP: jmp newmem nop 3 return: registersymbol(INJECT_INF_HP INJECT_INF_HPo) [DISABLE] INJECT_INF_HP: readmem(INJECT_INF_HPo, 8) unregistersymbol(INJECT_INF_HP INJECT_INF_HPo) dealloc(newmem) dealloc(INJECT_INF_HPo) { // ORIGINAL CODE - INJECTION POINT: HonoHime.CharacterSystem.IStatus:damageHandle+298 HonoHime.CharacterSystem.IStatus:damageHandle+244: 48 8B CE - mov rcx,rsi HonoHime.CharacterSystem.IStatus:damageHandle+247: BA 03 00 00 00 - mov edx,00000003 HonoHime.CharacterSystem.IStatus:damageHandle+24c: 83 3E 00 - cmp dword ptr [rsi],00 HonoHime.CharacterSystem.IStatus:damageHandle+24f: 48 8D AD 00 00 00 00 - lea rbp,[rbp+00000000] HonoHime.CharacterSystem.IStatus:damageHandle+256: 49 BB 0D 3A 4A 2E EF 01 00 00 - mov r11,000001EF2E4A3A0D HonoHime.CharacterSystem.IStatus:damageHandle+260: 41 FF D3 - call r11 HonoHime.CharacterSystem.IStatus:damageHandle+263: 48 8B CF - mov rcx,rdi HonoHime.CharacterSystem.IStatus:damageHandle+266: 49 BB 25 E5 A0 26 ED 01 00 00 - mov r11,000001ED26A0E525 HonoHime.CharacterSystem.IStatus:damageHandle+270: 41 FF D3 - call r11 HonoHime.CharacterSystem.IStatus:damageHandle+273: E9 83 00 00 00 - jmp HonoHime.CharacterSystem.IStatus:damageHandle+2fb HonoHime.CharacterSystem.IStatus:damageHandle+278: F3 0F 10 87 A8 00 00 00 - movss xmm0,[rdi+000000A8] HonoHime.CharacterSystem.IStatus:damageHandle+280: F3 0F 5A C0 - cvtss2sd xmm0,xmm0 HonoHime.CharacterSystem.IStatus:damageHandle+284: F3 0F 10 8E A4 00 00 00 - movss xmm1,[rsi+000000A4] HonoHime.CharacterSystem.IStatus:damageHandle+28c: F3 0F 5A C9 - cvtss2sd xmm1,xmm1 HonoHime.CharacterSystem.IStatus:damageHandle+290: F2 0F 5C C1 - subsd xmm0,xmm1 HonoHime.CharacterSystem.IStatus:damageHandle+294: F2 0F 5A E8 - cvtsd2ss xmm5,xmm0 // ---------- INJECTING HERE ---------- HonoHime.CharacterSystem.IStatus:damageHandle+298: F3 0F 11 AF A8 00 00 00 - movss [rdi+000000A8],xmm5 // ---------- DONE INJECTING ---------- HonoHime.CharacterSystem.IStatus:damageHandle+2a0: 0F B6 86 FB 00 00 00 - movzx eax,byte ptr [rsi+000000FB] HonoHime.CharacterSystem.IStatus:damageHandle+2a7: 85 C0 - test eax,eax HonoHime.CharacterSystem.IStatus:damageHandle+2a9: 74 28 - je HonoHime.CharacterSystem.IStatus:damageHandle+2d3 HonoHime.CharacterSystem.IStatus:damageHandle+2ab: F3 0F 10 87 A0 00 00 00 - movss xmm0,[rdi+000000A0] HonoHime.CharacterSystem.IStatus:damageHandle+2b3: F3 0F 5A C0 - cvtss2sd xmm0,xmm0 HonoHime.CharacterSystem.IStatus:damageHandle+2b7: 48 8B CF - mov rcx,rdi HonoHime.CharacterSystem.IStatus:damageHandle+2ba: F2 0F 10 C8 - movsd xmm1,xmm0 HonoHime.CharacterSystem.IStatus:damageHandle+2be: F2 0F 5A C9 - cvtsd2ss xmm1,xmm1 HonoHime.CharacterSystem.IStatus:damageHandle+2c2: 48 8D 6D 00 - lea rbp,[rbp+00] HonoHime.CharacterSystem.IStatus:damageHandle+2c6: 49 BB 22 53 4A 2E EF 01 00 00 - mov r11,000001EF2E4A5322 HonoHime.CharacterSystem.IStatus:damageHandle+2d0: 41 FF D3 - call r11 HonoHime.CharacterSystem.IStatus:damageHandle+2d3: 48 8B CE - mov rcx,rsi HonoHime.CharacterSystem.IStatus:damageHandle+2d6: 33 D2 - xor edx,edx HonoHime.CharacterSystem.IStatus:damageHandle+2d8: 83 3E 00 - cmp dword ptr [rsi],00 HonoHime.CharacterSystem.IStatus:damageHandle+2db: 66 66 90 - nop 3 HonoHime.CharacterSystem.IStatus:damageHandle+2de: 49 BB 70 53 4A 2E EF 01 00 00 - mov r11,000001EF2E4A5370 } 7 "Fill SP" Auto Assembler Script { Generated by AOBMaker, bbfox@https://opencheattables.com Date : 2026/03/13 } [ENABLE] aobscanregion(INJECT_INF_SP,HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+0,HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+83,F3 0F 10 ?? 18 01 00 00 F3 0F 5A ?? F3 0F 10 ?? 14 01 00 00 F3 0F 5A ?? 66 0F 2F ?? 75) // raw AOB: 00 01 04 02 05 04 03 01 50 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 55 48 8B EC 48 83 EC 40 48 89 75 F8 48 8B F1 F3 0F 10 86 18 01 00 00 F3 0F 5A C0 F3 0F 10 8E 14 01 00 00 F3 0F 5A C9 66 0F 2F C8 75 ?? 7A ?? 72 ?? 0F B6 86 10 01 00 00 85 C0 0F 85 ?? ?? ?? ?? C6 86 10 01 00 00 01 E9 ?? ?? ?? ?? 0F B6 86 24 01 00 00 85 C0 0F 84 ?? ?? ?? ?? F3 0F 10 86 40 01 00 00 // injection point AOB: F3 0F 10 ?? 18 01 00 00 F3 0F 5A ?? F3 0F 10 ?? 14 01 00 00 F3 0F 5A ?? 66 0F 2F ?? 75 ?? 7A ?? 72 ?? 0F B6 ?? 10 01 00 00 85 ?? 0F 85 ?? ?? ?? ?? C6 ?? 10 01 00 00 01 E9 ?? ?? ?? ?? 0F B6 ?? 24 01 00 00 85 ?? 0F 84 ?? ?? ?? ?? F3 0F 10 ?? 40 01 00 00 alloc(newmem,$1000,INJECT_INF_SP) alloc(INJECT_INF_SPo, $8) label(code) label(return) INJECT_INF_SPo: readmem(INJECT_INF_SP, 8) newmem: cmp dword ptr [rsi+000000A0], 0 //InvincibleTime je short code cmp dword ptr [rsi+000000BC], 0 //defaultGuardPointTime je short code cmp dword ptr [rsi+00000114], 0 //SP je short code cmp qword ptr [rsi+00000078], 0 //OnGuardWindowExit je short code movss xmm0, [vf_06] movss [rsi+000000BC], xmm0 movss xmm0, [rsi+00000114] movss [rsi+00000118], xmm0 //defaultGuardPointTime code: // movss xmm0,[rsi+00000118] reassemble(INJECT_INF_SP) jmp return align 10 cc vf_06: dd (float)0.6 INJECT_INF_SP: jmp newmem nop 3 return: registersymbol(INJECT_INF_SP INJECT_INF_SPo) [DISABLE] INJECT_INF_SP: readmem(INJECT_INF_SPo, 8) unregistersymbol(INJECT_INF_SP INJECT_INF_SPo) dealloc(newmem) dealloc(INJECT_INF_SPo) { // ORIGINAL CODE - INJECTION POINT: HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+f 1F12A31E247: 00 01 - add [rcx],al 1F12A31E249: 04 02 - add al,02 1F12A31E24B: 05 04 03 01 50 - add eax,50010304 1F12A31E250: 00 00 - add [rax],al 1F12A31E252: 00 00 - add [rax],al 1F12A31E254: 00 00 - add [rax],al 1F12A31E256: 00 00 - add [rax],al 1F12A31E258: 00 00 - add [rax],al 1F12A31E25A: 00 00 - add [rax],al 1F12A31E25C: 00 00 - add [rax],al 1F12A31E25E: 00 00 - add [rax],al HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle: 55 - push rbp HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+1: 48 8B EC - mov rbp,rsp HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+4: 48 83 EC 40 - sub rsp,40 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+8: 48 89 75 F8 - mov [rbp-08],rsi HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+c: 48 8B F1 - mov rsi,rcx // ---------- INJECTING HERE ---------- HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+f: F3 0F 10 86 18 01 00 00 - movss xmm0,[rsi+00000118] // ---------- DONE INJECTING ---------- HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+17: F3 0F 5A C0 - cvtss2sd xmm0,xmm0 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+1b: F3 0F 10 8E 14 01 00 00 - movss xmm1,[rsi+00000114] HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+23: F3 0F 5A C9 - cvtss2sd xmm1,xmm1 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+27: 66 0F 2F C8 - comisd xmm1,xmm0 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+2b: 75 1F - jne HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+4c HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+2d: 7A 1D - jp HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+4c HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+2f: 72 1B - jb HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+4c HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+31: 0F B6 86 10 01 00 00 - movzx eax,byte ptr [rsi+00000110] HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+38: 85 C0 - test eax,eax HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+3a: 0F 85 65 02 00 00 - jne HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+2a5 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+40: C6 86 10 01 00 00 01 - mov byte ptr [rsi+00000110],01 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+47: E9 59 02 00 00 - jmp HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+2a5 HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+4c: 0F B6 86 24 01 00 00 - movzx eax,byte ptr [rsi+00000124] HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+53: 85 C0 - test eax,eax HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+55: 0F 84 82 00 00 00 - je HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+dd HonoHime.CharacterSystem.IStatus_Player:SpReconveryHandle+5b: F3 0F 10 86 40 01 00 00 - movss xmm0,[rsi+00000140] } 10 "Set min currency" Auto Assembler Script { Generated by AOBMaker, bbfox@https://opencheattables.com Date : 2026/03/13 } [ENABLE] aobscan(INJECT_SET_CURRENCY,48 63 08 49 8B C7 03 C1 48 8B C8 48 89 8D) // raw AOB: 49 8B CE 48 8B D7 4C 8B C5 49 81 C0 E0 FC FF FF 48 8D 64 24 00 90 49 BB 10 6F 2D A0 A5 02 00 00 41 FF D3 4C 8B E8 48 8B 07 49 63 CD 39 48 18 0F 86 ?? ?? ?? ?? 48 C1 E1 04 48 03 C1 48 83 C0 20 48 63 08 49 8B C7 03 C1 48 8B C8 48 89 8D B0 FC FF FF 41 83 3E 00 49 63 4E 60 FF C1 99 F7 F9 4C 8B E2 48 8B 07 48 89 85 98 FC FF FF 33 C0 48 89 85 38 FD FF FF 48 89 85 40 FD FF FF 44 89 A5 38 FD FF FF 48 8B CD // injection point AOB: 48 63 08 49 8B C7 03 C1 48 8B C8 48 89 8D B0 FC FF FF 41 83 3E 00 49 63 4E 60 FF C1 99 F7 F9 4C 8B E2 48 8B 07 48 89 85 98 FC FF FF 33 C0 48 89 85 38 FD FF FF 48 89 85 40 FD FF FF 44 89 A5 38 FD FF FF 48 8B CD alloc(newmem,$1000) label(code) label(return) newmem: cmp dword ptr [rax], #4000 jae set_300K cmp dword ptr [rax], #100 jae set_500 cmp dword ptr [rax], #4 jae set_50 jmp code set_300K: cmp dword ptr [rax], #300000 jae code mov dword ptr [rax], #300000 jmp code set_500: cmp dword ptr [rax], #500 jae code mov dword ptr [rax], #500 jmp code set_50: cmp dword ptr [rax], #50 jae code mov dword ptr [rax], #50 code: // movsxd rcx,dword ptr [rax] db 48 63 08 // mov rax,r15 db 49 8B C7 // add eax,ecx db 03 C1 // mov rcx,rax db 48 8B C8 // mov [rbp-00000350],rcx db 48 89 8D B0 FC FF FF jmp far return align 10 cc INJECT_SET_CURRENCY: jmp far newmem nop 4 return: registersymbol(INJECT_SET_CURRENCY) [DISABLE] INJECT_SET_CURRENCY: db 48 63 08 49 8B C7 03 C1 48 8B C8 48 89 8D B0 FC FF FF unregistersymbol(INJECT_SET_CURRENCY) dealloc(newmem) { // ORIGINAL CODE - INJECTION POINT: Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+130 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+f0: 49 8B CE - mov rcx,r14 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+f3: 48 8B D7 - mov rdx,rdi Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+f6: 4C 8B C5 - mov r8,rbp Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+f9: 49 81 C0 E0 FC FF FF - add r8,FFFFFFFFFFFFFCE0 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+100: 48 8D 64 24 00 - lea rsp,[rsp+00] Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+105: 90 - nop Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+106: 49 BB 10 6F 2D A0 A5 02 00 00 - mov r11,000002A5A02D6F10 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+110: 41 FF D3 - call r11 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+113: 4C 8B E8 - mov r13,rax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+116: 48 8B 07 - mov rax,[rdi] Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+119: 49 63 CD - movsxd rcx,r13d Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+11c: 39 48 18 - cmp [rax+18],ecx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+11f: 0F 86 FE 07 00 00 - jbe Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+923 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+125: 48 C1 E1 04 - shl rcx,04 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+129: 48 03 C1 - add rax,rcx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+12c: 48 83 C0 20 - add rax,20 // ---------- INJECTING HERE ---------- Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+130: 48 63 08 - movsxd rcx,dword ptr [rax] // ---------- DONE INJECTING ---------- Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+133: 49 8B C7 - mov rax,r15 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+136: 03 C1 - add eax,ecx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+138: 48 8B C8 - mov rcx,rax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+13b: 48 89 8D B0 FC FF FF - mov [rbp-00000350],rcx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+142: 41 83 3E 00 - cmp dword ptr [r14],00 Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+146: 49 63 4E 60 - movsxd rcx,dword ptr [r14+60] Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+14a: FF C1 - inc ecx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+14c: 99 - cdq Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+14d: F7 F9 - idiv ecx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+14f: 4C 8B E2 - mov r12,rdx Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+152: 48 8B 07 - mov rax,[rdi] Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+155: 48 89 85 98 FC FF FF - mov [rbp-00000368],rax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+15c: 33 C0 - xor eax,eax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+15e: 48 89 85 38 FD FF FF - mov [rbp-000002C8],rax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+165: 48 89 85 40 FD FF FF - mov [rbp-000002C0],rax Opsive.UltimateInventorySystem.Exchange.CurrencyCollection:DiscreteAddition_S+16c: 44 89 A5 38 FD FF FF - mov [rbp-000002C8],r12d }