<?xml version="1.0" encoding="utf-8"?>
<CheatTable CheatEngineTableVersion="52">
  <CheatEntries>
    <CheatEntry>
      <ID>27034</ID>
      <Description>"UE Reflection Library (Lua)"</Description>
      <VariableType>Auto Assembler Script</VariableType>
      <AssemblerScript>[ENABLE]

{$lua}

UE_REFLECTION = (function()

-- UE5 reflection library (pure Lua). Resolves everything by NAME through UE reflection.

-- Only the two engine globals (object array, FName pool) are located by code signature and re-validated on every call.

local UE = {}

local LAYOUT = {

  OBJECT_FLAGS=0x08, OBJECT_INDEX=0x0C, OBJECT_CLASS=0x10, OBJECT_NAME=0x18, OBJECT_OUTER=0x20,

  STRUCT_SUPER=0x40, STRUCT_CHILDREN=0x48, STRUCT_PROPERTIES=0x50, FIELD_NEXT_UFIELD=0x28,

  FFIELD_CLASS=0x08, FFIELD_NEXT=0x18, FFIELD_NAME=0x20, FPROPERTY_OFFSET=0x44, FPROPERTY_SIZE=0x70,

  OBJECT_ITEM_SIZE=0x18, OBJECT_ITEM_FLAGS=0x08, CHUNK_ELEMENTS=65536, NAME_POOL_BLOCKS=0x10, NAME_STRIDE=2, MAX_CHUNKS=64,

}

local RF_CLASS_DEFAULT_OBJECT = 0x10

local RF_BEGIN_DESTROYED = 0x8000

local IF_GARBAGE = 1 &lt;&lt; 21

local IF_UNREACHABLE = 1 &lt;&lt; 28

local OBJECT_ARRAY_SIGNATURES = {

  '48 8B 05 ?? ?? ?? ?? 48 8B 0C C8 48 8D 04 D1',

  '48 8B 05 ?? ?? ?? ?? 48 8B 0C C8 48 8D 1C D1',

}

local NAME_POOL_SIGNATURES = {

  '48 8D 05 ?? ?? ?? ?? EB ?? 48 8D 0D ?? ?? ?? ?? E8 ?? ?? ?? ?? C6 05',

  '48 8D 0D ?? ?? ?? ?? E8 ?? ?? ?? ?? 4C 8B C0 C6 05 ?? ?? ?? ?? 01',

}

local globals = { object_array = nil, name_pool = nil }



local function is_valid_pointer(value) return value ~= nil and value &gt; 0x10000 and value &lt; 0x7FFFFFFFFFFF end

local function read_pointer_safe(address)

  if not address then return nil end

  local value = readPointer(address)

  if is_valid_pointer(value) then return value end

  return nil

end

local function resolve_rip_relative(hit, displacement_offset, instruction_length)

  local displacement = readInteger(hit + displacement_offset)

  if not displacement then return nil end

  if displacement &gt;= 0x80000000 then displacement = displacement - 0x100000000 end

  return hit + instruction_length + displacement

end

local function scan_signatures(signatures)

  local results = {}

  for _, signature in ipairs(signatures) do

    local list = AOBScan(signature, '+X', 0, '')

    if list then

      for i = 0, list.Count - 1 do results[#results + 1] = tonumber(list[i], 16) end

      list.destroy()

      if #results &gt; 0 then return results end

    end

  end

  return results

end



local function read_name_by_index(pool, index)

  if not pool or not index then return nil end

  local block = read_pointer_safe(pool + LAYOUT.NAME_POOL_BLOCKS + (index &gt;&gt; 16) * 8)

  if not block then return nil end

  local entry = block + (index &amp; 0xFFFF) * LAYOUT.NAME_STRIDE

  local header = readSmallInteger(entry)

  if not header then return nil end

  local length = (header &amp; 0xFFFF) &gt;&gt; 6

  if length &lt;= 0 or length &gt; 1024 then return nil end

  if (header &amp; 1) ~= 0 then return nil end

  return readString(entry + 2, length)

end

local function validate_name_pool(pool) return read_name_by_index(pool, 0) == 'None' end

local function locate_name_pool()

  for _, hit in ipairs(scan_signatures(NAME_POOL_SIGNATURES)) do

    local candidate = resolve_rip_relative(hit, 3, 7)

    if candidate and validate_name_pool(candidate) then return candidate end

  end

  return nil

end



local function validate_object_array(chunk_table_address)

  local chunk_table = read_pointer_safe(chunk_table_address)

  if not chunk_table then return false end

  local first_chunk = read_pointer_safe(chunk_table)

  if not first_chunk then return false end

  local first_object = read_pointer_safe(first_chunk)

  if not first_object then return false end

  return readInteger(first_object + LAYOUT.OBJECT_INDEX) == 0

end

local function locate_object_array()

  local votes, best, best_count = {}, nil, 0

  for _, hit in ipairs(scan_signatures(OBJECT_ARRAY_SIGNATURES)) do

    local candidate = resolve_rip_relative(hit, 3, 7)

    if candidate then

      votes[candidate] = (votes[candidate] or 0) + 1

      if votes[candidate] &gt; best_count then best, best_count = candidate, votes[candidate] end

    end

  end

  if best and validate_object_array(best) then return best end

  return nil

end



local GWORLD_SIGNATURES = {

  '48 8B 15 ?? ?? ?? ?? 48 85 D2 74 ?? 48 8B 0D ?? ?? ?? ?? 48 85 C9 74',

  '48 8B 15 ?? ?? ?? ?? 48 85 D2 74 ?? 48 8B 0D',

}



local function locate_gworld()

  local sym = getAddress('GWorld_Ptr')

  if sym and sym &gt; 0 and is_valid_pointer(readPointer(sym)) then return sym end

  for _, hit in ipairs(scan_signatures(GWORLD_SIGNATURES)) do

    local candidate = resolve_rip_relative(hit, 3, 7)

    if candidate and is_valid_pointer(candidate) then

      local world = read_pointer_safe(candidate)

      if world and UE.get_class_name(world) == 'World' then

        unregisterSymbol('GWorld_Ptr')

        registerSymbol('GWorld_Ptr', candidate, true)

        return candidate

      end

    end

  end

  return nil

end



-- Makes sure both engine globals are valid; locates them again if they are not.

function UE.ensure_ready()

  if not (globals.name_pool and validate_name_pool(globals.name_pool)) then globals.name_pool = locate_name_pool() end

  if not (globals.object_array and validate_object_array(globals.object_array)) then globals.object_array = locate_object_array() end

  locate_gworld()

  if not globals.name_pool then return false, 'FName pool not found' end

  if not globals.object_array then return false, 'GUObjectArray not found' end

  return true

end



function UE.get_object_name(object)

  if not object then return nil end

  local name = read_name_by_index(globals.name_pool, readInteger(object + LAYOUT.OBJECT_NAME))

  local number = readInteger(object + LAYOUT.OBJECT_NAME + 4)

  if name and number and number &gt; 0 then name = name .. '_' .. (number - 1) end

  return name

end

function UE.get_class(object) return read_pointer_safe(object + LAYOUT.OBJECT_CLASS) end

function UE.get_outer(object) return read_pointer_safe(object + LAYOUT.OBJECT_OUTER) end

function UE.get_class_name(object)

  local class = UE.get_class(object)

  return class and UE.get_object_name(class) or nil

end

function UE.get_super(struct) return read_pointer_safe(struct + LAYOUT.STRUCT_SUPER) end

function UE.is_a(class, ancestor)

  local depth = 0

  while class and depth &lt; 64 do

    if class == ancestor then return true end

    class = UE.get_super(class)

    depth = depth + 1

  end

  return false

end



-- Walks the live object array. The callback may return true to stop.

function UE.for_each_object(callback)

  local ok, reason = UE.ensure_ready()

  if not ok then return false, reason end

  local chunk_table = read_pointer_safe(globals.object_array)

  if not chunk_table then return false, 'object array unreadable' end

  for chunk_number = 0, LAYOUT.MAX_CHUNKS - 1 do

    local chunk = read_pointer_safe(chunk_table + chunk_number * 8)

    if not chunk then break end

    for slot = 0, LAYOUT.CHUNK_ELEMENTS - 1 do

      local item = chunk + slot * LAYOUT.OBJECT_ITEM_SIZE

      local object = read_pointer_safe(item)

      if object then

        local item_flags = readInteger(item + LAYOUT.OBJECT_ITEM_FLAGS) or 0

        local expected_index = chunk_number * LAYOUT.CHUNK_ELEMENTS + slot

        if readInteger(object + LAYOUT.OBJECT_INDEX) == expected_index and (item_flags &amp; (IF_GARBAGE | IF_UNREACHABLE)) == 0 then

          if callback(object, item_flags) then return true end

        end

      end

    end

  end

  return true

end



local struct_cache = {}

local property_cache = {}



-- kind: optional 'class', 'struct' or 'function'.

function UE.find_struct(name, kind)

  local cache_key = (kind or '') .. ':' .. name

  if struct_cache[cache_key] and is_valid_pointer(struct_cache[cache_key]) then

    return struct_cache[cache_key]

  end

  local found

  local ok, reason = UE.for_each_object(function(object)

    if UE.get_object_name(object) == name then

      local type_name = UE.get_class_name(object) or ''

      local matches = (kind == nil and (type_name:find('Class$') or type_name == 'ScriptStruct'))

        or (kind == 'class' and type_name:find('Class$'))

        or (kind == 'struct' and type_name == 'ScriptStruct')

        or (kind == 'function' and type_name == 'Function')

      if matches then found = object return true end

    end

  end)

  if not ok then return nil, reason end

  if found then struct_cache[cache_key] = found end

  return found

end



-- Finds a property by name, walking the super classes. Returns {address, name, type, offset}.

function UE.find_property(struct, property_name)

  local depth = 0

  while struct and depth &lt; 64 do

    local field = read_pointer_safe(struct + LAYOUT.STRUCT_PROPERTIES)

    local guard = 0

    while field and guard &lt; 4096 do

      local name = read_name_by_index(globals.name_pool, readInteger(field + LAYOUT.FFIELD_NAME))

      if name == property_name then

        local field_class = read_pointer_safe(field + LAYOUT.FFIELD_CLASS)

        return { address = field, name = name,

          type = field_class and read_name_by_index(globals.name_pool, readInteger(field_class)) or '?',

          offset = readInteger(field + LAYOUT.FPROPERTY_OFFSET) }

      end

      field = read_pointer_safe(field + LAYOUT.FFIELD_NEXT)

      guard = guard + 1

    end

    struct = UE.get_super(struct)

    depth = depth + 1

  end

  return nil

end



function UE.list_properties(struct)

  local list, guard = {}, 0

  local field = read_pointer_safe(struct + LAYOUT.STRUCT_PROPERTIES)

  while field and guard &lt; 4096 do

    local field_class = read_pointer_safe(field + LAYOUT.FFIELD_CLASS)

    list[#list + 1] = { name = read_name_by_index(globals.name_pool, readInteger(field + LAYOUT.FFIELD_NAME)),

      type = field_class and read_name_by_index(globals.name_pool, readInteger(field_class)) or '?',

      offset = readInteger(field + LAYOUT.FPROPERTY_OFFSET) }

    field = read_pointer_safe(field + LAYOUT.FFIELD_NEXT)

    guard = guard + 1

  end

  return list

end



function UE.list_functions(class)

  local list, guard = {}, 0

  local function_object = read_pointer_safe(class + LAYOUT.STRUCT_CHILDREN)

  while function_object and guard &lt; 4096 do

    list[#list + 1] = UE.get_object_name(function_object)

    function_object = read_pointer_safe(function_object + LAYOUT.FIELD_NEXT_UFIELD)

    guard = guard + 1

  end

  return list

end



function UE.get_struct_of_property(property) return read_pointer_safe(property.address + LAYOUT.FPROPERTY_SIZE) end



function UE.read_property(object, property_name)

  local property = UE.find_property(UE.get_class(object), property_name)

  if not property then return nil, 'property not found: ' .. property_name end

  local address, t = object + property.offset, property.type

  if t == 'FloatProperty' then return readFloat(address), property

  elseif t == 'DoubleProperty' then return readDouble(address), property

  elseif t == 'IntProperty' or t == 'UInt32Property' then return readInteger(address), property

  elseif t == 'Int64Property' or t == 'UInt64Property' then return readQword(address), property

  elseif t == 'ByteProperty' or t == 'EnumProperty' or t == 'BoolProperty' then return readBytes(address, 1, false), property

  elseif t == 'ObjectProperty' then return read_pointer_safe(address), property

  elseif t == 'NameProperty' then return read_name_by_index(globals.name_pool, readInteger(address)), property

  end

  return nil, 'unsupported property type: ' .. t

end



-- Reads an FGameplayAttributeData-like struct property. Field offsets come from reflection.

function UE.read_attribute(object, attribute_name)

  local property = UE.find_property(UE.get_class(object), attribute_name)

  if not property then return nil, 'attribute not found: ' .. attribute_name end

  local struct = UE.get_struct_of_property(property)

  if not struct then return nil, 'attribute struct unresolved' end

  local base_property = UE.find_property(struct, 'BaseValue')

  local current_property = UE.find_property(struct, 'CurrentValue')

  if not (base_property and current_property) then return nil, 'BaseValue/CurrentValue missing' end

  local address = object + property.offset

  return { base = readFloat(address + base_property.offset), current = readFloat(address + current_property.offset) }

end



-- Excludes class default objects, destroyed objects and cinematic copies.

local function is_in_live_level(object)

  local flags = readInteger(object + LAYOUT.OBJECT_FLAGS) or 0

  if (flags &amp; (RF_CLASS_DEFAULT_OBJECT | RF_BEGIN_DESTROYED)) ~= 0 then return false end

  local outer = UE.get_outer(object)

  return outer ~= nil and UE.get_class_name(outer) == 'Level'

end



-- Cheap re-validation of a previously found instance (O(1), no full scan).

-- Returns false once the object was destroyed, garbage collected or its slot reused.

function UE.is_instance_alive(object, class)

  if not object or not class then return false end

  local ok = UE.ensure_ready()

  if not ok then return false end

  local index = readInteger(object + LAYOUT.OBJECT_INDEX)

  if not index or index &lt; 0 then return false end

  local chunk_table = read_pointer_safe(globals.object_array)

  local chunk = chunk_table and read_pointer_safe(chunk_table + (index // LAYOUT.CHUNK_ELEMENTS) * 8)

  if not chunk then return false end

  local item = chunk + (index % LAYOUT.CHUNK_ELEMENTS) * LAYOUT.OBJECT_ITEM_SIZE

  if read_pointer_safe(item) ~= object then return false end

  local item_flags = readInteger(item + LAYOUT.OBJECT_ITEM_FLAGS) or 0

  if (item_flags &amp; (IF_GARBAGE | IF_UNREACHABLE)) ~= 0 then return false end

  local object_class = UE.get_class(object)

  return object_class ~= nil and UE.is_a(object_class, class) and is_in_live_level(object)

end



-- Every live instance of class_name (subclasses included). Re-resolves the class on each call.

function UE.find_live_instances(class_name)

  local class, reason = UE.find_struct(class_name, 'class')

  if not class then return nil, reason or ('class not found: ' .. class_name) end

  local instances = {}

  local ok, err = UE.for_each_object(function(object)

    local object_class = UE.get_class(object)

    if object_class and UE.is_a(object_class, class) and is_in_live_level(object) then instances[#instances + 1] = object end

  end)

  if not ok then return nil, err end

  return instances, class

end





-- Lists properties of a struct/class with their FField address. include_inherited walks the super chain.

function UE.enumerate_properties(struct, include_inherited)

  local list, depth = {}, 0

  while struct and depth &lt; 64 do

    local field, guard = read_pointer_safe(struct + LAYOUT.STRUCT_PROPERTIES), 0

    while field and guard &lt; 4096 do

      local field_class = read_pointer_safe(field + LAYOUT.FFIELD_CLASS)

      list[#list + 1] = {

        address = field,

        name = read_name_by_index(globals.name_pool, readInteger(field + LAYOUT.FFIELD_NAME)),

        type = field_class and read_name_by_index(globals.name_pool, readInteger(field_class)) or '?',

        offset = readInteger(field + LAYOUT.FPROPERTY_OFFSET),

        owner = UE.get_object_name(struct),

      }

      field = read_pointer_safe(field + LAYOUT.FFIELD_NEXT)

      guard = guard + 1

    end

    if not include_inherited then break end

    struct = UE.get_super(struct)

    depth = depth + 1

  end

  return list

end



function UE.is_valid_pointer(value) return is_valid_pointer(value) end





-- Writes BaseValue and CurrentValue of an FGameplayAttributeData-like struct property via reflection.

function UE.write_attribute(object, attribute_name, new_value)

  local property = UE.find_property(UE.get_class(object), attribute_name)

  if not property then return false, 'attribute not found: ' .. attribute_name end

  local struct = UE.get_struct_of_property(property)

  if not struct then return false, 'attribute struct unresolved' end

  local base_property = UE.find_property(struct, 'BaseValue')

  local current_property = UE.find_property(struct, 'CurrentValue')

  if not (base_property and current_property) then return false, 'BaseValue/CurrentValue missing' end

  local address = object + property.offset

  writeFloat(address + base_property.offset, new_value)

  writeFloat(address + current_property.offset, new_value)

  return true

end



-- Resolves the live local player pawn via GWorld_Ptr if registered, or falls back to live instance check.

function UE.get_local_player_pawn(cached_state)

  cached_state = cached_state or {}

  if cached_state.pawn and cached_state.class and UE.is_instance_alive(cached_state.pawn, cached_state.class) then

    return cached_state.pawn

  end

  cached_state.pawn = nil

  -- Fast path: resolve via GWorld_Ptr and reflection properties in 1ms

  local gworld_sym = getAddress('GWorld_Ptr')

  if gworld_sym and gworld_sym &gt; 0 then

    local world = readPointer(gworld_sym)

    if world and world &gt; 0 then

      local gi = UE.read_property(world, 'OwningGameInstance')

      if gi and gi &gt; 0 then

        local lp_prop = UE.find_property(UE.get_class(gi), 'LocalPlayers')

        local lp_arr = lp_prop and readPointer(gi + lp_prop.offset)

        local lp = lp_arr and readPointer(lp_arr)

        if lp and lp &gt; 0 then

          local pc_prop = UE.find_property(UE.get_class(lp), 'PlayerController')

          local pc = pc_prop and readPointer(lp + pc_prop.offset)

          if pc and pc &gt; 0 then

            local pawn_prop = UE.find_property(UE.get_class(pc), 'AcknowledgedPawn')

            local pawn = pawn_prop and readPointer(pc + pawn_prop.offset)

            if pawn and pawn &gt; 0 and UE.is_instance_alive(pawn, UE.get_class(pawn)) then

              cached_state.pawn = pawn

              cached_state.class = UE.get_class(pawn)

              return pawn

            end

          end

        end

      end

    end

  end

  -- Fallback path: search live instances

  local now = os.clock()

  if cached_state.last_search and (now - cached_state.last_search &lt; 3.0) then

    return nil

  end

  cached_state.last_search = now

  local instances, class = UE.find_live_instances('AibouPlayer')

  if instances and #instances &gt; 0 then

    cached_state.pawn = instances[1]

    cached_state.class = class

    return cached_state.pawn

  end

  return nil

end



return UE



end)()

if not UE_REFLECTION.ensure_ready() then print("UE reflection: engine globals not found") end

{$asm}

[DISABLE]

{$lua}

UE_REFLECTION = nil

{$asm}

</AssemblerScript>
      <CheatEntries>
        <CheatEntry>
          <ID>27710</ID>
          <Description>"Player Survivability &amp; Defense"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27653</ID>
              <Description>"Infinite Health (God Mode)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Health (God Mode)

-- Pure-Lua UE5 reflection script. Keeps HealthSet.Health equal to MaxHealth.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local HEALTH_SET_PROPERTY = 'HealthSet'

local HEALTH_ATTRIBUTE     = 'Health'

local MAX_HEALTH_ATTRIBUTE = 'MaxHealth'

local UPDATE_INTERVAL_MS   = 50



local state = { pawn = nil, class = nil, last_search = nil }



local function update_health()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local health_set = UE.read_property(pawn, HEALTH_SET_PROPERTY)

  if not health_set or health_set == 0 then return end



  local max_hp = UE.read_attribute(health_set, MAX_HEALTH_ATTRIBUTE)

  if max_hp and max_hp.current and max_hp.current &gt; 0 then

    local cur_hp = UE.read_attribute(health_set, HEALTH_ATTRIBUTE)

    if not cur_hp or cur_hp.current &lt; max_hp.current or cur_hp.base &lt; max_hp.current then

      UE.write_attribute(health_set, HEALTH_ATTRIBUTE, max_hp.current)

    end

  end

end



if INFINITE_HEALTH_TIMER then

  INFINITE_HEALTH_TIMER.destroy()

  INFINITE_HEALTH_TIMER = nil

end



INFINITE_HEALTH_TIMER = createTimer(nil, false)

INFINITE_HEALTH_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_HEALTH_TIMER.OnTimer = function()

  pcall(update_health)

end

INFINITE_HEALTH_TIMER.Enabled = true

pcall(update_health)



{$asm}

[DISABLE]

{$lua}

if INFINITE_HEALTH_TIMER then

  INFINITE_HEALTH_TIMER.Enabled = false

  INFINITE_HEALTH_TIMER.destroy()

  INFINITE_HEALTH_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27652</ID>
              <Description>"Hit Through / Ghost Mode (No-Hit &amp; Permanent I-Frames)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Hit Through / Ghost Mode (No-Hit &amp; Permanent I-Frames)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded addresses, zero AOBs.

-- Neutralizes incoming attack impacts, prevents damage, stagger, flinch, and launch reactions.

-- Enemy attacks pass completely through the player without triggering hits.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local UPDATE_INTERVAL_MS = 60

local state = { pawn = nil, class = nil, last_search = nil }



local function apply_hit_through()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end

  local pawn_cls = UE.get_class(pawn)



  -- 1. Actor: Disable bCanBeDamaged (clear bit 2: mask 0x04)

  local prop_can_damage = UE.find_property(pawn_cls, 'bCanBeDamaged')

  if prop_can_damage and prop_can_damage.offset then

    local cur_byte = readBytes(pawn + prop_can_damage.offset, 1, false) or 0

    if (cur_byte &amp; 0x04) ~= 0 then

      writeBytes(pawn + prop_can_damage.offset, cur_byte &amp; ~0x04)

    end

  end



  -- 2. AttackHitReceiverComponent: Disable all enemy damage &amp; reaction triggers

  local prop_receiver = UE.find_property(pawn_cls, 'AttackHitReceiverComponent')

  if prop_receiver and prop_receiver.offset then

    local receiver = readPointer(pawn + prop_receiver.offset)

    if receiver and receiver &gt; 0 then

      local r_cls = UE.get_class(receiver)

      local p_other = UE.find_property(r_cls, 'IsDamagedByOther')

      if p_other and p_other.offset then writeBytes(receiver + p_other.offset, 0) end

      local p_launch = UE.find_property(r_cls, 'CanLaunchedReaction')

      if p_launch and p_launch.offset then writeBytes(receiver + p_launch.offset, 0) end

      local p_drag = UE.find_property(r_cls, 'CanDragReaction')

      if p_drag and p_drag.offset then writeBytes(receiver + p_drag.offset, 0) end

    end

  end



  -- 3. StaggerSet: Anti-Stagger / Anti-Flinch (zero accumulation)

  local stagger_set = UE.read_property(pawn, 'StaggerSet')

  if stagger_set and stagger_set &gt; 0 then

    UE.write_attribute(stagger_set, 'Stagger', 0)

    UE.write_attribute(stagger_set, 'Increase', 0)

    UE.write_attribute(stagger_set, 'StunDownDamageAccumulate', 0)

    UE.write_attribute(stagger_set, 'AerialStaggerDamageAccumulate', 0)

  end



  -- 4. KnockbackSet: Anti-knockback, prevent launch and knockdown

  local knockback_set = UE.read_property(pawn, 'KnockbackSet')

  if knockback_set and knockback_set &gt; 0 then

    UE.write_attribute(knockback_set, 'Knockback', 0)

    UE.write_attribute(knockback_set, 'AdditionalKnockback', 0)

    UE.write_attribute(knockback_set, 'Increase', 0)

    UE.write_attribute(knockback_set, 'LaunchedReaction', 0)

    UE.write_attribute(knockback_set, 'AerialStaggerKnockbackDamageAccumulate', 0)

    UE.write_attribute(knockback_set, 'BindKnockbackDamageAccumulate', 0)

  end



  -- 5. Status effect sets (Acid, Burn, Electric, Injury) kept at zero

  local acid_set = UE.read_property(pawn, 'AcidSet')

  if acid_set and acid_set &gt; 0 then UE.write_attribute(acid_set, 'Acid', 0) end



  local burn_set = UE.read_property(pawn, 'BurnSet')

  if burn_set and burn_set &gt; 0 then UE.write_attribute(burn_set, 'Burn', 0) end



  local elec_set = UE.read_property(pawn, 'ElectricSet')

  if elec_set and elec_set &gt; 0 then UE.write_attribute(elec_set, 'Electric', 0) end



  local inj_set = UE.read_property(pawn, 'InjurySet')

  if inj_set and inj_set &gt; 0 then UE.write_attribute(inj_set, 'Injury', 0) end



  -- 6. HealthSet: Maintain health locked to MaxHealth

  local health_set = UE.read_property(pawn, 'HealthSet')

  if health_set and health_set &gt; 0 then

    local max_hp = UE.read_attribute(health_set, 'MaxHealth')

    if max_hp and max_hp.current and max_hp.current &gt; 0 then

      local cur_hp = UE.read_attribute(health_set, 'Health')

      if not cur_hp or cur_hp.current &lt; max_hp.current or cur_hp.base &lt; max_hp.current then

        UE.write_attribute(health_set, 'Health', max_hp.current)

      end

    end

  end

end



if HIT_THROUGH_TIMER then

  HIT_THROUGH_TIMER.destroy()

  HIT_THROUGH_TIMER = nil

end



HIT_THROUGH_TIMER = createTimer(nil, false)

HIT_THROUGH_TIMER.Interval = UPDATE_INTERVAL_MS

HIT_THROUGH_TIMER.OnTimer = function()

  pcall(apply_hit_through)

end

HIT_THROUGH_TIMER.Enabled = true

pcall(apply_hit_through)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if HIT_THROUGH_TIMER then

  HIT_THROUGH_TIMER.Enabled = false

  HIT_THROUGH_TIMER.destroy()

  HIT_THROUGH_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local pawn_cls = UE_REFLECTION.get_class(pawn)

    local prop = UE_REFLECTION.find_property(pawn_cls, 'bCanBeDamaged')

    if prop and prop.offset then

      local cur = readBytes(pawn + prop.offset, 1, false) or 0

      writeBytes(pawn + prop.offset, cur | 0x04)

    end

    local prop_receiver = UE_REFLECTION.find_property(pawn_cls, 'AttackHitReceiverComponent')

    if prop_receiver and prop_receiver.offset then

      local receiver = readPointer(pawn + prop_receiver.offset)

      if receiver and receiver &gt; 0 then

        local r_cls = UE_REFLECTION.get_class(receiver)

        local p_other = UE_REFLECTION.find_property(r_cls, 'IsDamagedByOther')

        if p_other and p_other.offset then writeBytes(receiver + p_other.offset, 1) end

        local p_launch = UE_REFLECTION.find_property(r_cls, 'CanLaunchedReaction')

        if p_launch and p_launch.offset then writeBytes(receiver + p_launch.offset, 1) end

        local p_drag = UE_REFLECTION.find_property(r_cls, 'CanDragReaction')

        if p_drag and p_drag.offset then writeBytes(receiver + p_drag.offset, 1) end

      end

    end

  end

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27674</ID>
              <Description>"Mega Defense &amp; Damage Reduction"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Mega Defense &amp; Damage Reduction

-- Pure-Lua UE5 reflection script. Maximizes base defense and damage resistance multipliers for unmatched protection.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY = 'BattleSet'

local TARGET_DEFENCE_BASE = 9999.0

local TARGET_DEFENCE_MULT = 10.0

local UPDATE_INTERVAL_MS  = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_defense()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_def = UE.read_attribute(battle_set, 'DefenceBase')

  if not cur_def or cur_def.current &lt; TARGET_DEFENCE_BASE then

    UE.write_attribute(battle_set, 'DefenceBase', TARGET_DEFENCE_BASE)

  end



  local cur_mult = UE.read_attribute(battle_set, 'DefenceMultiplier')

  if not cur_mult or cur_mult.current &lt; TARGET_DEFENCE_MULT then

    UE.write_attribute(battle_set, 'DefenceMultiplier', TARGET_DEFENCE_MULT)

  end



  local cur_skill_def = UE.read_attribute(battle_set, 'SkillHpDamageDefenceMultiplier')

  if not cur_skill_def or cur_skill_def.current &lt; TARGET_DEFENCE_MULT then

    UE.write_attribute(battle_set, 'SkillHpDamageDefenceMultiplier', TARGET_DEFENCE_MULT)

  end

end



if MEGA_DEFENSE_TIMER then

  MEGA_DEFENSE_TIMER.destroy()

  MEGA_DEFENSE_TIMER = nil

end



MEGA_DEFENSE_TIMER = createTimer(nil, false)

MEGA_DEFENSE_TIMER.Interval = UPDATE_INTERVAL_MS

MEGA_DEFENSE_TIMER.OnTimer = function()

  pcall(update_defense)

end

MEGA_DEFENSE_TIMER.Enabled = true

pcall(update_defense)



{$asm}

[DISABLE]

{$lua}

if MEGA_DEFENSE_TIMER then

  MEGA_DEFENSE_TIMER.Enabled = false

  MEGA_DEFENSE_TIMER.destroy()

  MEGA_DEFENSE_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'DefenceBase', 15.0)

      UE_REFLECTION.write_attribute(battle_set, 'DefenceMultiplier', 0.266)

      UE_REFLECTION.write_attribute(battle_set, 'SkillHpDamageDefenceMultiplier', 0.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27660</ID>
              <Description>"Ultra Fast Health Regeneration"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Ultra Fast Health Regeneration

-- Pure-Lua UE5 reflection script. Boosts natural health regeneration speed and amount.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local HEALTH_SET_PROPERTY        = 'HealthSet'

local REGEN_AMOUNT_ATTRIBUTE     = 'RegenerationAmount'

local REGEN_MULTIPLIER_ATTRIBUTE = 'RegenerationMultiplier'

local TARGET_MULTIPLIER          = 50.0

local TARGET_AMOUNT              = 50.0

local UPDATE_INTERVAL_MS         = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_regen()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local health_set = UE.read_property(pawn, HEALTH_SET_PROPERTY)

  if not health_set or health_set == 0 then return end



  local cur_mult = UE.read_attribute(health_set, REGEN_MULTIPLIER_ATTRIBUTE)

  if not cur_mult or cur_mult.current &lt; TARGET_MULTIPLIER then

    UE.write_attribute(health_set, REGEN_MULTIPLIER_ATTRIBUTE, TARGET_MULTIPLIER)

  end



  local cur_amt = UE.read_attribute(health_set, REGEN_AMOUNT_ATTRIBUTE)

  if not cur_amt or cur_amt.current &lt; TARGET_AMOUNT then

    UE.write_attribute(health_set, REGEN_AMOUNT_ATTRIBUTE, TARGET_AMOUNT)

  end

end



if ULTRA_FAST_HEALTH_REGEN_TIMER then

  ULTRA_FAST_HEALTH_REGEN_TIMER.destroy()

  ULTRA_FAST_HEALTH_REGEN_TIMER = nil

end



ULTRA_FAST_HEALTH_REGEN_TIMER = createTimer(nil, false)

ULTRA_FAST_HEALTH_REGEN_TIMER.Interval = UPDATE_INTERVAL_MS

ULTRA_FAST_HEALTH_REGEN_TIMER.OnTimer = function()

  pcall(update_regen)

end

ULTRA_FAST_HEALTH_REGEN_TIMER.Enabled = true

pcall(update_regen)



{$asm}

[DISABLE]

{$lua}

if ULTRA_FAST_HEALTH_REGEN_TIMER then

  ULTRA_FAST_HEALTH_REGEN_TIMER.Enabled = false

  ULTRA_FAST_HEALTH_REGEN_TIMER.destroy()

  ULTRA_FAST_HEALTH_REGEN_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local health_set = UE_REFLECTION.read_property(pawn, 'HealthSet')

    if health_set and health_set &gt; 0 then

      UE_REFLECTION.write_attribute(health_set, 'RegenerationMultiplier', 1.0)

      UE_REFLECTION.write_attribute(health_set, 'RegenerationAmount', 1.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27661</ID>
              <Description>"Max Health Boost (9999 HP)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Max Health Boost (9999 HP)

-- Pure-Lua UE5 reflection script. Elevates player MaxHealth to 9999.

-- Automatically saves previous max health and restores it when disabled.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local HEALTH_SET_PROPERTY = 'HealthSet'

local HEALTH_ATTRIBUTE     = 'Health'

local MAX_HEALTH_ATTRIBUTE = 'MaxHealth'

local TARGET_MAX_HEALTH    = 9999.0

local UPDATE_INTERVAL_MS   = 100



local state = { pawn = nil, class = nil, last_search = nil }

ORIGINAL_PLAYER_MAX_HEALTH = ORIGINAL_PLAYER_MAX_HEALTH or nil



local function update_max_health_boost()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local health_set = UE.read_property(pawn, HEALTH_SET_PROPERTY)

  if not health_set or health_set == 0 then return end



  local cur_max = UE.read_attribute(health_set, MAX_HEALTH_ATTRIBUTE)

  if cur_max and cur_max.current &lt; TARGET_MAX_HEALTH then

    if not ORIGINAL_PLAYER_MAX_HEALTH and cur_max.current &gt; 0 then

      ORIGINAL_PLAYER_MAX_HEALTH = cur_max.current

    end

    UE.write_attribute(health_set, MAX_HEALTH_ATTRIBUTE, TARGET_MAX_HEALTH)

    UE.write_attribute(health_set, HEALTH_ATTRIBUTE, TARGET_MAX_HEALTH)

  end

end



if MAX_HEALTH_BOOST_TIMER then

  MAX_HEALTH_BOOST_TIMER.destroy()

  MAX_HEALTH_BOOST_TIMER = nil

end



MAX_HEALTH_BOOST_TIMER = createTimer(nil, false)

MAX_HEALTH_BOOST_TIMER.Interval = UPDATE_INTERVAL_MS

MAX_HEALTH_BOOST_TIMER.OnTimer = function()

  pcall(update_max_health_boost)

end

MAX_HEALTH_BOOST_TIMER.Enabled = true

pcall(update_max_health_boost)



{$asm}

[DISABLE]

{$lua}

if MAX_HEALTH_BOOST_TIMER then

  MAX_HEALTH_BOOST_TIMER.Enabled = false

  MAX_HEALTH_BOOST_TIMER.destroy()

  MAX_HEALTH_BOOST_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local health_set = UE_REFLECTION.read_property(pawn, 'HealthSet')

    if health_set and health_set &gt; 0 then

      local restore_hp = ORIGINAL_PLAYER_MAX_HEALTH or 870.0

      UE_REFLECTION.write_attribute(health_set, 'MaxHealth', restore_hp)

      UE_REFLECTION.write_attribute(health_set, 'Health', restore_hp)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27662</ID>
              <Description>"No Knockback &amp; Launch (Super Armor)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- No Knockback &amp; Launch (Super Armor)

-- Pure-Lua UE5 reflection script. Keeps KnockbackSet attributes locked to 0.

-- Prevents pushback, airborne launches, knockdowns, and bind reactions.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local KNOCKBACK_SET_PROPERTY = 'KnockbackSet'

local UPDATE_INTERVAL_MS     = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_knockback()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local knockback_set = UE.read_property(pawn, KNOCKBACK_SET_PROPERTY)

  if not knockback_set or knockback_set == 0 then return end



  UE.write_attribute(knockback_set, 'Knockback', 0)

  UE.write_attribute(knockback_set, 'AdditionalKnockback', 0)

  UE.write_attribute(knockback_set, 'Increase', 0)

  UE.write_attribute(knockback_set, 'LaunchedReaction', 0)

  UE.write_attribute(knockback_set, 'AerialStaggerKnockbackDamageAccumulate', 0)

  UE.write_attribute(knockback_set, 'BindKnockbackDamageAccumulate', 0)

end



if NO_KNOCKBACK_TIMER then

  NO_KNOCKBACK_TIMER.destroy()

  NO_KNOCKBACK_TIMER = nil

end



NO_KNOCKBACK_TIMER = createTimer(nil, false)

NO_KNOCKBACK_TIMER.Interval = UPDATE_INTERVAL_MS

NO_KNOCKBACK_TIMER.OnTimer = function()

  pcall(update_knockback)

end

NO_KNOCKBACK_TIMER.Enabled = true

pcall(update_knockback)



{$asm}

[DISABLE]

{$lua}

if NO_KNOCKBACK_TIMER then

  NO_KNOCKBACK_TIMER.Enabled = false

  NO_KNOCKBACK_TIMER.destroy()

  NO_KNOCKBACK_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27663</ID>
              <Description>"No Stagger &amp; Stun (Unstoppable)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- No Stagger &amp; Stun (Unstoppable)

-- Pure-Lua UE5 reflection script. Keeps StaggerSet attributes locked to 0.

-- Prevents attack interruptions (flinch), hit staggers, and stun knockdowns.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local STAGGER_SET_PROPERTY = 'StaggerSet'

local UPDATE_INTERVAL_MS   = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_stagger()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local stagger_set = UE.read_property(pawn, STAGGER_SET_PROPERTY)

  if not stagger_set or stagger_set == 0 then return end



  UE.write_attribute(stagger_set, 'Stagger', 0)

  UE.write_attribute(stagger_set, 'Increase', 0)

  UE.write_attribute(stagger_set, 'StunDownDamageAccumulate', 0)

  UE.write_attribute(stagger_set, 'AerialStaggerDamageAccumulate', 0)

end



if NO_STAGGER_TIMER then

  NO_STAGGER_TIMER.destroy()

  NO_STAGGER_TIMER = nil

end



NO_STAGGER_TIMER = createTimer(nil, false)

NO_STAGGER_TIMER.Interval = UPDATE_INTERVAL_MS

NO_STAGGER_TIMER.OnTimer = function()

  pcall(update_stagger)

end

NO_STAGGER_TIMER.Enabled = true

pcall(update_stagger)



{$asm}

[DISABLE]

{$lua}

if NO_STAGGER_TIMER then

  NO_STAGGER_TIMER.Enabled = false

  NO_STAGGER_TIMER.destroy()

  NO_STAGGER_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27664</ID>
              <Description>"Immunity to All Status Effects"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Immunity to All Status Effects

-- Pure-Lua UE5 reflection script. Keeps all 7 status ailment sets locked to 0.

-- Immunizes against Acid, Burn, Electric, Poison, Oil, Restraint, and Wet states.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local STATUS_SETS = {

  { property = 'AcidSet',      attribute = 'Acid' },

  { property = 'BurnSet',      attribute = 'Burn' },

  { property = 'ElectricSet',  attribute = 'Electric' },

  { property = 'PoisonSet',    attribute = 'Poison' },

  { property = 'OilSet',       attribute = 'Oil' },

  { property = 'RestraintSet', attribute = 'Restraint' },

  { property = 'WetSet',       attribute = 'Wet' }

}



local UPDATE_INTERVAL_MS = 80

local state = { pawn = nil, class = nil, last_search = nil }



local function update_status_effects()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  for _, entry in ipairs(STATUS_SETS) do

    local set_ptr = UE.read_property(pawn, entry.property)

    if set_ptr and set_ptr &gt; 0 then

      local cur_val = UE.read_attribute(set_ptr, entry.attribute)

      if cur_val and (cur_val.current &gt; 0 or cur_val.base &gt; 0) then

        UE.write_attribute(set_ptr, entry.attribute, 0)

      end

    end

  end

end



if IMMUNITY_ALL_STATUS_TIMER then

  IMMUNITY_ALL_STATUS_TIMER.destroy()

  IMMUNITY_ALL_STATUS_TIMER = nil

end



IMMUNITY_ALL_STATUS_TIMER = createTimer(nil, false)

IMMUNITY_ALL_STATUS_TIMER.Interval = UPDATE_INTERVAL_MS

IMMUNITY_ALL_STATUS_TIMER.OnTimer = function()

  pcall(update_status_effects)

end

IMMUNITY_ALL_STATUS_TIMER.Enabled = true

pcall(update_status_effects)



{$asm}

[DISABLE]

{$lua}

if IMMUNITY_ALL_STATUS_TIMER then

  IMMUNITY_ALL_STATUS_TIMER.Enabled = false

  IMMUNITY_ALL_STATUS_TIMER.destroy()

  IMMUNITY_ALL_STATUS_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27658</ID>
              <Description>"No Injuries (Never Injured)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- No Injuries (Never Injured)

-- Pure-Lua UE5 reflection script. Keeps InjurySet.Injury locked to 0.

-- Prevents max health penalties, injuries, and trauma accumulation.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local INJURY_SET_PROPERTY = 'InjurySet'

local INJURY_ATTRIBUTE     = 'Injury'

local UPDATE_INTERVAL_MS   = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_injury()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local injury_set = UE.read_property(pawn, INJURY_SET_PROPERTY)

  if not injury_set or injury_set == 0 then return end



  local cur_injury = UE.read_attribute(injury_set, INJURY_ATTRIBUTE)

  if cur_injury and (cur_injury.current &gt; 0 or cur_injury.base &gt; 0) then

    UE.write_attribute(injury_set, INJURY_ATTRIBUTE, 0)

  end

end



if NO_INJURIES_TIMER then

  NO_INJURIES_TIMER.destroy()

  NO_INJURIES_TIMER = nil

end



NO_INJURIES_TIMER = createTimer(nil, false)

NO_INJURIES_TIMER.Interval = UPDATE_INTERVAL_MS

NO_INJURIES_TIMER.OnTimer = function()

  pcall(update_injury)

end

NO_INJURIES_TIMER.Enabled = true

pcall(update_injury)



{$asm}

[DISABLE]

{$lua}

if NO_INJURIES_TIMER then

  NO_INJURIES_TIMER.Enabled = false

  NO_INJURIES_TIMER.destroy()

  NO_INJURIES_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27671</ID>
              <Description>"100% Perfect Dodge &amp; Perfect Guard (Just Avoid &amp; Just Guard)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- 100% Just Avoidance &amp; Infinite Just Guard (Esquive et Garde Parfaites garanties a 100%)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded addresses, zero AOBs.

-- 1. Just Avoidance: Maximizes dodge trigger range (99999.0) and enables air dodge. Any dodge input becomes a Perfect Just Avoidance!

-- 2. Just Guard / Perfect Parry: Extends the parry window from 0.27s to 999.0s. Any guard instantly triggers a Just Guard counter-attack!

-- 3. RPG Passive Evasion: Maximizes Avoid and TemporalAutoAvoidRate in BattleSet.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local UPDATE_INTERVAL_MS = 60

local state = { pawn = nil, class = nil, last_search = nil }



local function apply_perfect_avoid_guard()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end

  local pawn_cls = UE.get_class(pawn)



  -- 1. Enable in-air auto avoidance &amp; max avoidance trigger distance

  local prop_air = UE.find_property(pawn_cls, 'CanAutoAvoidanceInAir')

  if prop_air and prop_air.offset then writeBytes(pawn + prop_air.offset, 1) end



  local prop_near = UE.find_property(pawn_cls, 'NearestJustAvoidanceAttackDistance')

  if prop_near and prop_near.offset then writeFloat(pawn + prop_near.offset, 99999.0) end



  -- 2. Infinite Just Guard Duration (0.27s -&gt; 999.0s)

  local prop_jg = UE.find_property(pawn_cls, 'JustGuardDuration')

  if prop_jg and prop_jg.offset then writeFloat(pawn + prop_jg.offset, 999.0) end



  local prop_djg = UE.find_property(pawn_cls, 'DefaultJustGuardDuration')

  if prop_djg and prop_djg.offset then writeFloat(pawn + prop_djg.offset, 999.0) end



  -- 3. BattleSet: Maximize Avoid and TemporalAutoAvoidRate

  local battle_set = UE.read_property(pawn, 'BattleSet')

  if battle_set and battle_set &gt; 0 then

    local cur_auto = UE.read_attribute(battle_set, 'TemporalAutoAvoidRate')

    if not cur_auto or cur_auto.current &lt; 1.0 then

      UE.write_attribute(battle_set, 'TemporalAutoAvoidRate', 1.0)

    end

    local cur_avoid = UE.read_attribute(battle_set, 'Avoid')

    if not cur_avoid or cur_avoid.current &lt; 100.0 then

      UE.write_attribute(battle_set, 'Avoid', 100.0)

    end

  end

end



if AUTO_AVOID_TIMER then

  AUTO_AVOID_TIMER.destroy()

  AUTO_AVOID_TIMER = nil

end



AUTO_AVOID_TIMER = createTimer(nil, false)

AUTO_AVOID_TIMER.Interval = UPDATE_INTERVAL_MS

AUTO_AVOID_TIMER.OnTimer = function()

  pcall(apply_perfect_avoid_guard)

end

AUTO_AVOID_TIMER.Enabled = true

pcall(apply_perfect_avoid_guard)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if AUTO_AVOID_TIMER then

  AUTO_AVOID_TIMER.Enabled = false

  AUTO_AVOID_TIMER.destroy()

  AUTO_AVOID_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local pawn_cls = UE_REFLECTION.get_class(pawn)

    local prop_near = UE_REFLECTION.find_property(pawn_cls, 'NearestJustAvoidanceAttackDistance')

    if prop_near and prop_near.offset then writeFloat(pawn + prop_near.offset, 100.0) end

    local prop_djg = UE_REFLECTION.find_property(pawn_cls, 'DefaultJustGuardDuration')

    local def_val = prop_djg and readFloat(pawn + prop_djg.offset) or 0.27

    local prop_jg = UE_REFLECTION.find_property(pawn_cls, 'JustGuardDuration')

    if prop_jg and prop_jg.offset then writeFloat(pawn + prop_jg.offset, def_val) end

  end

end

{$asm}

</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27720</ID>
          <Description>"Combat &amp; Damage Multipliers"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27667</ID>
              <Description>"Damage Multiplier (10x Damage)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Damage Multiplier (10x Damage)

-- Pure-Lua UE5 reflection script. Multiplies melee, skill, and general attack damage by 10x.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY   = 'BattleSet'

local TARGET_MULTIPLIER     = 10.0

local UPDATE_INTERVAL_MS    = 100



local ATTRIBUTES_TO_MULTIPLY = {

  'AttackMultiplier',

  'MeleeAttackMultiplier',

  'SkillDamageAttackMultiplier',

  'ArrowAttackMultiplier'

}



local state = { pawn = nil, class = nil, last_search = nil }



local function update_damage_multiplier()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  for _, attr_name in ipairs(ATTRIBUTES_TO_MULTIPLY) do

    local cur = UE.read_attribute(battle_set, attr_name)

    if not cur or cur.current &lt; TARGET_MULTIPLIER then

      UE.write_attribute(battle_set, attr_name, TARGET_MULTIPLIER)

    end

  end

end



if DAMAGE_MULTIPLIER_TIMER then

  DAMAGE_MULTIPLIER_TIMER.destroy()

  DAMAGE_MULTIPLIER_TIMER = nil

end



DAMAGE_MULTIPLIER_TIMER = createTimer(nil, false)

DAMAGE_MULTIPLIER_TIMER.Interval = UPDATE_INTERVAL_MS

DAMAGE_MULTIPLIER_TIMER.OnTimer = function()

  pcall(update_damage_multiplier)

end

DAMAGE_MULTIPLIER_TIMER.Enabled = true

pcall(update_damage_multiplier)



{$asm}

[DISABLE]

{$lua}

if DAMAGE_MULTIPLIER_TIMER then

  DAMAGE_MULTIPLIER_TIMER.Enabled = false

  DAMAGE_MULTIPLIER_TIMER.destroy()

  DAMAGE_MULTIPLIER_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'AttackMultiplier', 1.0)

      UE_REFLECTION.write_attribute(battle_set, 'MeleeAttackMultiplier', 1.0)

      UE_REFLECTION.write_attribute(battle_set, 'SkillDamageAttackMultiplier', 1.0)

      UE_REFLECTION.write_attribute(battle_set, 'ArrowAttackMultiplier', 1.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27665</ID>
              <Description>"100% Critical Hit Rate &amp; Enhanced Crit Damage"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- 100% Critical Hit Rate &amp; Enhanced Crit Damage

-- Pure-Lua UE5 reflection script. Guarantees critical hits on every attack with 5x crit damage.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY           = 'BattleSet'

local CRITICAL_RATE_ATTRIBUTE       = 'CriticalRate'

local CRITICAL_DAMAGE_ATTRIBUTE     = 'CriticalDamageRate'

local TARGET_CRIT_RATE              = 1.0

local TARGET_CRIT_DAMAGE            = 5.0

local UPDATE_INTERVAL_MS            = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_crit()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_rate = UE.read_attribute(battle_set, CRITICAL_RATE_ATTRIBUTE)

  if not cur_rate or cur_rate.current &lt; TARGET_CRIT_RATE then

    UE.write_attribute(battle_set, CRITICAL_RATE_ATTRIBUTE, TARGET_CRIT_RATE)

  end



  local cur_dmg = UE.read_attribute(battle_set, CRITICAL_DAMAGE_ATTRIBUTE)

  if not cur_dmg or cur_dmg.current &lt; TARGET_CRIT_DAMAGE then

    UE.write_attribute(battle_set, CRITICAL_DAMAGE_ATTRIBUTE, TARGET_CRIT_DAMAGE)

  end

end



if CRITICAL_HITS_TIMER then

  CRITICAL_HITS_TIMER.destroy()

  CRITICAL_HITS_TIMER = nil

end



CRITICAL_HITS_TIMER = createTimer(nil, false)

CRITICAL_HITS_TIMER.Interval = UPDATE_INTERVAL_MS

CRITICAL_HITS_TIMER.OnTimer = function()

  pcall(update_crit)

end

CRITICAL_HITS_TIMER.Enabled = true

pcall(update_crit)



{$asm}

[DISABLE]

{$lua}

if CRITICAL_HITS_TIMER then

  CRITICAL_HITS_TIMER.Enabled = false

  CRITICAL_HITS_TIMER.destroy()

  CRITICAL_HITS_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'CriticalRate', 0.0)

      UE_REFLECTION.write_attribute(battle_set, 'CriticalDamageRate', 1.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27666</ID>
              <Description>"Life Steal (Vampirism on Hit)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Life Steal (Vampirism on Hit)

-- Pure-Lua UE5 reflection script. Absorbs health on every attack hit against enemies.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY     = 'BattleSet'

local HEALTH_DRAIN_ATTRIBUTE  = 'HealthDrain'

local TARGET_DRAIN_VALUE      = 0.5

local UPDATE_INTERVAL_MS      = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_lifesteal()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_drain = UE.read_attribute(battle_set, HEALTH_DRAIN_ATTRIBUTE)

  if not cur_drain or cur_drain.current &lt; TARGET_DRAIN_VALUE then

    UE.write_attribute(battle_set, HEALTH_DRAIN_ATTRIBUTE, TARGET_DRAIN_VALUE)

  end

end



if LIFE_STEAL_TIMER then

  LIFE_STEAL_TIMER.destroy()

  LIFE_STEAL_TIMER = nil

end



LIFE_STEAL_TIMER = createTimer(nil, false)

LIFE_STEAL_TIMER.Interval = UPDATE_INTERVAL_MS

LIFE_STEAL_TIMER.OnTimer = function()

  pcall(update_lifesteal)

end

LIFE_STEAL_TIMER.Enabled = true

pcall(update_lifesteal)



{$asm}

[DISABLE]

{$lua}

if LIFE_STEAL_TIMER then

  LIFE_STEAL_TIMER.Enabled = false

  LIFE_STEAL_TIMER.destroy()

  LIFE_STEAL_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'HealthDrain', 0.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27668</ID>
              <Description>"Instant Stagger / Boss Break"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Instant Stagger / Boss Break

-- Pure-Lua UE5 reflection script. Drastically amplifies enemy poise/stagger damage and guard break.

-- Puts bosses and enemies into vulnerable stun states almost instantly.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY = 'BattleSet'

local UPDATE_INTERVAL_MS  = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_boss_break()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_stagger = UE.read_attribute(battle_set, 'StaggerAttackMultiplier')

  if not cur_stagger or cur_stagger.current &lt; 50.0 then

    UE.write_attribute(battle_set, 'StaggerAttackMultiplier', 50.0)

  end



  local cur_sgb = UE.read_attribute(battle_set, 'SwordGuardBreak')

  if not cur_sgb or cur_sgb.current &lt; 100.0 then

    UE.write_attribute(battle_set, 'SwordGuardBreak', 100.0)

  end



  local cur_shgb = UE.read_attribute(battle_set, 'ShieldGuardBreak')

  if not cur_shgb or cur_shgb.current &lt; 100.0 then

    UE.write_attribute(battle_set, 'ShieldGuardBreak', 100.0)

  end

end



if INSTANT_STAGGER_TIMER then

  INSTANT_STAGGER_TIMER.destroy()

  INSTANT_STAGGER_TIMER = nil

end



INSTANT_STAGGER_TIMER = createTimer(nil, false)

INSTANT_STAGGER_TIMER.Interval = UPDATE_INTERVAL_MS

INSTANT_STAGGER_TIMER.OnTimer = function()

  pcall(update_boss_break)

end

INSTANT_STAGGER_TIMER.Enabled = true

pcall(update_boss_break)



{$asm}

[DISABLE]

{$lua}

if INSTANT_STAGGER_TIMER then

  INSTANT_STAGGER_TIMER.Enabled = false

  INSTANT_STAGGER_TIMER.destroy()

  INSTANT_STAGGER_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'StaggerAttackMultiplier', 1.0)

      UE_REFLECTION.write_attribute(battle_set, 'SwordGuardBreak', 0.0)

      UE_REFLECTION.write_attribute(battle_set, 'ShieldGuardBreak', 0.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27673</ID>
              <Description>"Instant Status Effect Infliction on Enemies"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Instant Status Effect Infliction on Enemies

-- Pure-Lua UE5 reflection script. Multiplies player status effect buildup by 50x (Acid, Burn, Electric, Poison).

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY = 'BattleSet'

local TARGET_STATUS_MULT  = 50.0

local TARGET_DOT_MULT     = 10.0

local UPDATE_INTERVAL_MS  = 100



local state = { pawn = nil, class = nil, last_search = nil }



local status_mult_attributes = {

  'AcidAttackAccumulateMultiplier',

  'BurnAttackAccumulateMultiplier',

  'ElectricAttackAccumulateMultiplier',

  'PoisonAttackAccumulateMultiplier',

  'EnhanceStatusEffectAccumulateMultiplier'

}



local dot_mult_attributes = {

  'AcidDOTMultiplier',

  'BurnDOTMultiplier',

  'ElectricDOTMultiplier',

  'PoisonDOTMultiplier'

}



local function update_status_effects()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  for _, attr in ipairs(status_mult_attributes) do

    local cur = UE.read_attribute(battle_set, attr)

    if not cur or cur.current &lt; TARGET_STATUS_MULT then

      UE.write_attribute(battle_set, attr, TARGET_STATUS_MULT)

    end

  end



  for _, attr in ipairs(dot_mult_attributes) do

    local cur = UE.read_attribute(battle_set, attr)

    if not cur or cur.current &lt; TARGET_DOT_MULT then

      UE.write_attribute(battle_set, attr, TARGET_DOT_MULT)

    end

  end

end



if STATUS_INFLICTION_TIMER then

  STATUS_INFLICTION_TIMER.destroy()

  STATUS_INFLICTION_TIMER = nil

end



STATUS_INFLICTION_TIMER = createTimer(nil, false)

STATUS_INFLICTION_TIMER.Interval = UPDATE_INTERVAL_MS

STATUS_INFLICTION_TIMER.OnTimer = function()

  pcall(update_status_effects)

end

STATUS_INFLICTION_TIMER.Enabled = true

pcall(update_status_effects)



{$asm}

[DISABLE]

{$lua}

if STATUS_INFLICTION_TIMER then

  STATUS_INFLICTION_TIMER.Enabled = false

  STATUS_INFLICTION_TIMER.destroy()

  STATUS_INFLICTION_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      local status_mult_attrs = {

        'AcidAttackAccumulateMultiplier',

        'BurnAttackAccumulateMultiplier',

        'ElectricAttackAccumulateMultiplier',

        'PoisonAttackAccumulateMultiplier',

        'EnhanceStatusEffectAccumulateMultiplier'

      }

      for _, attr in ipairs(status_mult_attrs) do

        UE_REFLECTION.write_attribute(battle_set, attr, 1.0)

      end



      local dot_mult_attrs = {

        'AcidDOTMultiplier',

        'BurnDOTMultiplier',

        'ElectricDOTMultiplier',

        'PoisonDOTMultiplier'

      }

      for _, attr in ipairs(dot_mult_attrs) do

        UE_REFLECTION.write_attribute(battle_set, attr, 0.125)

      end

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27669</ID>
              <Description>"Fast Bow Draw Speed"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Fast Bow Draw Speed

-- Pure-Lua UE5 reflection script. Accelerates bow draw and aiming speed by 5x.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY      = 'BattleSet'

local BOW_DRAW_SPEED_ATTRIBUTE = 'BowDrawSpeedBase'

local TARGET_BOW_SPEED         = 5.0

local UPDATE_INTERVAL_MS       = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_bow_speed()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_speed = UE.read_attribute(battle_set, BOW_DRAW_SPEED_ATTRIBUTE)

  if not cur_speed or cur_speed.current &lt; TARGET_BOW_SPEED then

    UE.write_attribute(battle_set, BOW_DRAW_SPEED_ATTRIBUTE, TARGET_BOW_SPEED)

  end

end



if FAST_BOW_DRAW_TIMER then

  FAST_BOW_DRAW_TIMER.destroy()

  FAST_BOW_DRAW_TIMER = nil

end



FAST_BOW_DRAW_TIMER = createTimer(nil, false)

FAST_BOW_DRAW_TIMER.Interval = UPDATE_INTERVAL_MS

FAST_BOW_DRAW_TIMER.OnTimer = function()

  pcall(update_bow_speed)

end

FAST_BOW_DRAW_TIMER.Enabled = true

pcall(update_bow_speed)



{$asm}

[DISABLE]

{$lua}

if FAST_BOW_DRAW_TIMER then

  FAST_BOW_DRAW_TIMER.Enabled = false

  FAST_BOW_DRAW_TIMER.destroy()

  FAST_BOW_DRAW_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'BowDrawSpeedBase', 1.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27694</ID>
              <Description>"Infinite Arrows &amp; No Reload (Bow &amp; Crossbow)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

-- Infinite Arrows &amp; No Reload (Bow &amp; Crossbow)
-- 100% Pure Lua UE5 Reflection script. Zero Assembly, zero hardcoded addresses.
-- 1. Infinite Ammo: Keeps all 12 Arrow &amp; Crossbow Bolt types in Inventory locked to 99.
-- 2. No Reload &amp; Bottomless Clip: Locks Crossbow magazine slots &amp; Bow quivers to 99 and dynamically patches decrements via reflection.
-- Fully resilient across zone transitions, cutscenes, deaths, and updates.

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local UPDATE_INTERVAL_MS = 50
local TARGET_AMMO_COUNT  = 99

-- State &amp; caches
INFINITE_AMMO_PATCHES = INFINITE_AMMO_PATCHES or {
  xbow_dec_addr = nil,
  bow_dec_addr = nil
}

local ammo_cache = {
  save_sub = nil,
  current_offset = nil,
  inv_offset = nil
}

local function resolve_subsystem()
  if ammo_cache.save_sub and UE.is_valid_pointer(ammo_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        ammo_cache.save_sub = val
        break
      end
    end
  end

  if not ammo_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    ammo_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not ammo_cache.inv_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_inv = struct_each_day and UE.find_property(struct_each_day, 'InventorySaveData')
    ammo_cache.inv_offset = prop_inv and prop_inv.offset or 0x640
  end

  return ammo_cache.save_sub ~= nil
end

local function apply_dynamic_reflection_patches(pawn)
  -- 1. Crossbow Decrement Hook (via Crossbow vtable virtual method 0x7F8)
  if not INFINITE_AMMO_PATCHES.xbow_dec_addr then
    local children_data = readPointer(pawn + 0x190)
    local children_num = readInteger(pawn + 0x198)
    if children_data and children_num and children_num &gt; 0 then
      for i = 0, children_num - 1 do
        local ch = readPointer(children_data + i * 8)
        if ch and ch &gt; 0x10000000000 then
          local cname = UE.get_class_name(ch) or ''
          if cname:find('CrossBow') then
            local vtable = readPointer(ch)
            local target_fn = vtable and readPointer(vtable + 0x7F8)
            if target_fn and target_fn &gt; 0x10000000000 then
              local bytes = readBytes(target_fn, 300, true)
              if bytes then
                for j = 1, #bytes - 2 do
                  if bytes[j] == 0xFF and bytes[j+1] == 0x48 and bytes[j+2] == 0x1C then
                    INFINITE_AMMO_PATCHES.xbow_dec_addr = target_fn + (j - 1)
                    break
                  end
                end
              end
            end
            break
          end
        end
      end
    end
  end

  if INFINITE_AMMO_PATCHES.xbow_dec_addr then
    writeBytes(INFINITE_AMMO_PATCHES.xbow_dec_addr, {0x90, 0x90, 0x90})
  end

  -- 2. Bow / Base Projectile Decrement Hook (via AibouRangedWeaponProjectile CDO vtable 0x7F8)
  if not INFINITE_AMMO_PATCHES.bow_dec_addr then
    local struct_proj = UE.find_struct('AibouRangedWeaponProjectile')
    if struct_proj then
      local cdo = nil
      for off = 0x100, 0x140, 8 do
        local p = readPointer(struct_proj + off)
        if p and p &gt; 0x10000000000 and UE.get_class(p) == struct_proj then
          cdo = p
          break
        end
      end
      local vtable = cdo and readPointer(cdo)
      local base_fn_dec = vtable and readPointer(vtable + 0x7F8)
      if base_fn_dec and base_fn_dec &gt; 0x10000000000 then
        local bytes = readBytes(base_fn_dec, 50, true)
        if bytes then
          for j = 1, #bytes - 5 do
            if bytes[j] == 0xFF and bytes[j+1] == 0x89 and bytes[j+2] == 0x40 and bytes[j+3] == 0x07 and bytes[j+4] == 0x00 and bytes[j+5] == 0x00 then
              INFINITE_AMMO_PATCHES.bow_dec_addr = base_fn_dec + (j - 1)
              break
            end
          end
        end
      end
    end
  end

  if INFINITE_AMMO_PATCHES.bow_dec_addr then
    writeBytes(INFINITE_AMMO_PATCHES.bow_dec_addr, {0x90, 0x90, 0x90, 0x90, 0x90, 0x90})
  end
end

local function update_ammo_state()
  if not UE_REFLECTION then return end
  local pawn = UE.get_local_player_pawn()
  if not pawn then return end

  -- Ensure code patches are applied
  apply_dynamic_reflection_patches(pawn)

  -- [1] Infinite Inventory Arrows &amp; Bolts (Items 116 to 127)
  if resolve_subsystem() then
    local save_sub = ammo_cache.save_sub
    local inv_addr = save_sub + 0x50 + ammo_cache.current_offset + ammo_cache.inv_offset
    local map_ptr = readPointer(inv_addr)
    local map_max = readInteger(inv_addr + 0xC)
    if map_ptr and map_max and map_max &gt; 0 then
      for i = 0, map_max - 1 do
        local elem = map_ptr + i * 24
        local comp_idx = readInteger(elem)
        local num_idx = readInteger(elem + 4)
        if comp_idx == 148280 and num_idx &gt;= 116 and num_idx &lt;= 127 then
          local current_val = readInteger(elem + 8)
          if current_val and current_val &lt; TARGET_AMMO_COUNT then
            writeInteger(elem + 8, TARGET_AMMO_COUNT)
          end
        end
      end
    end
  end

  -- [2] Crossbow Magazine Slots &amp; Bow Ammo
  local children_data = readPointer(pawn + 0x190)
  local children_num = readInteger(pawn + 0x198)
  if children_data and children_num and children_num &gt; 0 then
    for i = 0, children_num - 1 do
      local ch = readPointer(children_data + i * 8)
      if ch and ch &gt; 0x10000000000 then
        local cname = UE.get_class_name(ch) or ''
        if cname:find('CrossBow') then
          local rdi = readPointer(ch + 0x990)
          if rdi and rdi &gt; 0x10000000000 then
            local rdx = readPointer(rdi)
            local count = readInteger(rdi + 0x08)
            if rdx and count and count &gt; 0 then
              for s = 0, math.min(count, 4) - 1 do
                local slot_elem = rdx + s * 0x2C
                local ammo = readInteger(slot_elem + 0x1C)
                if ammo and ammo &lt; TARGET_AMMO_COUNT then
                  writeInteger(slot_elem + 0x1C, TARGET_AMMO_COUNT)
                end
              end
            end
          end
          writeInteger(ch + 0x740, TARGET_AMMO_COUNT)
          writeInteger(ch + 0x744, TARGET_AMMO_COUNT)
          writeByte(ch + 0x88C, 0)
        elseif cname:find('Bow') then
          writeInteger(ch + 0x740, TARGET_AMMO_COUNT)
          writeInteger(ch + 0x744, TARGET_AMMO_COUNT)
        end
      end
    end
  end
end

if INFINITE_ARROWS_TIMER then
  INFINITE_ARROWS_TIMER.destroy()
  INFINITE_ARROWS_TIMER = nil
end

INFINITE_ARROWS_TIMER = createTimer(nil, false)
INFINITE_ARROWS_TIMER.Interval = UPDATE_INTERVAL_MS
INFINITE_ARROWS_TIMER.OnTimer = function()
  pcall(update_ammo_state)
end
INFINITE_ARROWS_TIMER.Enabled = true
pcall(update_ammo_state)

{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end

if INFINITE_ARROWS_TIMER then
  INFINITE_ARROWS_TIMER.Enabled = false
  INFINITE_ARROWS_TIMER.destroy()
  INFINITE_ARROWS_TIMER = nil
end

-- Restore original decrement instructions
if INFINITE_AMMO_PATCHES then
  if INFINITE_AMMO_PATCHES.xbow_dec_addr then
    writeBytes(INFINITE_AMMO_PATCHES.xbow_dec_addr, {0xFF, 0x48, 0x1C})
  end
  if INFINITE_AMMO_PATCHES.bow_dec_addr then
    writeBytes(INFINITE_AMMO_PATCHES.bow_dec_addr, {0xFF, 0x89, 0x40, 0x07, 0x00, 0x00})
  end
end

{$asm}
</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27730</ID>
          <Description>"Bloom, Synchro &amp; Buddy System"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27651</ID>
              <Description>"Infinite Bloom Gauge"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Bloom Gauge

-- Pure-Lua UE5 reflection script. Keeps PlayerSkillGaugeSet.CoolTime equal to MaxCoolTime.

-- Resilient to world restarts, scene changes, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local SKILL_GAUGE_SET_PROPERTY = 'PlayerSkillGaugeSet'

local CURRENT_TIME_ATTRIBUTE   = 'CoolTime'

local MAX_TIME_ATTRIBUTE       = 'MaxCoolTime'

local UPDATE_INTERVAL_MS       = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_bloom_gauge()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local gauge_set = UE.read_property(pawn, SKILL_GAUGE_SET_PROPERTY)

  if not gauge_set then return end



  local max_time = UE.read_attribute(gauge_set, MAX_TIME_ATTRIBUTE)

  if max_time and max_time.current and max_time.current &gt; 0 then

    local cool_time = UE.read_attribute(gauge_set, CURRENT_TIME_ATTRIBUTE)

    if not cool_time or cool_time.current &lt; max_time.current or cool_time.base &lt; max_time.current then

      UE.write_attribute(gauge_set, CURRENT_TIME_ATTRIBUTE, max_time.current)

    end

  end

end



if INFINITE_BLOOM_GAUGE_TIMER then

  INFINITE_BLOOM_GAUGE_TIMER.destroy()

  INFINITE_BLOOM_GAUGE_TIMER = nil

end



INFINITE_BLOOM_GAUGE_TIMER = createTimer(nil, false)

INFINITE_BLOOM_GAUGE_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_BLOOM_GAUGE_TIMER.OnTimer = function()

  pcall(update_bloom_gauge)

end

INFINITE_BLOOM_GAUGE_TIMER.Enabled = true

pcall(update_bloom_gauge)



{$asm}

[DISABLE]

{$lua}

if INFINITE_BLOOM_GAUGE_TIMER then

  INFINITE_BLOOM_GAUGE_TIMER.Enabled = false

  INFINITE_BLOOM_GAUGE_TIMER.destroy()

  INFINITE_BLOOM_GAUGE_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27654</ID>
              <Description>"Infinite Flower Points"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Flower Points

-- Pure-Lua UE5 reflection script. Keeps FlowerPointSet.FlowerPoint equal to MaxFlowerPoint.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local FLOWER_POINT_SET_PROPERTY = 'FlowerPointSet'

local CURRENT_POINT_ATTRIBUTE   = 'FlowerPoint'

local MAX_POINT_ATTRIBUTE       = 'MaxFlowerPoint'

local UPDATE_INTERVAL_MS        = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_flower_points()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local point_set = UE.read_property(pawn, FLOWER_POINT_SET_PROPERTY)

  if not point_set or point_set == 0 then return end



  local max_pts = UE.read_attribute(point_set, MAX_POINT_ATTRIBUTE)

  if max_pts and max_pts.current and max_pts.current &gt; 0 then

    local cur_pts = UE.read_attribute(point_set, CURRENT_POINT_ATTRIBUTE)

    if not cur_pts or cur_pts.current &lt; max_pts.current or cur_pts.base &lt; max_pts.current then

      UE.write_attribute(point_set, CURRENT_POINT_ATTRIBUTE, max_pts.current)

    end

  end

end



if INFINITE_FLOWER_POINTS_TIMER then

  INFINITE_FLOWER_POINTS_TIMER.destroy()

  INFINITE_FLOWER_POINTS_TIMER = nil

end



INFINITE_FLOWER_POINTS_TIMER = createTimer(nil, false)

INFINITE_FLOWER_POINTS_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_FLOWER_POINTS_TIMER.OnTimer = function()

  pcall(update_flower_points)

end

INFINITE_FLOWER_POINTS_TIMER.Enabled = true

pcall(update_flower_points)



{$asm}

[DISABLE]

{$lua}

if INFINITE_FLOWER_POINTS_TIMER then

  INFINITE_FLOWER_POINTS_TIMER.Enabled = false

  INFINITE_FLOWER_POINTS_TIMER.destroy()

  INFINITE_FLOWER_POINTS_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27655</ID>
              <Description>"Infinite Synchro Boost"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Synchro Boost

-- Pure-Lua UE5 reflection script. Keeps SynchroBoostSet.SynchroBoost equal to MaxSynchroBoost.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local SYNCHRO_BOOST_SET_PROPERTY = 'SynchroBoostSet'

local CURRENT_BOOST_ATTRIBUTE    = 'SynchroBoost'

local MAX_BOOST_ATTRIBUTE        = 'MaxSynchroBoost'

local UPDATE_INTERVAL_MS         = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_synchro_boost()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local boost_set = UE.read_property(pawn, SYNCHRO_BOOST_SET_PROPERTY)

  if not boost_set or boost_set == 0 then return end



  local max_boost = UE.read_attribute(boost_set, MAX_BOOST_ATTRIBUTE)

  if max_boost and max_boost.current and max_boost.current &gt; 0 then

    local cur_boost = UE.read_attribute(boost_set, CURRENT_BOOST_ATTRIBUTE)

    if not cur_boost or cur_boost.current &lt; max_boost.current or cur_boost.base &lt; max_boost.current then

      UE.write_attribute(boost_set, CURRENT_BOOST_ATTRIBUTE, max_boost.current)

    end

  end

end



if INFINITE_SYNCHRO_BOOST_TIMER then

  INFINITE_SYNCHRO_BOOST_TIMER.destroy()

  INFINITE_SYNCHRO_BOOST_TIMER = nil

end



INFINITE_SYNCHRO_BOOST_TIMER = createTimer(nil, false)

INFINITE_SYNCHRO_BOOST_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_SYNCHRO_BOOST_TIMER.OnTimer = function()

  pcall(update_synchro_boost)

end

INFINITE_SYNCHRO_BOOST_TIMER.Enabled = true

pcall(update_synchro_boost)



{$asm}

[DISABLE]

{$lua}

if INFINITE_SYNCHRO_BOOST_TIMER then

  INFINITE_SYNCHRO_BOOST_TIMER.Enabled = false

  INFINITE_SYNCHRO_BOOST_TIMER.destroy()

  INFINITE_SYNCHRO_BOOST_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27656</ID>
              <Description>"Infinite Buddy Commands &amp; Resonance"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Buddy Commands &amp; Resonance

-- Pure-Lua UE5 reflection script. Keeps CommandSet.BuddyCommand and BuddyResonanceStock at maximum.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local COMMAND_SET_PROPERTY       = 'CommandSet'

local COMMAND_ATTRIBUTE          = 'BuddyCommand'

local MAX_COMMAND_ATTRIBUTE      = 'MaxBuddyCommand'

local RESONANCE_ATTRIBUTE        = 'BuddyResonanceStock'

local MAX_RESONANCE_ATTRIBUTE    = 'MaxBuddyResonanceStock'

local UPDATE_INTERVAL_MS         = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_buddy_commands()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local cmd_set = UE.read_property(pawn, COMMAND_SET_PROPERTY)

  if not cmd_set or cmd_set == 0 then return end



  -- 1. Infinite Buddy Commands

  local max_cmd = UE.read_attribute(cmd_set, MAX_COMMAND_ATTRIBUTE)

  if max_cmd and max_cmd.current and max_cmd.current &gt; 0 then

    local cur_cmd = UE.read_attribute(cmd_set, COMMAND_ATTRIBUTE)

    if not cur_cmd or cur_cmd.current &lt; max_cmd.current or cur_cmd.base &lt; max_cmd.current then

      UE.write_attribute(cmd_set, COMMAND_ATTRIBUTE, max_cmd.current)

    end

  end



  -- 2. Infinite Resonance Stocks

  local max_res = UE.read_attribute(cmd_set, MAX_RESONANCE_ATTRIBUTE)

  if max_res and max_res.current and max_res.current &gt; 0 then

    local cur_res = UE.read_attribute(cmd_set, RESONANCE_ATTRIBUTE)

    if not cur_res or cur_res.current &lt; max_res.current or cur_res.base &lt; max_res.current then

      UE.write_attribute(cmd_set, RESONANCE_ATTRIBUTE, max_res.current)

    end

  end

end



if INFINITE_BUDDY_COMMANDS_TIMER then

  INFINITE_BUDDY_COMMANDS_TIMER.destroy()

  INFINITE_BUDDY_COMMANDS_TIMER = nil

end



INFINITE_BUDDY_COMMANDS_TIMER = createTimer(nil, false)

INFINITE_BUDDY_COMMANDS_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_BUDDY_COMMANDS_TIMER.OnTimer = function()

  pcall(update_buddy_commands)

end

INFINITE_BUDDY_COMMANDS_TIMER.Enabled = true

pcall(update_buddy_commands)



{$asm}

[DISABLE]

{$lua}

if INFINITE_BUDDY_COMMANDS_TIMER then

  INFINITE_BUDDY_COMMANDS_TIMER.Enabled = false

  INFINITE_BUDDY_COMMANDS_TIMER.destroy()

  INFINITE_BUDDY_COMMANDS_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27657</ID>
              <Description>"Infinite Buddy Satiety (Never Hungry)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Infinite Buddy Satiety (Never Hungry)

-- Pure-Lua UE5 reflection script. Keeps HungerSet.Hunger locked to MaxHunger.

-- Prevents companion hunger depletion and enables continuous auto-healing.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local HUNGER_SET_PROPERTY = 'HungerSet'

local HUNGER_ATTRIBUTE     = 'Hunger'

local MAX_HUNGER_ATTRIBUTE = 'MaxHunger'

local UPDATE_INTERVAL_MS   = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_hunger()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local hunger_set = UE.read_property(pawn, HUNGER_SET_PROPERTY)

  if not hunger_set or hunger_set == 0 then return end



  local max_hunger = UE.read_attribute(hunger_set, MAX_HUNGER_ATTRIBUTE)

  if max_hunger and max_hunger.current and max_hunger.current &gt; 0 then

    local cur_hunger = UE.read_attribute(hunger_set, HUNGER_ATTRIBUTE)

    if not cur_hunger or cur_hunger.current &lt; max_hunger.current or cur_hunger.base &lt; max_hunger.current then

      UE.write_attribute(hunger_set, HUNGER_ATTRIBUTE, max_hunger.current)

    end

  end

end



if INFINITE_BUDDY_SATIETY_TIMER then

  INFINITE_BUDDY_SATIETY_TIMER.destroy()

  INFINITE_BUDDY_SATIETY_TIMER = nil

end



INFINITE_BUDDY_SATIETY_TIMER = createTimer(nil, false)

INFINITE_BUDDY_SATIETY_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_BUDDY_SATIETY_TIMER.OnTimer = function()

  pcall(update_hunger)

end

INFINITE_BUDDY_SATIETY_TIMER.Enabled = true

pcall(update_hunger)



{$asm}

[DISABLE]

{$lua}

if INFINITE_BUDDY_SATIETY_TIMER then

  INFINITE_BUDDY_SATIETY_TIMER.Enabled = false

  INFINITE_BUDDY_SATIETY_TIMER.destroy()

  INFINITE_BUDDY_SATIETY_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27659</ID>
              <Description>"Max Player Nutrition"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Max Player Nutrition

-- Pure-Lua UE5 reflection script. Keeps HealthSet.Nutrition locked to MaxNutrition (100).

-- Keeps the player character fully nourished without consuming food items.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local HEALTH_SET_PROPERTY     = 'HealthSet'

local NUTRITION_ATTRIBUTE     = 'Nutrition'

local MAX_NUTRITION_ATTRIBUTE = 'MaxNutrition'

local UPDATE_INTERVAL_MS      = 80



local state = { pawn = nil, class = nil, last_search = nil }



local function update_nutrition()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local health_set = UE.read_property(pawn, HEALTH_SET_PROPERTY)

  if not health_set or health_set == 0 then return end



  local max_nut = UE.read_attribute(health_set, MAX_NUTRITION_ATTRIBUTE)

  local target_val = (max_nut and max_nut.current and max_nut.current &gt; 0) and max_nut.current or 100



  local cur_nut = UE.read_attribute(health_set, NUTRITION_ATTRIBUTE)

  if not cur_nut or cur_nut.current &lt; target_val or cur_nut.base &lt; target_val then

    UE.write_attribute(health_set, NUTRITION_ATTRIBUTE, target_val)

  end

end



if MAX_PLAYER_NUTRITION_TIMER then

  MAX_PLAYER_NUTRITION_TIMER.destroy()

  MAX_PLAYER_NUTRITION_TIMER = nil

end



MAX_PLAYER_NUTRITION_TIMER = createTimer(nil, false)

MAX_PLAYER_NUTRITION_TIMER.Interval = UPDATE_INTERVAL_MS

MAX_PLAYER_NUTRITION_TIMER.OnTimer = function()

  pcall(update_nutrition)

end

MAX_PLAYER_NUTRITION_TIMER.Enabled = true

pcall(update_nutrition)



{$asm}

[DISABLE]

{$lua}

if MAX_PLAYER_NUTRITION_TIMER then

  MAX_PLAYER_NUTRITION_TIMER.Enabled = false

  MAX_PLAYER_NUTRITION_TIMER.destroy()

  MAX_PLAYER_NUTRITION_TIMER = nil

end



{$asm}

</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27675</ID>
          <Description>"Character Progression &amp; Currency"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27670</ID>
              <Description>"10x EXP &amp; Amber Multiplier"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- 10x EXP &amp; Amber Multiplier

-- Pure-Lua UE5 reflection script. Multiplies earned Experience and Amber rewards by 10x.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY  = 'BattleSet'

local TARGET_RATE          = 10.0

local UPDATE_INTERVAL_MS   = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_exp_amber()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_exp = UE.read_attribute(battle_set, 'ExpRate')

  if not cur_exp or cur_exp.current &lt; TARGET_RATE then

    UE.write_attribute(battle_set, 'ExpRate', TARGET_RATE)

  end



  local cur_amber = UE.read_attribute(battle_set, 'AmberRate')

  if not cur_amber or cur_amber.current &lt; TARGET_RATE then

    UE.write_attribute(battle_set, 'AmberRate', TARGET_RATE)

  end

end



if EXP_AMBER_MULTIPLIER_TIMER then

  EXP_AMBER_MULTIPLIER_TIMER.destroy()

  EXP_AMBER_MULTIPLIER_TIMER = nil

end



EXP_AMBER_MULTIPLIER_TIMER = createTimer(nil, false)

EXP_AMBER_MULTIPLIER_TIMER.Interval = UPDATE_INTERVAL_MS

EXP_AMBER_MULTIPLIER_TIMER.OnTimer = function()

  pcall(update_exp_amber)

end

EXP_AMBER_MULTIPLIER_TIMER.Enabled = true

pcall(update_exp_amber)



{$asm}

[DISABLE]

{$lua}

if EXP_AMBER_MULTIPLIER_TIMER then

  EXP_AMBER_MULTIPLIER_TIMER.Enabled = false

  EXP_AMBER_MULTIPLIER_TIMER.destroy()

  EXP_AMBER_MULTIPLIER_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'ExpRate', 1.0)

      UE_REFLECTION.write_attribute(battle_set, 'AmberRate', 1.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27691</ID>
              <Description>"Infinite Amber (Currency for Upgrades &amp; Shop)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Infinite Amber (Currency for Upgrades &amp; Shop)

-- Pure-Lua UE5 reflection script. 100% dynamic, zero hardcoded addresses or offsets.

-- Resolves AibouInventorySubsystem and GetAmberItemNum via class reflection hierarchy.

-- Hooks GetAmberItemNum to return 999,999 Amber for all UI menus, shops, and upgrade checks.

-- Also boosts AmberRate in the character's BattleSet.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



-- Resolve native GetAmberItemNum dynamically through class reflection

local cls = UE.find_struct('AibouInventorySubsystem', 'class')

local fn_amber = nil

if cls then

  local f = readPointer(cls + 0x48) -- STRUCT_CHILDREN

  while f and f &gt; 0 do

    if UE.get_object_name(f) == 'GetAmberItemNum' then fn_amber = f break end

    f = readPointer(f + 0x28) -- FIELD_NEXT_UFIELD

  end

end



local target_addr = nil

if fn_amber then

  local thunk = readPointer(fn_amber + 0xD8)

  if thunk then

    for i = 0, 0x40 do

      if readBytes(thunk + i, 1, false) == 0xE8 then

        local disp = readInteger(thunk + i + 1)

        if disp &gt;= 0x80000000 then disp = disp - 0x100000000 end

        target_addr = thunk + i + 5 + disp

        break

      end

    end

  end

end



if target_addr and target_addr &gt; 0 then

  DYNAMIC_AMBER_TARGET = target_addr

  DYNAMIC_AMBER_ORIGINAL_BYTES = readBytes(target_addr, 6, true)

  writeBytes(target_addr, {0xB8, 0x3F, 0x42, 0x0F, 0x00, 0xC3}) -- mov eax, 999999; ret

end



-- Boost AmberRate in BattleSet via reflection

pcall(function()

  local pawn = UE.get_local_player_pawn()

  if pawn then

    local battle_set = UE.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE.write_attribute(battle_set, 'AmberRate', 999.0)

    end

  end

end)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if DYNAMIC_AMBER_TARGET and DYNAMIC_AMBER_ORIGINAL_BYTES then

  writeBytes(DYNAMIC_AMBER_TARGET, DYNAMIC_AMBER_ORIGINAL_BYTES)

  DYNAMIC_AMBER_TARGET = nil

  DYNAMIC_AMBER_ORIGINAL_BYTES = nil

end



if UE_REFLECTION then

  pcall(function()

    local pawn = UE_REFLECTION.get_local_player_pawn()

    if pawn then

      local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

      if battle_set and battle_set &gt; 0 then

        UE_REFLECTION.write_attribute(battle_set, 'AmberRate', 1.0)

      end

    end

  end)

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27692</ID>
              <Description>"Infinite Skill Points (PC for Skill Tree)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Infinite Skill Points (PC for Skill Tree)

-- Pure-Lua UE5 reflection script. 100% dynamic, zero hardcoded offsets.

-- Resolves CacheSkillPoint and RemainingSkillPoint by name through reflection.

-- Locks available skill points to 99, allowing unlocking all skills in the tree.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local TARGET_SKILL_PTS   = 99

local UPDATE_INTERVAL_MS = 100



local state = { pawn = nil, class = nil, last_search = nil }

local pc_prop_cache = {}



local function update_pc()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local pawn_class = UE.get_class(pawn)

  if not pawn_class or pawn_class == 0 then return end



  -- Resolve CacheSkillPoint property dynamically on Pawn class

  if not pc_prop_cache.pawn_class or pc_prop_cache.pawn_class ~= pawn_class then

    pc_prop_cache.pawn_class = pawn_class

    local prop = UE.find_property(pawn_class, 'CacheSkillPoint')

    pc_prop_cache.cache_sp_offset = prop and prop.offset

  end



  if pc_prop_cache.cache_sp_offset then

    local cur = readInteger(pawn + pc_prop_cache.cache_sp_offset)

    if not cur or cur &lt; TARGET_SKILL_PTS then

      writeInteger(pawn + pc_prop_cache.cache_sp_offset, TARGET_SKILL_PTS)

    end

  end



  -- Resolve RemainingSkillPoint property dynamically on AbilityPointComponent

  local ap_comp = UE.read_property(pawn, 'AbilityPointComponent')

  if ap_comp and ap_comp &gt; 0 then

    local ap_class = UE.get_class(ap_comp)

    if ap_class and ap_class &gt; 0 then

      if not pc_prop_cache.ap_class or pc_prop_cache.ap_class ~= ap_class then

        pc_prop_cache.ap_class = ap_class

        local prop = UE.find_property(ap_class, 'RemainingSkillPoint')

        pc_prop_cache.rem_sp_offset = prop and prop.offset

      end

      if pc_prop_cache.rem_sp_offset then

        local cur = readInteger(ap_comp + pc_prop_cache.rem_sp_offset)

        if not cur or cur &lt; TARGET_SKILL_PTS then

          writeInteger(ap_comp + pc_prop_cache.rem_sp_offset, TARGET_SKILL_PTS)

        end

      end

    end

  end

end



if SKILL_POINTS_PC_TIMER then

  SKILL_POINTS_PC_TIMER.destroy()

  SKILL_POINTS_PC_TIMER = nil

end



SKILL_POINTS_PC_TIMER = createTimer(nil, false)

SKILL_POINTS_PC_TIMER.Interval = UPDATE_INTERVAL_MS

SKILL_POINTS_PC_TIMER.OnTimer = function()

  pcall(update_pc)

end

SKILL_POINTS_PC_TIMER.Enabled = true

pcall(update_pc)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if SKILL_POINTS_PC_TIMER then

  SKILL_POINTS_PC_TIMER.Enabled = false

  SKILL_POINTS_PC_TIMER.destroy()

  SKILL_POINTS_PC_TIMER = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27676</ID>
              <Description>"Infinite Attribute &amp; Skill Points (Player &amp; Buddy)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Infinite Attribute &amp; Skill Points (Player &amp; Buddy)

-- Pure-Lua UE5 reflection script. 100% dynamic, zero hardcoded offsets.

-- Locks player and buddy available attribute and skill points to 99.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local TARGET_POINTS      = 99

local UPDATE_INTERVAL_MS = 100



local state = { pawn = nil, class = nil, last_search = nil }

local ap_prop_cache = {}



local function update_points()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local ap_comp = UE.read_property(pawn, 'AbilityPointComponent')

  if not ap_comp or ap_comp == 0 then return end



  local ap_class = UE.get_class(ap_comp)

  if not ap_class or ap_class == 0 then return end



  -- Resolve property offsets dynamically by name through UE reflection

  if not ap_prop_cache.class or ap_prop_cache.class ~= ap_class then

    ap_prop_cache.class = ap_class

    local p_ap = UE.find_property(ap_class, 'RemainingAbilityPoint')

    local p_sp = UE.find_property(ap_class, 'RemainingSkillPoint')

    local b_ap = UE.find_property(ap_class, 'BuddyRemainingAbilityPoint')

    local b_sp = UE.find_property(ap_class, 'BuddyRemainingSkillPoint')

    ap_prop_cache.rem_ap = p_ap and p_ap.offset

    ap_prop_cache.rem_sp = p_sp and p_sp.offset

    ap_prop_cache.b_ap   = b_ap and b_ap.offset

    ap_prop_cache.b_sp   = b_sp and b_sp.offset

  end



  if ap_prop_cache.rem_ap then

    local v = readInteger(ap_comp + ap_prop_cache.rem_ap)

    if not v or v &lt; TARGET_POINTS then writeInteger(ap_comp + ap_prop_cache.rem_ap, TARGET_POINTS) end

  end



  if ap_prop_cache.rem_sp then

    local v = readInteger(ap_comp + ap_prop_cache.rem_sp)

    if not v or v &lt; TARGET_POINTS then writeInteger(ap_comp + ap_prop_cache.rem_sp, TARGET_POINTS) end

  end



  if ap_prop_cache.b_ap then

    local v = readInteger(ap_comp + ap_prop_cache.b_ap)

    if not v or v &lt; TARGET_POINTS then writeInteger(ap_comp + ap_prop_cache.b_ap, TARGET_POINTS) end

  end



  if ap_prop_cache.b_sp then

    local v = readInteger(ap_comp + ap_prop_cache.b_sp)

    if not v or v &lt; TARGET_POINTS then writeInteger(ap_comp + ap_prop_cache.b_sp, TARGET_POINTS) end

  end

end



if INFINITE_POINTS_TIMER then

  INFINITE_POINTS_TIMER.destroy()

  INFINITE_POINTS_TIMER = nil

end



INFINITE_POINTS_TIMER = createTimer(nil, false)

INFINITE_POINTS_TIMER.Interval = UPDATE_INTERVAL_MS

INFINITE_POINTS_TIMER.OnTimer = function()

  pcall(update_points)

end

INFINITE_POINTS_TIMER.Enabled = true

pcall(update_points)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if INFINITE_POINTS_TIMER then

  INFINITE_POINTS_TIMER.Enabled = false

  INFINITE_POINTS_TIMER.destroy()

  INFINITE_POINTS_TIMER = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27677</ID>
              <Description>"Max Base Attributes (99 Strength, Vitality, Energy)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Max Base Attributes (99 Strength, Vitality, Energy)

-- Pure-Lua UE5 reflection script. Boosts base attributes to 99 for both Emma and Buddy.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local TARGET_STAT_VALUE  = 99.0

local UPDATE_INTERVAL_MS = 100



local state = { pawn = nil, class = nil, last_search = nil }

local stats_list = { 'Strength', 'Vitality', 'Energy' }



local function update_attributes()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  -- Player StatusSet

  local ss = UE.read_property(pawn, 'StatusSet')

  if ss and ss &gt; 0 then

    for _, name in ipairs(stats_list) do

      local cur = UE.read_attribute(ss, name)

      if not cur or cur.current &lt; TARGET_STAT_VALUE then

        UE.write_attribute(ss, name, TARGET_STAT_VALUE)

      end

    end

  end



  -- Buddy StatusSet

  local buddy = UE.read_property(pawn, 'Buddy')

  if buddy and buddy &gt; 0 then

    local buddy_ss = UE.read_property(buddy, 'StatusSet')

    if buddy_ss and buddy_ss &gt; 0 then

      for _, name in ipairs(stats_list) do

        local cur = UE.read_attribute(buddy_ss, name)

        if not cur or cur.current &lt; TARGET_STAT_VALUE then

          UE.write_attribute(buddy_ss, name, TARGET_STAT_VALUE)

        end

      end

    end

  end

end



if MAX_ATTRIBUTES_TIMER then

  MAX_ATTRIBUTES_TIMER.destroy()

  MAX_ATTRIBUTES_TIMER = nil

end



MAX_ATTRIBUTES_TIMER = createTimer(nil, false)

MAX_ATTRIBUTES_TIMER.Interval = UPDATE_INTERVAL_MS

MAX_ATTRIBUTES_TIMER.OnTimer = function()

  pcall(update_attributes)

end

MAX_ATTRIBUTES_TIMER.Enabled = true

pcall(update_attributes)



{$asm}

[DISABLE]

{$lua}

if MAX_ATTRIBUTES_TIMER then

  MAX_ATTRIBUTES_TIMER.Enabled = false

  MAX_ATTRIBUTES_TIMER.destroy()

  MAX_ATTRIBUTES_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local ss = UE_REFLECTION.read_property(pawn, 'StatusSet')

    if ss and ss &gt; 0 then

      UE_REFLECTION.write_attribute(ss, 'Strength', 5.0)

      UE_REFLECTION.write_attribute(ss, 'Vitality', 5.0)

      UE_REFLECTION.write_attribute(ss, 'Energy', 5.0)

    end

    local buddy = UE_REFLECTION.read_property(pawn, 'Buddy')

    if buddy and buddy &gt; 0 then

      local buddy_ss = UE_REFLECTION.read_property(buddy, 'StatusSet')

      if buddy_ss and buddy_ss &gt; 0 then

        UE_REFLECTION.write_attribute(buddy_ss, 'Strength', 5.0)

        UE_REFLECTION.write_attribute(buddy_ss, 'Vitality', 5.0)

        UE_REFLECTION.write_attribute(buddy_ss, 'Energy', 5.0)

      end

    end

  end

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27672</ID>
              <Description>"Maximum Luck (999 Luck)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- Maximum Luck (999 Luck)

-- Pure-Lua UE5 reflection script. Maximizes player luck attribute for superior item discovery and rare drop rates.

-- Resilient across zone changes, cutscenes, deaths, and game updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local BATTLE_SET_PROPERTY = 'BattleSet'

local TARGET_LUCK         = 999.0

local UPDATE_INTERVAL_MS  = 100



local state = { pawn = nil, class = nil, last_search = nil }



local function update_luck()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local battle_set = UE.read_property(pawn, BATTLE_SET_PROPERTY)

  if not battle_set or battle_set == 0 then return end



  local cur_luck = UE.read_attribute(battle_set, 'LuckBase')

  if not cur_luck or cur_luck.current &lt; TARGET_LUCK then

    UE.write_attribute(battle_set, 'LuckBase', TARGET_LUCK)

  end

end



if MAX_LUCK_TIMER then

  MAX_LUCK_TIMER.destroy()

  MAX_LUCK_TIMER = nil

end



MAX_LUCK_TIMER = createTimer(nil, false)

MAX_LUCK_TIMER.Interval = UPDATE_INTERVAL_MS

MAX_LUCK_TIMER.OnTimer = function()

  pcall(update_luck)

end

MAX_LUCK_TIMER.Enabled = true

pcall(update_luck)



{$asm}

[DISABLE]

{$lua}

if MAX_LUCK_TIMER then

  MAX_LUCK_TIMER.Enabled = false

  MAX_LUCK_TIMER.destroy()

  MAX_LUCK_TIMER = nil

end



if UE_REFLECTION then

  local pawn = UE_REFLECTION.get_local_player_pawn()

  if pawn then

    local battle_set = UE_REFLECTION.read_property(pawn, 'BattleSet')

    if battle_set and battle_set &gt; 0 then

      UE_REFLECTION.write_attribute(battle_set, 'LuckBase', 0.0)

    end

  end

end



{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27693</ID>
              <Description>"Free Upgrades &amp; Skills (No Amber, No PC, No Atelier Rank) - Not working!!!"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Free Upgrades &amp; Skills (No Amber, No PC, No Atelier Rank)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded offsets, zero AOBs.

-- 1. Infinite PC (99 Skill Points) &amp; Satisfies all Skill Tree Attribute requirements (99 Vitality, Strength, Energy).

-- 2. Infinite Amber currency rate &amp; balance for all equipment upgrades.

-- 3. Bypasses Bauera Facility &amp; VehicleSpec Rank requirements (removes [Cadena 2], unlocks Duplication pierres spirituelles, unlocks all weapon &amp; arrow upgrade tiers).

-- Saves legitimately in savegame. Resilient across zone changes, cutscenes, deaths, and updates.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local UPDATE_INTERVAL_MS = 100

local state = { pawn = nil, class = nil, last_search = nil }

local cache = {}



local function update_free_upgrades()

  if not UE_REFLECTION then return end

  local pawn = UE.get_local_player_pawn(state)

  if not pawn then return end



  local pawn_class = UE.get_class(pawn)

  if not pawn_class or pawn_class == 0 then return end



  -- [A] Skill Tree PC (CacheSkillPoint on Pawn)

  if not cache.pawn_class or cache.pawn_class ~= pawn_class then

    cache.pawn_class = pawn_class

    local prop = UE.find_property(pawn_class, 'CacheSkillPoint')

    cache.cache_sp_offset = prop and prop.offset

  end

  if cache.cache_sp_offset then

    local cur = readInteger(pawn + cache.cache_sp_offset)

    if not cur or cur &lt; 99 then writeInteger(pawn + cache.cache_sp_offset, 99) end

  end



  -- [B] Skill Tree PC (RemainingSkillPoint on AbilityPointComponent)

  local ap_comp = UE.read_property(pawn, 'AbilityPointComponent')

  if ap_comp and ap_comp &gt; 0 then

    local ap_class = UE.get_class(ap_comp)

    if ap_class and ap_class &gt; 0 then

      if not cache.ap_class or cache.ap_class ~= ap_class then

        cache.ap_class = ap_class

        local prop = UE.find_property(ap_class, 'RemainingSkillPoint')

        cache.rem_sp_offset = prop and prop.offset

      end

      if cache.rem_sp_offset then

        local cur = readInteger(ap_comp + cache.rem_sp_offset)

        if not cur or cur &lt; 99 then writeInteger(ap_comp + cache.rem_sp_offset, 99) end

      end

    end

  end



  -- [C] Skill Tree Attributes (Vitality, Strength, Energy to 99) -&gt; bypasses "Vitalit� requis"

  local ss = UE.read_property(pawn, 'StatusSet')

  if ss and ss &gt; 0 then

    for _, name in ipairs({'Strength', 'Vitality', 'Energy'}) do

      local cur = UE.read_attribute(ss, name)

      if not cur or cur.current &lt; 99.0 then UE.write_attribute(ss, name, 99.0) end

    end

  end

  local buddy = UE.read_property(pawn, 'Buddy')

  if buddy and buddy &gt; 0 then

    local buddy_ss = UE.read_property(buddy, 'StatusSet')

    if buddy_ss and buddy_ss &gt; 0 then

      for _, name in ipairs({'Strength', 'Vitality', 'Energy'}) do

        local cur = UE.read_attribute(buddy_ss, name)

        if not cur or cur.current &lt; 99.0 then UE.write_attribute(buddy_ss, name, 99.0) end

      end

    end

  end



  -- [D] Amber Rate (BattleSet) &amp; Inventory Amber Currency

  local battle_set = UE.read_property(pawn, 'BattleSet')

  if battle_set and battle_set &gt; 0 then

    local cur_amber = UE.read_attribute(battle_set, 'AmberRate')

    if not cur_amber or cur_amber.current &lt; 999.0 then

      UE.write_attribute(battle_set, 'AmberRate', 999.0)

    end

  end



  -- [E] Bauera Atelier / Vehicle Spec Rank &amp; Workbench Buttons

  -- 1. Resolve Workbench Button Properties

  if not cache.btn_checked then

    local btn_cls = UE.find_struct('AibouWorkbenchButtonItem', 'class')

    if btn_cls then

      cache.btn_cls = btn_cls

      local p_unlocked = UE.find_property(btn_cls, 'IsUnlockedVehicleSpec')

      cache.p_unlocked_offset = p_unlocked and p_unlocked.offset

      local p_enable = UE.find_property(btn_cls, 'IsEnable')

      cache.p_enable_offset = p_enable and p_enable.offset

      local p_lock = UE.find_property(btn_cls, 'IsLock') or UE.find_property(btn_cls, 'bIsLocked')

      cache.p_lock_offset = p_lock and p_lock.offset

      local p_req = UE.find_property(btn_cls, 'RequiredVehicleSpecRank')

      cache.p_req_offset = p_req and p_req.offset

      cache.btn_checked = true

    end

  end



  -- 2. Unlock all live Workbench buttons and set vehicle/facility rank properties

  UE.for_each_object(function(obj)

    local cname = UE.get_class_name(obj)

    if not cname then return end



    if cname == 'AibouWorkbenchButtonItem' then

      if cache.p_unlocked_offset then writeBytes(obj + cache.p_unlocked_offset, 1) end

      if cache.p_enable_offset then writeBytes(obj + cache.p_enable_offset, 1) end

      if cache.p_lock_offset then writeBytes(obj + cache.p_lock_offset, 0) end

      if cache.p_req_offset then writeInteger(obj + cache.p_req_offset, 1) end

    elseif cname:find('VehicleSpec') or cname:find('FacilitySpec') or cname:find('FacilityManager') or cname:find('VehicleManager') then

      local obj_cls = UE.get_class(obj)

      if obj_cls then

        local p_rank = UE.find_property(obj_cls, 'Rank') or UE.find_property(obj_cls, 'FacilityRank') or UE.find_property(obj_cls, 'VehicleRank') or UE.find_property(obj_cls, 'SpecRank') or UE.find_property(obj_cls, 'Level')

        if p_rank and p_rank.offset then

          local cur_r = readInteger(obj + p_rank.offset)

          if not cur_r or cur_r &lt; 10 then writeInteger(obj + p_rank.offset, 10) end

        end

      end

    elseif cname:find('InventorySubsystem') then

      local obj_cls = UE.get_class(obj)

      if obj_cls then

        local p_amber = UE.find_property(obj_cls, 'Amber') or UE.find_property(obj_cls, 'AmberItemNum') or UE.find_property(obj_cls, 'AmberNum')

        if p_amber and p_amber.offset then

          local cur_a = readInteger(obj + p_amber.offset)

          if not cur_a or cur_a &lt; 999999 then writeInteger(obj + p_amber.offset, 999999) end

        end

      end

    end

  end)

end



if FREE_UPGRADE_TIMER then

  FREE_UPGRADE_TIMER.destroy()

  FREE_UPGRADE_TIMER = nil

end



FREE_UPGRADE_TIMER = createTimer(nil, false)

FREE_UPGRADE_TIMER.Interval = UPDATE_INTERVAL_MS

FREE_UPGRADE_TIMER.OnTimer = function()

  pcall(update_free_upgrades)

end

FREE_UPGRADE_TIMER.Enabled = true

pcall(update_free_upgrades)



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if FREE_UPGRADE_TIMER then

  FREE_UPGRADE_TIMER.Enabled = false

  FREE_UPGRADE_TIMER.destroy()

  FREE_UPGRADE_TIMER = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27740</ID>
          <Description>"Movement &amp; Exploration"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27703</ID>
              <Description>"Blink / Forward Teleport (Wall Pass - Key V or Ctrl+Space)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then library_record.Active = true end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local pawn = UE.get_local_player_pawn()

if not pawn then error('Player pawn not found') end



local root_prop = UE.find_property(UE.get_class(pawn), 'RootComponent')

local root = root_prop and readPointer(pawn + root_prop.offset)

if not root then error('RootComponent not found') end



local move_comp_prop = UE.find_property(UE.get_class(pawn), 'CharacterMovement')

local move_comp = move_comp_prop and readPointer(pawn + move_comp_prop.offset)



local vel_prop = move_comp and UE.find_property(UE.get_class(move_comp), 'Velocity')

local vel_offset = vel_prop and vel_prop.offset or 0x168



local function do_blink(dist)

  dist = dist or 1500.0 -- 15 meters forward



  local x = readDouble(root + 0x128)

  local y = readDouble(root + 0x128 + 8)

  local z = readDouble(root + 0x128 + 16)

  local yaw = readDouble(root + 0x140 + 8)

  if not x or not y or not z or not yaw then return end



  local rad = math.rad(yaw)

  local nx = x + math.cos(rad) * dist

  local ny = y + math.sin(rad) * dist

  local nz = z + 30.0



  writeDouble(root + 0x128, nx)

  writeDouble(root + 0x128 + 8, ny)

  writeDouble(root + 0x128 + 16, nz)



  if move_comp then

    writeDouble(move_comp + vel_offset, 0.0)

    writeDouble(move_comp + vel_offset + 8, 0.0)

    writeDouble(move_comp + vel_offset + 16, 0.0)

  end



  beep()

end



if BLINK_STATE and BLINK_STATE.timer then

  BLINK_STATE.timer.destroy()

  BLINK_STATE.timer = nil

end



local state = {

  timer = nil,

  was_down_v = false,

  was_down_space = false

}

BLINK_STATE = state



state.timer = createTimer(nil, false)

state.timer.Interval = 20



state.timer.OnTimer = function()

  -- Hotkey 1: V key (0x56)

  local down_v = isKeyPressed(0x56)

  if down_v and not state.was_down_v then

    do_blink(1500.0)

  end

  state.was_down_v = down_v



  -- Hotkey 2: Ctrl + Space (0x11 + 0x20)

  local down_ctrl = isKeyPressed(0x11)

  local down_space = isKeyPressed(0x20)

  local down_combo = down_ctrl and down_space

  if down_combo and not state.was_down_space then

    do_blink(1500.0)

  end

  state.was_down_space = down_combo

end



state.timer.setEnabled(true)



[DISABLE]

{$lua}

if BLINK_STATE and BLINK_STATE.timer then

  BLINK_STATE.timer.destroy()

  BLINK_STATE.timer = nil

end

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27697</ID>
              <Description>"Air Dash &amp; Super Leap Anywhere (Look-Direction Leap - Key G)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Air Dash &amp; Super Leap Anywhere (Propulsion libre vers le regard)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded addresses, zero AOBs.

-- Allows the player to launch/propel themselves through the air in the exact direction of the camera.

-- Default hotkey: [G] (can be changed in the script or held to fly)



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



-- Helper: Retrieve PlayerCameraManager

local function get_player_camera_manager(pawn)

  local level = UE.get_outer(pawn)

  local world = level and UE.get_outer(level)

  local gi = world and UE.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return nil end



  local lp_prop = UE.find_property(UE.get_class(gi), 'LocalPlayers')

  local lp_arr = lp_prop and readPointer(gi + lp_prop.offset)

  local lp = lp_arr and readPointer(lp_arr)

  if not lp or lp == 0 then return nil end



  local pc_prop = UE.find_property(UE.get_class(lp), 'PlayerController')

  local pc = pc_prop and readPointer(lp + pc_prop.offset)

  if not pc or pc == 0 then return nil end



  local pcm_prop = UE.find_property(UE.get_class(pc), 'PlayerCameraManager')

  return pcm_prop and readPointer(pc + pcm_prop.offset)

end



local pawn = UE.get_local_player_pawn()

if not pawn then error('Player character not found. Please enter the game world first.') end



local move_comp_prop = UE.find_property(UE.get_class(pawn), 'CharacterMovement')

local move_comp = move_comp_prop and readPointer(pawn + move_comp_prop.offset)

if not move_comp or move_comp == 0 then error('CharacterMovement not found on player.') end



local vel_prop = UE.find_property(UE.get_class(move_comp), 'Velocity')

local vel_offset = vel_prop and vel_prop.offset or 0x168



local mode_prop = UE.find_property(UE.get_class(move_comp), 'MovementMode')

local mode_offset = mode_prop and mode_prop.offset or 0x201



local pcm = get_player_camera_manager(pawn)

if not pcm or pcm == 0 then error('PlayerCameraManager not found.') end



local cam_base = pcm + 0x13C0

local DEG2RAD = 0.017453292519943295

local DASH_SPEED = 3200.0 -- Leap impulse speed



-- Hotkey: G key (VK_G = 0x47). You can also use VK_X (0x58) or VK_F (0x46)

local HOTKEY = 0x47



SUPER_LEAP_STATE = SUPER_LEAP_STATE or {}

local state = {

  timer = nil,

  was_down = false

}

SUPER_LEAP_STATE = state



state.timer = createTimer(nil, false)

state.timer.Interval = 20 -- 50 FPS hotkey polling



state.timer.OnTimer = function()

  local is_down = isKeyPressed(HOTKEY)



  if is_down and not state.was_down then

    local cx = readDouble(cam_base + 0x10)

    if not cx then return end

    local pitch = readDouble(cam_base + 0x28) * DEG2RAD

    local yaw = readDouble(cam_base + 0x30) * DEG2RAD



    local fx = math.cos(pitch) * math.cos(yaw)

    local fy = math.cos(pitch) * math.sin(yaw)

    local fz = math.sin(pitch)



    -- Apply instantaneous 3D directional velocity

    writeDouble(move_comp + vel_offset + 0x00, fx * DASH_SPEED)

    writeDouble(move_comp + vel_offset + 0x08, fy * DASH_SPEED)

    writeDouble(move_comp + vel_offset + 0x10, fz * DASH_SPEED)



    -- Set MovementMode to Falling (3) so character is airborne immediately

    writeBytes(move_comp + mode_offset, {3})

  end



  state.was_down = is_down

end



state.timer.Enabled = true



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if SUPER_LEAP_STATE then

  if SUPER_LEAP_STATE.timer then

    pcall(function()

      SUPER_LEAP_STATE.timer.Enabled = false

      SUPER_LEAP_STATE.timer.destroy()

    end)

    SUPER_LEAP_STATE.timer = nil

  end

  SUPER_LEAP_STATE = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27696</ID>
              <Description>"Infinite Grapple Range &amp; 360 Hookshot (Full Aim Freedom)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Infinite Grapple Range &amp; 360 Hookshot (Bondir - Port�e infinie &amp; Vis�e totale)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded addresses, zero AOBs.

-- Unlocks infinite detection range (10 km), 360-degree detection, zero cooldown, and fluid travel speed.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local pawn = UE.get_local_player_pawn()

if not pawn then error('Player character not found. Please enter the game world first.') end



local hookshot_prop = UE.find_property(UE.get_class(pawn), 'HookshotComponent')

local hookshot = hookshot_prop and readPointer(pawn + hookshot_prop.offset)

if not hookshot or hookshot == 0 then error('HookshotComponent not found on player.') end



-- State tracking for clean restore

INFINITE_GRAPPLE_BACKUP = INFINITE_GRAPPLE_BACKUP or {}

local state = {

  param_obj = nil,

  move_param_obj = nil,

  orig_hookshot_params = {},

  orig_move_params = {}

}

INFINITE_GRAPPLE_BACKUP = state



-- Patch DA_Player_Hookshot for infinite range and 360-degree detection

local param_prop = UE.find_property(UE.get_class(hookshot), 'HookshotParam')

local param = param_prop and readPointer(hookshot + param_prop.offset)

if param and param &gt; 0 then

  state.param_obj = param

  state.orig_hookshot_params = {

    min_dist = readFloat(param + 0x30),

    max_dist = readFloat(param + 0x34),

    h_min_ang = readFloat(param + 0x38),

    h_max_ang = readFloat(param + 0x3C),

    v_min_ang = readFloat(param + 0x40),

    v_max_ang = readFloat(param + 0x44),

    view_dist = readFloat(param + 0x48),

    jump_min_dist = readFloat(param + 0x54),

    jump_max_dist = readFloat(param + 0x58),

    jump_view_dist = readFloat(param + 0x5C),

    cannot_pass_time = readFloat(param + 0x78),

    used_interval_time = readFloat(param + 0x7C),

    max_angle = readFloat(param + 0x98)

  }



  writeFloat(param + 0x30, 0.0)          -- CanHookshotDistanceMin = 0 (point-blank allowed)

  writeFloat(param + 0x34, 1000000.0)    -- CanHookshotDistanceMax = 1,000,000 (10 km)

  writeFloat(param + 0x38, -180.0)       -- CanJumpHookshotHorizontalAngleMin = -180

  writeFloat(param + 0x3C, 180.0)        -- CanJumpHookshotHorizontalAngleMax = 180

  writeFloat(param + 0x40, -90.0)        -- CanJumpHookshotVarticalAngleMin = -90

  writeFloat(param + 0x44, 180.0)        -- CanJumpHookshotVarticalAngleMax = 180

  writeFloat(param + 0x48, 1000000.0)    -- ViewIconDistance = 1,000,000

  writeFloat(param + 0x54, 0.0)          -- CanJumpHookshotDistanceMin = 0

  writeFloat(param + 0x58, 1000000.0)    -- CanJumpHookshotDistanceMax = 1,000,000

  writeFloat(param + 0x5C, 1000000.0)    -- ViewJumpHookshotIconDistance = 1,000,000

  writeFloat(param + 0x78, 0.0)          -- HideCurrentAnchorPointCannotPassTime = 0

  writeFloat(param + 0x7C, 0.0)          -- UsedAnchorPointIntervalTime = 0 (zero cooldown)

  writeFloat(param + 0x98, 360.0)        -- CanHookshotXYMaxAngle = 360 (full freedom)

end



-- Patch DA_Player_HookshotMovement for fast, fluid travel speed

local move_param_prop = UE.find_property(UE.get_class(hookshot), 'HookshotMovementParam')

local move_param = move_param_prop and readPointer(hookshot + move_param_prop.offset)

if move_param and move_param &gt; 0 then

  state.move_param_obj = move_param

  state.orig_move_params = {

    rot_speed = readFloat(move_param + 0x30),

    time_min = readFloat(move_param + 0x60),

    time_max = readFloat(move_param + 0x68)

  }



  writeFloat(move_param + 0x30, 720.0)   -- Fast turn to target

  writeFloat(move_param + 0x60, 0.5)     -- Fluid minimum leap duration

  writeFloat(move_param + 0x68, 0.8)     -- Fluid maximum leap duration

end



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if INFINITE_GRAPPLE_BACKUP then

  local state = INFINITE_GRAPPLE_BACKUP



  -- Restore DA_Player_Hookshot

  if state.param_obj and state.orig_hookshot_params and state.orig_hookshot_params.min_dist then

    local p = state.param_obj

    local o = state.orig_hookshot_params

    writeFloat(p + 0x30, o.min_dist)

    writeFloat(p + 0x34, o.max_dist)

    writeFloat(p + 0x38, o.h_min_ang)

    writeFloat(p + 0x3C, o.h_max_ang)

    writeFloat(p + 0x40, o.v_min_ang)

    writeFloat(p + 0x44, o.v_max_ang)

    writeFloat(p + 0x48, o.view_dist)

    writeFloat(p + 0x54, o.jump_min_dist)

    writeFloat(p + 0x58, o.jump_max_dist)

    writeFloat(p + 0x5C, o.jump_view_dist)

    writeFloat(p + 0x78, o.cannot_pass_time)

    writeFloat(p + 0x7C, o.used_interval_time)

    writeFloat(p + 0x98, o.max_angle)

  end



  -- Restore DA_Player_HookshotMovement

  if state.move_param_obj and state.orig_move_params and state.orig_move_params.rot_speed then

    local m = state.move_param_obj

    local o = state.orig_move_params

    writeFloat(m + 0x30, o.rot_speed)

    writeFloat(m + 0x60, o.time_min)

    writeFloat(m + 0x68, o.time_max)

  end



  INFINITE_GRAPPLE_BACKUP = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27702</ID>
              <Description>"Disable Invisible Barriers &amp; Story Restrictions"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then library_record.Active = true end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local cached_triggers = {}



local function disable_restrictions()

  local c = UE.find_struct('AibouFieldVolumePlayerRestrictionTrigger')

  if not c then return end



  UE.for_each_object(function(obj)

    if UE.get_class(obj) == c then

      local count = readInteger(obj + 0xC8 + 8) or 0

      if count &gt; 0 then

        if not cached_triggers[obj] then

          cached_triggers[obj] = count

        end

        -- Zero restriction count so trigger logic never fires

        writeInteger(obj + 0xC8 + 8, 0)



        -- Disable physical collision on the volume brush

        local outer = UE.get_outer(obj)

        if outer and outer &gt; 0 then

          local root = UE.read_property(outer, 'RootComponent')

          if root and root &gt; 0 then

            writeByte(root + 0x3D0, 0) -- ECollisionEnabled::NoCollision

          end

        end

      end

    end

  end)

end



-- Run immediately

disable_restrictions()



-- Periodic check for newly streamed volumes (every 2.5 seconds, ultra-low CPU)

if barrier_timer then

  barrier_timer.destroy()

  barrier_timer = nil

end



barrier_timer = createTimer(nil, false)

barrier_timer.Interval = 2500

barrier_timer.OnTimer = function()

  disable_restrictions()

end

barrier_timer.setEnabled(true)



[DISABLE]

{$lua}

if barrier_timer then

  barrier_timer.destroy()

  barrier_timer = nil

end



-- Restore cached triggers

if cached_triggers then

  for obj, orig_count in pairs(cached_triggers) do

    if UE_REFLECTION and UE_REFLECTION.is_valid_pointer(obj) then

      writeInteger(obj + 0xC8 + 8, orig_count)

      local outer = UE_REFLECTION.get_outer(obj)

      if outer and outer &gt; 0 then

        local root = UE_REFLECTION.read_property(outer, 'RootComponent')

        if root and root &gt; 0 then

          writeByte(root + 0x3D0, 3) -- QueryAndPhysics

        end

      end

    end

  end

  cached_triggers = {}

end

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27741</ID>
              <Description>"Unlock All Camps, Shrines &amp; Reveal Full Map (Fast Travel Everywhere)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

-- Unlock All Camps, Shrines &amp; Reveal Full Map (Fast Travel Everywhere)
-- 100% Pure Lua UE5 Reflection script. Zero Assembly, zero hardcoded addresses.
-- 1. Unlocks all 152 Camps &amp; 15 Shrines / Temples across all 19 zones for instant fast travel.
-- 2. Removes map fog of war, reveals all map markers, landmarks, and points of interest.
-- 3. Sets infinite discovery and icon display distances (999,999,999 units).
-- 4. Dynamically patches IsFoundLocation (returns true) so the entire world is marked discovered.
-- 5. Updates UnlockedMapFlagList, CampArray, and ShrineArray in active save data.
-- Fully resilient across zone transitions, cutscenes, camp returns, and game updates.

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

MAP_UNLOCK_PATCHES = MAP_UNLOCK_PATCHES or {
  is_found_addr = nil,
  orig_is_found_bytes = nil,
  dt_modified = false
}

local map_cache = {
  loc_sub = nil,
  save_sub = nil,
  cur_data = nil,
  dt_map = nil
}

local function resolve_map_components()
  if map_cache.loc_sub and UE.is_valid_pointer(map_cache.loc_sub) and
     map_cache.save_sub and UE.is_valid_pointer(map_cache.save_sub) and
     map_cache.dt_map and UE.is_valid_pointer(map_cache.dt_map) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 then
        local cname = UE.get_class_name(val)
        if cname == 'AibouCurrentLocationSubsystem' then
          map_cache.loc_sub = val
        elseif cname == 'AibouSaveDataSubsystem' then
          map_cache.save_sub = val
        end
      end
    end
  end

  if map_cache.loc_sub then
    local ref_dts = readPointer(map_cache.loc_sub + 0xB48)
    if ref_dts and ref_dts &gt; 0 then
      map_cache.dt_map = readPointer(ref_dts)
    end
  end

  if map_cache.save_sub then
    map_cache.cur_data = map_cache.save_sub + 0x50 + 0x50
  end

  return map_cache.loc_sub ~= nil and map_cache.save_sub ~= nil
end

local function apply_native_map_patch()
  if MAP_UNLOCK_PATCHES.is_found_addr then
    -- Patch: B0 01 C3 90 90 (mov al, 1 ; ret ; nop ; nop)
    writeBytes(MAP_UNLOCK_PATCHES.is_found_addr, {0xB0, 0x01, 0xC3, 0x90, 0x90})
    return
  end

  if not map_cache.loc_sub then return end
  local cls = UE.get_class(map_cache.loc_sub)

  local fn_is_found = nil
  UE.for_each_object(function(obj)
    if UE.get_outer(obj) == cls and UE.get_object_name(obj) == 'IsFoundLocation' then
      fn_is_found = obj
      return true
    end
  end)

  if fn_is_found then
    local exec_addr = readPointer(fn_is_found + 0xD8)
    if exec_addr and exec_addr &gt; 0x10000000000 then
      local bytes = readBytes(exec_addr, 200, true)
      if bytes then
        for i = 1, #bytes - 5 do
          if bytes[i] == 0xE8 then
            local rel = bytes[i+1] | (bytes[i+2] &lt;&lt; 8) | (bytes[i+3] &lt;&lt; 16) | (bytes[i+4] &lt;&lt; 24)
            if rel &gt; 0x7FFFFFFF then rel = rel - 0x100000000 end
            local dest = (exec_addr + i - 1 + 5) + rel
            MAP_UNLOCK_PATCHES.is_found_addr = dest
            MAP_UNLOCK_PATCHES.orig_is_found_bytes = readBytes(dest, 5, true)
            writeBytes(dest, {0xB0, 0x01, 0xC3, 0x90, 0x90})
            break
          end
        end
      end
    end
  end
end

local function unlock_datatable_and_savedata()
  if not resolve_map_components() then return end

  -- 1. Apply native IsFoundLocation patch
  apply_native_map_patch()

  -- 2. Extend subsystem discovery and icon display distances
  local loc_sub = map_cache.loc_sub
  writeFloat(loc_sub + 0x1EC, 999999999.0) -- DefaultDisplayLocationIconDistance
  writeFloat(loc_sub + 0x1F0, 999999999.0) -- DefaultFoundLocationDistance
  writeFloat(loc_sub + 0x228, 999999999.0) -- ForcedLocationIconDisplayTimeMax

  -- 3. Update DT_MapMenuData rows (fast travel &amp; discovery)
  local dt = map_cache.dt_map
  local camps_list = {}
  local shrines_list = {}
  local all_flags = {}
  local flag_set = {}

  if dt and dt &gt; 0 then
    local row_map = dt + 0x30
    local dt_data = readPointer(row_map)
    local dt_count = readInteger(row_map + 8)

    if dt_data and dt_count and dt_count &gt; 0 then
      for i = 0, dt_count - 1 do
        local off = i * 24
        local row = readPointer(dt_data + off + 8)
        if row and row &gt; 0x10000000000 and row &lt; 0x7FFFFFFFFFFF then
          writeByte(row + 0x28, 1)   -- CanFastTravel
          writeByte(row + 0x6C, 1)   -- IsDefaultFoundLocation
          writeByte(row + 0x102, 0)  -- IsDisableLocationIcon
          writeByte(row + 0x103, 0)  -- IsDisableLocationIconAndMapIcon
          writeInteger(row + 0x64, 0) -- ForegroundFogID (clear fog)
          writeFloat(row + 0x108, 999999999.0) -- DisplayLocationIconDistance
          writeFloat(row + 0x110, 999999999.0) -- FoundLocationDistance

          local icon_id = readByte(row + 0x8)
          local gid = readInteger(row + 0x94)
          if gid and gid &gt; 0 then
            if icon_id == 13 then
              table.insert(camps_list, gid)
            elseif icon_id == 38 then
              table.insert(shrines_list, gid)
            end
          end

          local f1 = readInteger(row + 0x20)
          local f2 = readInteger(row + 0x24)
          if f1 and f1 ~= 0 then
            local key = tostring(f1) .. '_' .. tostring(f2)
            if not flag_set[key] then
              flag_set[key] = true
              table.insert(all_flags, {f1 = f1, f2 = f2})
            end
          end
        end
      end
    end
  end

  -- 4. Update Save Data: UnlockedMapFlagList
  local cur = map_cache.cur_data
  if cur and cur &gt; 0 and #all_flags &gt; 0 then
    local map_save = cur + 0x2250
    local cur_num = readInteger(map_save + 8)
    if not cur_num or cur_num &lt; #all_flags then
      local new_max = #all_flags + 128
      local new_buf = allocateMemory(new_max * 8)
      for idx, flag in ipairs(all_flags) do
        writeInteger(new_buf + (idx - 1) * 8, flag.f1)
        writeInteger(new_buf + (idx - 1) * 8 + 4, flag.f2)
      end
      writePointer(map_save, new_buf)
      writeInteger(map_save + 8, #all_flags)
      writeInteger(map_save + 12, new_max)
    end

    -- 5. Update CampArray &amp; ShrineArray in RecordSaveData
    local camp_arr = cur + 0x25D0
    if #camps_list &gt; 0 then
      local c_buf = allocateMemory(#camps_list * 8 + 64)
      for idx, gid in ipairs(camps_list) do
        writeInteger(c_buf + (idx - 1) * 8, gid)
        writeInteger(c_buf + (idx - 1) * 8 + 4, 0)
      end
      writePointer(camp_arr, c_buf)
      writeInteger(camp_arr + 8, #camps_list)
      writeInteger(camp_arr + 12, #camps_list + 8)
    end

    local shrine_arr = cur + 0x2588
    if #shrines_list &gt; 0 then
      local s_buf = allocateMemory(#shrines_list * 8 + 64)
      for idx, gid in ipairs(shrines_list) do
        writeInteger(s_buf + (idx - 1) * 8, gid)
        writeInteger(s_buf + (idx - 1) * 8 + 4, 0)
      end
      writePointer(shrine_arr, s_buf)
      writeInteger(shrine_arr + 8, #shrines_list)
      writeInteger(shrine_arr + 12, #shrines_list + 8)
    end
  end
end

if MAP_UNLOCK_TIMER then
  MAP_UNLOCK_TIMER.destroy()
  MAP_UNLOCK_TIMER = nil
end

MAP_UNLOCK_TIMER = createTimer(nil, false)
MAP_UNLOCK_TIMER.Interval = 500
MAP_UNLOCK_TIMER.OnTimer = function()
  pcall(unlock_datatable_and_savedata)
end
MAP_UNLOCK_TIMER.Enabled = true
pcall(unlock_datatable_and_savedata)

{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end

if MAP_UNLOCK_TIMER then
  MAP_UNLOCK_TIMER.Enabled = false
  MAP_UNLOCK_TIMER.destroy()
  MAP_UNLOCK_TIMER = nil
end

if MAP_UNLOCK_PATCHES and MAP_UNLOCK_PATCHES.is_found_addr and MAP_UNLOCK_PATCHES.orig_is_found_bytes then
  writeBytes(MAP_UNLOCK_PATCHES.is_found_addr, MAP_UNLOCK_PATCHES.orig_is_found_bytes)
end

local UE = UE_REFLECTION
if UE then
  local pawn = UE.get_local_player_pawn()
  local level = pawn and UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if gi and gi &gt; 0 then
    local data_ptr = readPointer(gi + 0x108)
    local num = readInteger(gi + 0x108 + 8)
    if data_ptr and num and num &gt; 0 then
      for i = 0, num - 1 do
        local val = readPointer(data_ptr + i * 24 + 8)
        if val and val &gt; 0 and UE.get_class_name(val) == 'AibouCurrentLocationSubsystem' then
          writeFloat(val + 0x1EC, 6500.0)
          writeFloat(val + 0x1F0, 2000.0)
          writeFloat(val + 0x228, 120.0)
          break
        end
      end
    end
  end
end
{$asm}
</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27750</ID>
          <Description>"Bauera Vehicle &amp; Camp Research"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27706</ID>
              <Description>"Max Bauera Vehicle Specs (Power, Calculation, Knowledge)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local bauera_cache = {

  save_sub = nil,

  fs_offset = nil,

  current_offset = nil

}



local function resolve_state()

  if bauera_cache.save_sub and UE.is_valid_pointer(bauera_cache.save_sub) then

    return true

  end



  local pawn = UE.get_local_player_pawn()

  if not pawn then return false end



  local level = UE.get_outer(pawn)

  local world = level and UE.get_outer(level)

  local gi = world and UE.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return false end



  local data_ptr = readPointer(gi + 0x108)

  local num = readInteger(gi + 0x108 + 8)

  if data_ptr and num and num &gt; 0 then

    for i = 0, num - 1 do

      local val = readPointer(data_ptr + i * 24 + 8)

      if val and val &gt; 0 then

        local cname = UE.get_class_name(val)

        if cname == 'AibouSaveDataSubsystem' then

          bauera_cache.save_sub = val

          break

        end

      end

    end

  end



  if not bauera_cache.current_offset then

    local struct_normal = UE.find_struct('AibouSaveData_Normal')

    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')

    bauera_cache.current_offset = prop_norm and prop_norm.offset or 0x50

  end



  if not bauera_cache.fs_offset then

    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')

    local prop_fs = struct_each_day and UE.find_property(struct_each_day, 'FriendshipSaveData')

    bauera_cache.fs_offset = prop_fs and prop_fs.offset or 0x1EC0

  end



  return bauera_cache.save_sub ~= nil

end



local function apply_max_bauera()

  if not resolve_state() then return false end



  local save_sub = bauera_cache.save_sub

  local fs_addr = save_sub + 0x50 + bauera_cache.current_offset + bauera_cache.fs_offset

  local spec_arr_data = readPointer(fs_addr + 0x28)

  local spec_arr_count = readInteger(fs_addr + 0x28 + 8)



  if spec_arr_data and spec_arr_count and spec_arr_count &gt;= 3 then

    for i = 0, spec_arr_count - 1 do

      local elem = spec_arr_data + i * 8

      -- +0x0: Value (IntProperty)

      -- +0x4: Rank (EnumProperty / EAibouVehicleSpecRank)

      writeInteger(elem, 9999)      -- Value

      writeInteger(elem + 4, 6)     -- Rank 10 (exceeds requirement of 6)     -- Max Rank (Rank 3 / Max)

    end

  end



  return true

end



-- Apply immediately

apply_max_bauera()



-- Run periodic timer every 500ms (zero CPU overhead, pure pointer write)

if BAUERA_MAX_TIMER then

  BAUERA_MAX_TIMER.destroy()

  BAUERA_MAX_TIMER = nil

end



BAUERA_MAX_TIMER = createTimer(nil, false)

BAUERA_MAX_TIMER.Interval = 500

BAUERA_MAX_TIMER.OnTimer = function()

  apply_max_bauera()

end

BAUERA_MAX_TIMER.setEnabled(true)



[DISABLE]

{$lua}

if BAUERA_MAX_TIMER then

  BAUERA_MAX_TIMER.destroy()

  BAUERA_MAX_TIMER = nil

end
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27751</ID>
              <Description>"Unlock All Incubator Slots (Chicken Coop - 6 Nests)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local function unlock_incubator()
  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  local save_sub = nil
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        save_sub = val
        break
      end
    end
  end
  if not save_sub then return false end

  local struct_normal = UE.find_struct('AibouSaveData_Normal')
  local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
  local current_offset = prop_norm and prop_norm.offset or 0x50

  local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
  local prop_coop = struct_each_day and UE.find_property(struct_each_day, 'ChickenCoopSaveData')
  local coop_offset = prop_coop and prop_coop.offset or 0x19E8

  local coop_addr = save_sub + 0x50 + current_offset + coop_offset
  -- +0x28 is ArrayNum for nest slots (expand to 4)
  local cur_slots = readInteger(coop_addr + 0x28)
  if cur_slots and cur_slots &lt; 4 then
    writeInteger(coop_addr + 0x28, 4)
  end

  -- Clean up uninitialized slot memory if garbage
  local nests_ptr = readPointer(coop_addr + 0x20)
  if nests_ptr then
    for i = 0, 3 do
      local slot = nests_ptr + i * 12
      local state = readBytes(slot, 1)
      if state ~= 0 and state ~= 1 and state ~= 2 then
        for b = 0, 11 do writeBytes(slot + b, 0) end
      end
    end
  end
  return true
end

unlock_incubator()

[DISABLE]
{$lua}
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27699</ID>
              <Description>"Instant Incense &amp; Fellow Research (100% Immediate Progression)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



-- State and cache for zero CPU overhead

local state = {

  save_sub = nil,

  friend_sub = nil,

  fellow_offset = nil,

  current_offset = nil

}



local function resolve_subsystems()

  local pawn = UE.get_local_player_pawn()

  if not pawn then return nil end



  local level = UE.get_outer(pawn)

  local world = level and UE.get_outer(level)

  local gi = world and UE.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return nil end



  local data_ptr = readPointer(gi + 0x108)

  local num = readInteger(gi + 0x108 + 8)

  if data_ptr and num and num &gt; 0 then

    for i = 0, num - 1 do

      local val = readPointer(data_ptr + i * 24 + 8)

      if val and val &gt; 0 then

        local cname = UE.get_class_name(val)

        if cname == 'AibouSaveDataSubsystem' then

          state.save_sub = val

        elseif cname == 'AibouFriendshipSubsystem' then

          state.friend_sub = val

        end

      end

    end

  end



  if not state.current_offset then

    local struct_normal = UE.find_struct('AibouSaveData_Normal')

    local prop = struct_normal and UE.find_property(struct_normal, 'CurrentData')

    state.current_offset = prop and prop.offset or 0x50

  end



  if not state.fellow_offset then

    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')

    local prop = struct_each_day and UE.find_property(struct_each_day, 'FellowResearchSaveData')

    state.fellow_offset = prop and prop.offset or 0x2B20

  end



  return state.save_sub

end



-- Fast tick callback (every 300ms)

local function on_tick()

  local save_sub = state.save_sub

  if not save_sub or not UE.is_valid_pointer(save_sub) then

    save_sub = resolve_subsystems()

    if not save_sub then return end

  end



  -- Keep FakeResearchProgressBorder at 0.01 for instant engine checks

  if state.friend_sub and UE.is_valid_pointer(state.friend_sub) then

    writeFloat(state.friend_sub + 0x100, 0.01)

  end



  local fellow_research = save_sub + 0x50 + state.current_offset + state.fellow_offset

  local char_map_data = readPointer(fellow_research)

  local char_map_count = readInteger(fellow_research + 8)

  if not char_map_data or not char_map_count or char_map_count &lt;= 0 then return end



  for c_idx = 0, math.min(char_map_count - 1, 3) do

    local char_elem = char_map_data + c_idx * 0x70

    local task_fname = readInteger(char_elem + 0x08)

    local cur_progress = readFloat(char_elem + 0x14)



    -- If a research task is underway and not yet at 100%

    if task_fname and task_fname ~= 0 and cur_progress and cur_progress &lt; 1.0 then

      writeFloat(char_elem + 0x14, 1.0)



      -- Complete matching task in category lists

      local cat_map_data = readPointer(char_elem + 0x18)

      local cat_map_count = readInteger(char_elem + 0x20)

      if cat_map_data and cat_map_count and cat_map_count &gt; 0 then

        for cat_idx = 0, cat_map_count - 1 do

          local cat_elem = cat_map_data + cat_idx * 0x70

          local tasks_data = readPointer(cat_elem + 8)

          local tasks_count = readInteger(cat_elem + 0x10)

          if tasks_data and tasks_count and tasks_count &gt; 0 then

            for t_idx = 0, tasks_count - 1 do

              local t_addr = tasks_data + t_idx * 28

              if readInteger(t_addr) == task_fname then

                local v_addr = t_addr + 8

                writeByte(v_addr, 1)        -- bUnlocked = 1

                writeByte(v_addr + 1, 0)    -- bPaused = 0

                writeByte(v_addr + 2, 1)    -- bCompleted = 1

                writeInteger(v_addr + 4, 100) -- Progress = 100

                break

              end

            end

          end

        end

      end

    end

  end

end



-- Clean previous timer if exists

if instant_research_timer then

  instant_research_timer.destroy()

  instant_research_timer = nil

end



resolve_subsystems()

instant_research_timer = createTimer(nil, false)

instant_research_timer.Interval = 300

instant_research_timer.OnTimer = on_tick

instant_research_timer.setEnabled(true)



[DISABLE]

{$lua}

if instant_research_timer then

  instant_research_timer.destroy()

  instant_research_timer = nil

end

</AssemblerScript>
              <CheatEntries>
                <CheatEntry>
                  <ID>27700</ID>
                  <Description>"&gt;&gt;&gt; Instant Complete ALL Incenses (Unlock All 7 Incense Skills) &lt;&lt;&lt;"</Description>
                  <VariableType>Auto Assembler Script</VariableType>
                  <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then library_record.Active = true end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local function complete_incenses()

  local pawn = UE.get_local_player_pawn()

  if not pawn then return false, 'Player pawn not found' end



  local level = UE.get_outer(pawn)

  local world = level and UE.get_outer(level)

  local gi = world and UE.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return false, 'GameInstance not found' end



  local data_ptr = readPointer(gi + 0x108)

  local num = readInteger(gi + 0x108 + 8)

  local save_sub = nil

  for i = 0, num - 1 do

    local val = readPointer(data_ptr + i * 24 + 8)

    if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then

      save_sub = val

      break

    end

  end

  if not save_sub then return false, 'AibouSaveDataSubsystem not found' end



  local struct_normal = UE.find_struct('AibouSaveData_Normal')

  local struct_each_day = UE.find_struct('AibouSaveData_EachDay')

  local current_offset = UE.find_property(struct_normal, 'CurrentData').offset

  local fellow_offset = UE.find_property(struct_each_day, 'FellowResearchSaveData').offset



  local fellow_research = save_sub + 0x50 + current_offset + fellow_offset

  local char_map_data = readPointer(fellow_research)

  local char_map_count = readInteger(fellow_research + 8)

  if not char_map_data or not char_map_count or char_map_count &lt;= 0 then return false, 'CharacterData is empty' end



  local np = nil

  local i = 1

  while true do

    local k, v = debug.getupvalue(UE.ensure_ready, i)

    if not k then break end

    if k == 'globals' then np = v.name_pool break end

    i = i + 1

  end



  local function read_fname(pool, index)

    if not pool or not index then return nil end

    local block = readPointer(pool + 0x10 + (index &gt;&gt; 16) * 8)

    if not block then return nil end

    local entry = block + (index &amp; 0xFFFF) * 2

    local header = readSmallInteger(entry)

    if not header then return nil end

    local length = (header &amp; 0xFFFF) &gt;&gt; 6

    if length &lt;= 0 or length &gt; 1024 then return nil end

    if (header &amp; 1) ~= 0 then return nil end

    return readString(entry + 2, length)

  end



  local total = 0

  for c_idx = 0, char_map_count - 1 do

    local char_elem = char_map_data + c_idx * 0x70

    writeFloat(char_elem + 0x14, 1.0)



    local cat_map_data = readPointer(char_elem + 0x18)

    local cat_map_count = readInteger(char_elem + 0x20)

    if cat_map_data and cat_map_count and cat_map_count &gt; 0 then

      for cat_idx = 0, cat_map_count - 1 do

        local cat_elem = cat_map_data + cat_idx * 0x70

        local tasks_data = readPointer(cat_elem + 8)

        local tasks_count = readInteger(cat_elem + 0x10)

        if tasks_data and tasks_count and tasks_count &gt; 0 then

          for t_idx = 0, tasks_count - 1 do

            local task_addr = tasks_data + t_idx * 28

            local fn_idx = readInteger(task_addr)

            local name = read_fname(np, fn_idx) or ''

            if name:find('Incense') then

              local val_addr = task_addr + 8

              writeByte(val_addr, 1)        -- bUnlocked = 1

              writeByte(val_addr + 1, 0)    -- bPaused = 0

              writeByte(val_addr + 2, 1)    -- bCompleted = 1

              writeInteger(val_addr + 4, 100) -- Progress = 100

              total = total + 1

            end

          end

        end

      end

    end

  end



  return true, total

end



local ok, count = complete_incenses()

local rec = getAddressList().getMemoryRecordByID(27700)

if rec then rec.Active = false end

if ok then

  print(string.format('[Instant Research] Successfully completed %d incense research tasks!', count or 0))

else

  beep()

end



[DISABLE]

</AssemblerScript>
                </CheatEntry>
                <CheatEntry>
                  <ID>27701</ID>
                  <Description>"&gt;&gt;&gt; Instant Complete ALL Fellow Research (All Incenses, Skills &amp; Items) &lt;&lt;&lt;"</Description>
                  <VariableType>Auto Assembler Script</VariableType>
                  <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then library_record.Active = true end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



local function complete_all()

  local pawn = UE.get_local_player_pawn()

  if not pawn then return false, 'Player pawn not found' end



  local level = UE.get_outer(pawn)

  local world = level and UE.get_outer(level)

  local gi = world and UE.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return false, 'GameInstance not found' end



  local data_ptr = readPointer(gi + 0x108)

  local num = readInteger(gi + 0x108 + 8)

  local save_sub = nil

  for i = 0, num - 1 do

    local val = readPointer(data_ptr + i * 24 + 8)

    if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then

      save_sub = val

      break

    end

  end

  if not save_sub then return false, 'AibouSaveDataSubsystem not found' end



  local struct_normal = UE.find_struct('AibouSaveData_Normal')

  local struct_each_day = UE.find_struct('AibouSaveData_EachDay')

  local current_offset = UE.find_property(struct_normal, 'CurrentData').offset

  local fellow_offset = UE.find_property(struct_each_day, 'FellowResearchSaveData').offset



  local fellow_research = save_sub + 0x50 + current_offset + fellow_offset

  local char_map_data = readPointer(fellow_research)

  local char_map_count = readInteger(fellow_research + 8)

  if not char_map_data or not char_map_count or char_map_count &lt;= 0 then return false, 'CharacterData is empty' end



  local total = 0

  for c_idx = 0, char_map_count - 1 do

    local char_elem = char_map_data + c_idx * 0x70

    writeFloat(char_elem + 0x14, 1.0)



    local cat_map_data = readPointer(char_elem + 0x18)

    local cat_map_count = readInteger(char_elem + 0x20)

    if cat_map_data and cat_map_count and cat_map_count &gt; 0 then

      for cat_idx = 0, cat_map_count - 1 do

        local cat_elem = cat_map_data + cat_idx * 0x70

        local tasks_data = readPointer(cat_elem + 8)

        local tasks_count = readInteger(cat_elem + 0x10)

        if tasks_data and tasks_count and tasks_count &gt; 0 then

          for t_idx = 0, tasks_count - 1 do

            local task_addr = tasks_data + t_idx * 28

            local val_addr = task_addr + 8

            writeByte(val_addr, 1)        -- bUnlocked = 1

            writeByte(val_addr + 1, 0)    -- bPaused = 0

            writeByte(val_addr + 2, 1)    -- bCompleted = 1

            writeInteger(val_addr + 4, 100) -- Progress = 100

            total = total + 1

          end

        end

      end

    end

  end



  return true, total

end



local ok, count = complete_all()

local rec = getAddressList().getMemoryRecordByID(27701)

if rec then rec.Active = false end

if ok then

  print(string.format('[Instant Research] Successfully completed ALL %d fellow research tasks!', count or 0))

else

  beep()

end



[DISABLE]

</AssemblerScript>
                </CheatEntry>
              </CheatEntries>
            </CheatEntry>
            <CheatEntry>
              <ID>27752</ID>
              <Description>"Instant Egg Incubation (100% Progress Bar)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local coop_cache = {
  save_sub = nil,
  current_offset = nil,
  coop_offset = nil,
  inv_offset = nil,
  inv_sub = nil
}

local function resolve_coop()
  if coop_cache.save_sub and UE.is_valid_pointer(coop_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 then
        local cname = UE.get_class_name(val)
        if cname == 'AibouSaveDataSubsystem' then
          coop_cache.save_sub = val
        elseif cname == 'AibouInventorySubsystem' then
          coop_cache.inv_sub = val
        end
      end
    end
  end

  if not coop_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    coop_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not coop_cache.coop_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_coop = struct_each_day and UE.find_property(struct_each_day, 'ChickenCoopSaveData')
    coop_cache.coop_offset = prop_coop and prop_coop.offset or 0x19E8
  end

  if not coop_cache.inv_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_inv = struct_each_day and UE.find_property(struct_each_day, 'InventorySaveData')
    coop_cache.inv_offset = prop_inv and prop_inv.offset or 0x640
  end

  return coop_cache.save_sub ~= nil
end

local function apply_incubation_progress()
  if not resolve_coop() then return false end

  local save_sub = coop_cache.save_sub
  local coop_addr = save_sub + 0x50 + coop_cache.current_offset + coop_cache.coop_offset

  local nests_ptr = readPointer(coop_addr + 0x20)
  local nests_count = readInteger(coop_addr + 0x28)
  if nests_ptr and nests_count and nests_count &gt; 0 then
    for i = 0, nests_count - 1 do
      local slot = nests_ptr + i * 12
      local state = readBytes(slot, 1)
      if state == 1 then -- Egg
        writeInteger(slot + 4, 0) -- 100% Progress (RemainingTime = 0)
      end
    end
    writeInteger(coop_addr + 0x30, 100) -- Max food
  end

  -- Ensure Fertilized Eggs (num_idx=183) in active inventory
  local inv_addr = save_sub + 0x50 + coop_cache.current_offset + coop_cache.inv_offset
  local map_ptr = readPointer(inv_addr)
  local map_max = readInteger(inv_addr + 0xC)
  if map_ptr and map_max and map_max &gt; 0 then
    for i = 0, map_max - 1 do
      local elem = map_ptr + i * 24
      if readInteger(elem) == 148280 and readInteger(elem + 4) == 183 then
        if readInteger(elem + 8) &lt; 99 then
          writeInteger(elem + 8, 99)
        end
        break
      end
    end
  end

  return true
end

apply_incubation_progress()

if INCUBATION_PROGRESS_TIMER then
  INCUBATION_PROGRESS_TIMER.destroy()
  INCUBATION_PROGRESS_TIMER = nil
end

INCUBATION_PROGRESS_TIMER = createTimer(nil, false)
INCUBATION_PROGRESS_TIMER.Interval = 500
INCUBATION_PROGRESS_TIMER.OnTimer = function()
  apply_incubation_progress()
end
INCUBATION_PROGRESS_TIMER.setEnabled(true)

[DISABLE]
{$lua}
if INCUBATION_PROGRESS_TIMER then
  INCUBATION_PROGRESS_TIMER.destroy()
  INCUBATION_PROGRESS_TIMER = nil
end
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27753</ID>
              <Description>"Instant Egg Hatching (Transform Eggs into Adult Chickens)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local coop_cache = {
  save_sub = nil,
  current_offset = nil,
  coop_offset = nil,
  coop_actor = nil,
  reflect_fn = 0x23680632A80,
  pe_fn = 0x7FF6075F4D60
}

local function resolve_coop()
  if coop_cache.save_sub and UE.is_valid_pointer(coop_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        coop_cache.save_sub = val
        break
      end
    end
  end

  if not coop_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    coop_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not coop_cache.coop_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_coop = struct_each_day and UE.find_property(struct_each_day, 'ChickenCoopSaveData')
    coop_cache.coop_offset = prop_coop and prop_coop.offset or 0x19E8
  end

  return coop_cache.save_sub ~= nil
end

local function get_coop_actor()
  if coop_cache.coop_actor and UE.is_valid_pointer(coop_cache.coop_actor) then
    return coop_cache.coop_actor
  end
  UE.for_each_object(function(obj)
    if UE.get_class_name(obj) == 'BP_ChickenCoop_C' and readInteger(obj + 0x08) == 0 then
      coop_cache.coop_actor = obj
      return true
    end
  end)
  return coop_cache.coop_actor
end

local function apply_force_hatch()
  if not resolve_coop() then return false end

  local save_sub = coop_cache.save_sub
  local coop_addr = save_sub + 0x50 + coop_cache.current_offset + coop_cache.coop_offset

  local nests_ptr = readPointer(coop_addr + 0x20)
  local nests_count = readInteger(coop_addr + 0x28)
  local changed = false

  if nests_ptr and nests_count and nests_count &gt; 0 then
    for i = 0, nests_count - 1 do
      local slot = nests_ptr + i * 12
      local state = readBytes(slot, 1)
      if state == 1 then -- Egg -&gt; Adult Chicken
        writeBytes(slot, 2)
        writeInteger(slot + 4, 0)
        writeBytes(slot + 8, i % 3)
        changed = true
      end
    end
    writeInteger(coop_addr + 0x30, 100)
  end

  local actor = get_coop_actor()
  if actor and (changed or not coop_cache.reflected) then
    coop_cache.reflected = true
    executeCodeEx(0, nil, coop_cache.pe_fn, actor, coop_cache.reflect_fn, 0)
  end

  return true
end

apply_force_hatch()

if FORCE_HATCH_TIMER then
  FORCE_HATCH_TIMER.destroy()
  FORCE_HATCH_TIMER = nil
end

FORCE_HATCH_TIMER = createTimer(nil, false)
FORCE_HATCH_TIMER.Interval = 500
FORCE_HATCH_TIMER.OnTimer = function()
  apply_force_hatch()
end
FORCE_HATCH_TIMER.setEnabled(true)

[DISABLE]
{$lua}
if FORCE_HATCH_TIMER then
  FORCE_HATCH_TIMER.destroy()
  FORCE_HATCH_TIMER = nil
end
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27754</ID>
              <Description>"Unlock All Cultivation Chambers (Chambre de culture - 6 Chambers)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local function unlock_chambers()
  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  local save_sub = nil
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        save_sub = val
        break
      end
    end
  end
  if not save_sub then return false end

  local struct_normal = UE.find_struct('AibouSaveData_Normal')
  local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
  local current_offset = prop_norm and prop_norm.offset or 0x50

  local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
  local prop_plant = struct_each_day and UE.find_property(struct_each_day, 'CultivationPlantSaveData')
  local plant_offset = prop_plant and prop_plant.offset or 0x1668

  local plant_addr = save_sub + 0x50 + current_offset + plant_offset
  local cur_num = readInteger(plant_addr + 0x28)
  local arr_ptr = readPointer(plant_addr + 0x20)
  local target_num = 6
  local slot_size = 28

  if cur_num and cur_num &lt; target_num then
    local new_buf = allocateMemory(target_num * slot_size + 64)
    if arr_ptr and cur_num &gt; 0 then
      for b = 0, cur_num * slot_size - 1 do
        writeBytes(new_buf + b, {readBytes(arr_ptr + b, 1)})
      end
    end
    for b = cur_num * slot_size, target_num * slot_size - 1 do
      writeBytes(new_buf + b, {0})
    end
    writePointer(plant_addr + 0x20, new_buf)
    writeInteger(plant_addr + 0x28, target_num)
    writeInteger(plant_addr + 0x2C, target_num)
  end
  return true
end

unlock_chambers()

[DISABLE]
{$lua}
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27755</ID>
              <Description>"Instant Crop Growth &amp; 100% Cultivation Progress (Immediate Harvest)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local plant_cache = {
  save_sub = nil,
  current_offset = nil,
  plant_offset = nil
}

local function resolve_plant()
  if plant_cache.save_sub and UE.is_valid_pointer(plant_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        plant_cache.save_sub = val
        break
      end
    end
  end

  if not plant_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    plant_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not plant_cache.plant_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_plant = struct_each_day and UE.find_property(struct_each_day, 'CultivationPlantSaveData')
    plant_cache.plant_offset = prop_plant and prop_plant.offset or 0x1668
  end

  return plant_cache.save_sub ~= nil
end

local function apply_crop_growth()
  if not resolve_plant() then return false end

  local save_sub = plant_cache.save_sub
  local plant_addr = save_sub + 0x50 + plant_cache.current_offset + plant_cache.plant_offset

  local arr_ptr = readPointer(plant_addr + 0x20)
  local arr_num = readInteger(plant_addr + 0x28)
  if arr_ptr and arr_num and arr_num &gt; 0 then
    for i = 0, arr_num - 1 do
      local slot = arr_ptr + i * 28
      local is_planted = readBytes(slot, 1)
      if is_planted == 1 then
        writeInteger(slot + 0x14, 0) -- RemainingTime = 0 (100% Growth)
      end
    end
    writeInteger(plant_addr + 0x30, 100) -- Max water
  end
  return true
end

apply_crop_growth()

if CROP_GROWTH_TIMER then
  CROP_GROWTH_TIMER.destroy()
  CROP_GROWTH_TIMER = nil
end

CROP_GROWTH_TIMER = createTimer(nil, false)
CROP_GROWTH_TIMER.Interval = 500
CROP_GROWTH_TIMER.OnTimer = function()
  apply_crop_growth()
end
CROP_GROWTH_TIMER.setEnabled(true)

[DISABLE]
{$lua}
if CROP_GROWTH_TIMER then
  CROP_GROWTH_TIMER.destroy()
  CROP_GROWTH_TIMER = nil
end
</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27756</ID>
              <Description>"Infinite Food Ingredients &amp; Cooking Supplies (All Ingredients x999 &amp; Seeds x99)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local cook_cache = {
  save_sub = nil,
  current_offset = nil,
  inv_offset = nil
}

local function resolve_inv()
  if cook_cache.save_sub and UE.is_valid_pointer(cook_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 and UE.get_class_name(val) == 'AibouSaveDataSubsystem' then
        cook_cache.save_sub = val
        break
      end
    end
  end

  if not cook_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    cook_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not cook_cache.inv_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_inv = struct_each_day and UE.find_property(struct_each_day, 'InventorySaveData')
    cook_cache.inv_offset = prop_inv and prop_inv.offset or 0x640
  end

  return cook_cache.save_sub ~= nil
end

local function apply_max_ingredients()
  if not resolve_inv() then return false end

  local save_sub = cook_cache.save_sub
  local inv_addr = save_sub + 0x50 + cook_cache.current_offset + cook_cache.inv_offset

  local map_ptr = readPointer(inv_addr)
  local map_max = readInteger(inv_addr + 0xC)
  if map_ptr and map_max and map_max &gt; 0 then
    for i = 0, map_max - 1 do
      local elem = map_ptr + i * 24
      local comp_idx = readInteger(elem)
      local num_idx = readInteger(elem + 4)
      if comp_idx == 148280 then
        -- Ingredients: 166 (Meat) to 180 (Life fruit)
        if num_idx &gt;= 166 and num_idx &lt;= 180 then
          if readInteger(elem + 8) &lt; 999 then
            writeInteger(elem + 8, 999)
          end
        -- Seeds: 186 to 195
        elseif num_idx &gt;= 186 and num_idx &lt;= 195 then
          if readInteger(elem + 8) &lt; 99 then
            writeInteger(elem + 8, 99)
          end
        end
      end
    end
  end
  return true
end

apply_max_ingredients()

if COOKING_INGREDIENTS_TIMER then
  COOKING_INGREDIENTS_TIMER.destroy()
  COOKING_INGREDIENTS_TIMER = nil
end

COOKING_INGREDIENTS_TIMER = createTimer(nil, false)
COOKING_INGREDIENTS_TIMER.Interval = 500
COOKING_INGREDIENTS_TIMER.OnTimer = function()
  apply_max_ingredients()
end
COOKING_INGREDIENTS_TIMER.setEnabled(true)

[DISABLE]
{$lua}
if COOKING_INGREDIENTS_TIMER then
  COOKING_INGREDIENTS_TIMER.destroy()
  COOKING_INGREDIENTS_TIMER = nil
end
</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27760</ID>
          <Description>"Inventory &amp; Items"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27695</ID>
              <Description>"Item Spawner &amp; Inventory Editor (Add Any Item)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

if syntaxcheck then return end



-- Item Spawner &amp; Inventory Editor (Add Any Item - Multi-Select &amp; Batch Spawner)

-- Pure Lua UE5 Reflection script. 100% dynamic, zero hardcoded addresses, zero AOBs.

-- Features:

-- 1. Multi-Select: Use Ctrl+Click or Shift+Click to select multiple items at once.

-- 2. Select All / Deselect All buttons for quick batch operations.

-- 3. Add Selected: Adds all currently selected items in one click.

-- 4. Add ALL in List: Instantly adds all items matching the current search filter.



local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')

if library_record and not library_record.Active then

  library_record.Active = true

end



local UE = UE_REFLECTION

if not UE then error('UE Reflection Library (Lua) is required') end



-- Helper: Dynamically find AibouInventorySubsystem

local cached_inv = nil

local function get_inventory_subsystem()

  if not UE_REFLECTION then return nil end

  if cached_inv and UE.is_valid_pointer(cached_inv) and UE_REFLECTION.is_instance_alive(cached_inv, UE_REFLECTION.get_class(cached_inv)) then

    return cached_inv

  end



  local pawn = UE_REFLECTION.get_local_player_pawn()

  if not pawn then return nil end



  local level = UE_REFLECTION.get_outer(pawn)

  local world = level and UE_REFLECTION.get_outer(level)

  local gi = world and UE_REFLECTION.read_property(world, 'OwningGameInstance')

  if not gi or gi == 0 then return nil end



  local data_ptr = readPointer(gi + 0x108)

  local num = readInteger(gi + 0x108 + 8)

  if data_ptr and num and num &gt; 0 then

    for i = 0, num - 1 do

      local val = readPointer(data_ptr + i * 24 + 8)

      if val and val &gt; 0 and UE_REFLECTION.get_class_name(val) == 'AibouInventorySubsystem' then

        cached_inv = val

        return val

      end

    end

  end

  return nil

end



-- Helper: Retrieve all items from DT_Item

local function get_all_items(inv)

  if not inv or inv == 0 then return {} end

  local p_dt = UE.find_property(UE.get_class(inv), 'DummyDataTables')

  if not p_dt then return {} end



  local dt_arr = readPointer(inv + p_dt.offset)

  if not dt_arr or dt_arr == 0 then return {} end



  local dt_item = readPointer(dt_arr)

  if not dt_item or dt_item == 0 then return {} end



  local row_map_ptr = readPointer(dt_item + 0x30)

  local row_count = readInteger(dt_item + 0x30 + 8)

  if not row_map_ptr or not row_count or row_count &lt;= 0 then return {} end



  local items = {}

  for i = 0, row_count - 1 do

    local elem = row_map_ptr + i * 24

    local row_name = UE.get_object_name(elem - 0x18)

    local row_ptr = readPointer(elem + 8)

    if row_name and row_ptr and row_ptr &gt; 0 then

      local label_key = UE.get_object_name(row_ptr + 0xC - 0x18) or ''

      local clean_name = label_key:gsub('^ItemName_', ''):gsub('_', ' ')

      if clean_name == '' then clean_name = row_name end

      local max_count = readInteger(row_ptr + 0x2C) or 99



      table.insert(items, {

        row_name = row_name,

        clean_name = clean_name,

        f_idx = readInteger(elem),

        f_num = readInteger(elem + 4),

        max_count = max_count,

        display_name = string.format('%s  [%s]', clean_name, row_name)

      })

    end

  end



  table.sort(items, function(a, b) return a.display_name:lower() &lt; b.display_name:lower() end)

  return items

end



-- Helper: Dynamically locate ProcessEvent in vtable

local cached_pe = nil

local function resolve_process_event(vt)

  if cached_pe then return cached_pe end

  for i = 65, 95 do

    local fn = readPointer(vt + i * 8)

    if fn and fn &gt; 0x10000 then

      local b = readBytes(fn, 6, true)

      if b and b[1] == 0x40 and b[2] == 0x55 and b[3] == 0x56 and b[4] == 0x57 and b[5] == 0x41 and b[6] == 0x54 then

        cached_pe = fn

        return fn

      end

    end

  end

  cached_pe = readPointer(vt + 77 * 8)

  return cached_pe

end



-- Helper: Find function UObject inside class definition

local func_cache = {}

local function find_class_func(cls, func_name)

  if func_cache[func_name] then return func_cache[func_name] end

  local child = readPointer(cls + 0x48)

  while child and child &gt; 0 do

    if UE.get_object_name(child) == func_name then

      func_cache[func_name] = child

      return child

    end

    child = readPointer(child + 0x28)

  end

  return nil

end



-- Helper: Execute AddItemNum or SetItemNum via synchronous ProcessEvent

local function invoke_inventory_item(inv, fn_name, f_idx, f_num, quantity)

  local cls = UE.get_class(inv)

  local fn_obj = find_class_func(cls, fn_name)

  if not fn_obj or fn_obj == 0 then return false, 'Function ' .. fn_name .. ' not found' end



  local vtable = readPointer(inv)

  if not vtable or vtable == 0 then return false, 'VTable not found' end



  local pe_fn = resolve_process_event(vtable)

  if not pe_fn or pe_fn == 0 then return false, 'ProcessEvent not found' end



  local is_add = (fn_name == 'AddItemNum')

  local parms_size = is_add and 64 or 32

  local parms = allocateMemory(parms_size)

  for i = 0, parms_size - 1 do writeBytes(parms + i, {0}) end



  writeInteger(parms + 0x00, f_idx)

  writeInteger(parms + 0x04, f_num)

  writeInteger(parms + 0x08, quantity)

  writeBytes(parms + 0x0C, {1}) -- IsSkipNotification = true

  writeBytes(parms + 0x0D, {1}) -- IsSkipFirstTimeItemNotification = true

  writeBytes(parms + 0x0E, {0}) -- NotCheckAchievement = false



  if is_add then

    writeBytes(parms + 0x30, {1}) -- IsSendBag = true

    writeBytes(parms + 0x31, {0}) -- IsGetBuddy = false

    writeInteger(parms + 0x34, -1)

  else

    writeInteger(parms + 0x10, -1)

  end



  executeCodeEx(0, nil, pe_fn, inv, fn_obj, parms)



  local ret_val = is_add and readInteger(parms + 0x34) or readInteger(parms + 0x10)

  deAlloc(parms)



  return true, { return_val = ret_val }

end



-- Close any previously opened spawner window

if ITEM_SPAWNER_FORM then

  pcall(function() ITEM_SPAWNER_FORM.close() end)

  ITEM_SPAWNER_FORM = nil

end



-- Build GUI Form

local form = createForm(false)

ITEM_SPAWNER_FORM = form

form.Caption = 'Item Spawner &amp; Inventory Editor (Multi-Select)'

form.ClientWidth = 584

form.Height = 690

form.Position = 'poScreenCenter'

form.Color = 0x1E1E1E



local lbl_title = createLabel(form)

lbl_title.Caption = 'Item Spawner - Add Any Item to Inventory'

lbl_title.Font.Size = 12

lbl_title.Font.Style = '[fsBold]'

lbl_title.Font.Color = 0xFFFFFF

lbl_title.Left = 16

lbl_title.Top = 12



local lbl_search = createLabel(form)

lbl_search.Caption = 'Search / Filter Items:'

lbl_search.Font.Color = 0xCCCCCC

lbl_search.Left = 16

lbl_search.Top = 38



local edit_search = createEdit(form)

edit_search.Left = 16

edit_search.Top = 56

edit_search.Width = 552

edit_search.Text = ''



-- Selection utility buttons row

local btn_sel_all = createButton(form)

btn_sel_all.Left = 16

btn_sel_all.Top = 86

btn_sel_all.Width = 165

btn_sel_all.Height = 26

btn_sel_all.Caption = 'Select All'



local btn_desel_all = createButton(form)

btn_desel_all.Left = 188

btn_desel_all.Top = 86

btn_desel_all.Width = 180

btn_desel_all.Height = 26

btn_desel_all.Caption = 'Deselect All'



local lbl_count_info = createLabel(form)

lbl_count_info.Left = 378

lbl_count_info.Top = 92

lbl_count_info.Font.Color = 0xAAAAAA

lbl_count_info.Caption = '0 items shown | 0 selected'



local list_box = createListBox(form)

list_box.Left = 16

list_box.Top = 118

list_box.Width = 552

list_box.Height = 330

list_box.MultiSelect = true

list_box.ExtendedSelect = true



local lbl_qty = createLabel(form)

lbl_qty.Caption = 'Quantity:'

lbl_qty.Font.Color = 0xFFFFFF

lbl_qty.Left = 16

lbl_qty.Top = 462



local edit_qty = createEdit(form)

edit_qty.Left = 75

edit_qty.Top = 458

edit_qty.Width = 70

edit_qty.Text = '1'



local btn_q1 = createButton(form)

btn_q1.Left = 155

btn_q1.Top = 457

btn_q1.Width = 42

btn_q1.Height = 25

btn_q1.Caption = '+1'

btn_q1.OnClick = function() edit_qty.Text = '1' end



local btn_q10 = createButton(form)

btn_q10.Left = 202

btn_q10.Top = 457

btn_q10.Width = 42

btn_q10.Height = 25

btn_q10.Caption = '+10'

btn_q10.OnClick = function() edit_qty.Text = '10' end



local btn_q50 = createButton(form)

btn_q50.Left = 249

btn_q50.Top = 457

btn_q50.Width = 42

btn_q50.Height = 25

btn_q50.Caption = '+50'

btn_q50.OnClick = function() edit_qty.Text = '50' end



local btn_q99 = createButton(form)

btn_q99.Left = 296

btn_q99.Top = 457

btn_q99.Width = 42

btn_q99.Height = 25

btn_q99.Caption = '99'

btn_q99.OnClick = function() edit_qty.Text = '99' end



local btn_qmax = createButton(form)

btn_qmax.Left = 343

btn_qmax.Top = 457

btn_qmax.Width = 75

btn_qmax.Height = 25

btn_qmax.Caption = 'Max 999'

btn_qmax.OnClick = function() edit_qty.Text = '999' end



local btn_reload = createButton(form)

btn_reload.Left = 460

btn_reload.Top = 457

btn_reload.Width = 108

btn_reload.Height = 25

btn_reload.Caption = 'Reload Items'



-- Primary Actions

local btn_add_sel = createButton(form)

btn_add_sel.Left = 16

btn_add_sel.Top = 495

btn_add_sel.Width = 270

btn_add_sel.Height = 36

btn_add_sel.Caption = '&gt;&gt;&gt; Add Selected Item(s) &lt;&lt;&lt;'

btn_add_sel.Font.Style = '[fsBold]'



local btn_set_sel = createButton(form)

btn_set_sel.Left = 298

btn_set_sel.Top = 495

btn_set_sel.Width = 270

btn_set_sel.Height = 36

btn_set_sel.Caption = 'Set Exact Quantity for Selected'



-- Batch Action: Add ALL in list

local btn_add_all = createButton(form)

btn_add_all.Left = 16

btn_add_all.Top = 538

btn_add_all.Width = 552

btn_add_all.Height = 38

btn_add_all.Caption = '&gt;&gt;&gt; Add ALL Items in List &lt;&lt;&lt;'

btn_add_all.Font.Size = 10

btn_add_all.Font.Style = '[fsBold]'



local lbl_status = createLabel(form)

lbl_status.Left = 16

lbl_status.Top = 590

lbl_status.Width = 552

lbl_status.Font.Color = 0x00FF88

lbl_status.Caption = 'Ready. Use Ctrl+Click or Shift+Click to multi-select items.'



local lbl_hint = createLabel(form)

lbl_hint.Left = 16

lbl_hint.Top = 618

lbl_hint.Width = 552

lbl_hint.Height = 24

lbl_hint.Font.Size = 9

lbl_hint.Font.Color = 0x888888

lbl_hint.Caption = 'Tip: Filter "Costume" and click "Add ALL Items in List" to add all 14 costumes.'



-- State tracking

local all_items = {}

local filtered_items = {}



local function update_selection_count()

  local sel_count = 0

  for i = 0, list_box.Items.Count - 1 do

    if list_box.Selected[i] then sel_count = sel_count + 1 end

  end

  lbl_count_info.Caption = string.format('%d items shown | %d selected', #filtered_items, sel_count)

end



list_box.OnClick = function() update_selection_count() end



local function refresh_list()

  list_box.clear()

  filtered_items = {}

  local query = edit_search.Text:lower()



  for _, item in ipairs(all_items) do

    if query == '' or item.display_name:lower():find(query, 1, true) then

      table.insert(filtered_items, item)

      list_box.Items.add(item.display_name)

    end

  end



  update_selection_count()

  if #filtered_items &gt; 0 then

    lbl_status.Caption = string.format('Showing %d of %d items matching filter.', #filtered_items, #all_items)

  else

    lbl_status.Caption = 'No items match your filter.'

  end

end



edit_search.OnChange = function()

  refresh_list()

end



btn_sel_all.OnClick = function()

  for i = 0, list_box.Items.Count - 1 do

    list_box.Selected[i] = true

  end

  update_selection_count()

end



btn_desel_all.OnClick = function()

  for i = 0, list_box.Items.Count - 1 do

    list_box.Selected[i] = false

  end

  update_selection_count()

end



local function execute_batch(items_to_add, action_fn_name)

  if #items_to_add == 0 then

    lbl_status.Font.Color = 0xFF5555

    lbl_status.Caption = 'Error: No items selected to add.'

    return

  end



  local qty = tonumber(edit_qty.Text) or 1

  if qty &lt; 1 then qty = 1 end

  if qty &gt; 9999 then qty = 9999 end



  local inv = get_inventory_subsystem()

  if not inv then

    lbl_status.Font.Color = 0xFF5555

    lbl_status.Caption = 'Error: Inventory subsystem not available. Please ensure savegame is loaded.'

    return

  end



  local success_count = 0

  local last_item_name = ''

  for _, item in ipairs(items_to_add) do

    local ok = invoke_inventory_item(inv, action_fn_name, item.f_idx, item.f_num, qty)

    if ok then

      success_count = success_count + 1

      last_item_name = item.clean_name

    end

  end



  lbl_status.Font.Color = 0x00FF88

  local action_verb = (action_fn_name == 'AddItemNum') and 'Added' or 'Set'

  if success_count == 1 then

    lbl_status.Caption = string.format('Success! %s %dx %s in inventory/storage.', action_verb, qty, last_item_name)

  else

    lbl_status.Caption = string.format('Success! %s %dx to %d items at once in inventory!', action_verb, qty, success_count)

  end

end



-- Add Selected Button

btn_add_sel.OnClick = function()

  local selected = {}

  for i = 0, list_box.Items.Count - 1 do

    if list_box.Selected[i] and filtered_items[i + 1] then

      table.insert(selected, filtered_items[i + 1])

    end

  end

  execute_batch(selected, 'AddItemNum')

end



-- Set Selected Button

btn_set_sel.OnClick = function()

  local selected = {}

  for i = 0, list_box.Items.Count - 1 do

    if list_box.Selected[i] and filtered_items[i + 1] then

      table.insert(selected, filtered_items[i + 1])

    end

  end

  execute_batch(selected, 'SetItemNum')

end



-- Add ALL in List Button

btn_add_all.OnClick = function()

  execute_batch(filtered_items, 'AddItemNum')

end



-- Reload Items

btn_reload.OnClick = function()

  cached_inv = nil

  local live_inv = get_inventory_subsystem()

  if live_inv then

    all_items = get_all_items(live_inv)

    refresh_list()

    lbl_status.Font.Color = 0x00FF88

    lbl_status.Caption = string.format('Reloaded %d items successfully from game database.', #all_items)

  else

    lbl_status.Font.Color = 0xFFAA00

    lbl_status.Caption = 'Game save not loaded yet. Please enter the game world.'

  end

end



-- Initial loading

local inv = get_inventory_subsystem()

if inv then

  all_items = get_all_items(inv)

  refresh_list()

else

  lbl_status.Font.Color = 0xFFAA00

  lbl_status.Caption = 'Waiting for game world. Please load your savegame and click "Reload Items".'

end



form.OnClose = function()

  local mr = getAddressList().getMemoryRecordByDescription('Item Spawner &amp; Inventory Editor (Add Any Item)')

  if mr and mr.Active then

    mr.Active = false

  end

end



form.show()



{$asm}

[DISABLE]

{$lua}

if syntaxcheck then return end



if ITEM_SPAWNER_FORM then

  pcall(function()

    ITEM_SPAWNER_FORM.destroy()

  end)

  ITEM_SPAWNER_FORM = nil

end

{$asm}

</AssemblerScript>
            </CheatEntry>
            <CheatEntry>
              <ID>27761</ID>
              <Description>"Infinite Inventory Capacity &amp; No Bag Limit (Never Full &amp; No Amber Conversion)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]
{$lua}
if syntaxcheck then return end

-- Infinite Inventory Capacity &amp; No Bag Limit (Never Full &amp; No Amber Conversion)
-- 100% Pure Lua UE5 Reflection script. Zero Assembly, zero hardcoded addresses.
-- 1. Removes all bag and storage limits (StorageMaxNum set to 999,999).
-- 2. Prevents bags from becoming full (PlayerBagData.IsBagFull and BuddyBagData.IsBagFull neutralised to 0).
-- 3. Dynamically bypasses IsMaxItem (returns false) and forces CanAddItem (returns true): prevents items from being discarded or converted to amber.
-- Fully resilient across zone transitions, cutscenes, returns to camp, and game updates.

local library_record = getAddressList().getMemoryRecordByDescription('UE Reflection Library (Lua)')
if library_record and not library_record.Active then
  library_record.Active = true
end

local UE = UE_REFLECTION
if not UE then error('UE Reflection Library (Lua) is required') end

local UPDATE_INTERVAL_MS = 100

INVENTORY_LIMIT_PATCHES = INVENTORY_LIMIT_PATCHES or {
  is_max_call_addr = nil,
  orig_is_max_bytes = nil,
  can_add_call_addr = nil,
  orig_can_add_bytes = nil
}

local inv_cache = {
  inv_sub = nil,
  save_sub = nil,
  current_offset = nil,
  inv_offset = nil
}

local function resolve_subsystems()
  if inv_cache.inv_sub and UE.is_valid_pointer(inv_cache.inv_sub) and
     inv_cache.save_sub and UE.is_valid_pointer(inv_cache.save_sub) then
    return true
  end

  local pawn = UE.get_local_player_pawn()
  if not pawn then return false end

  local level = UE.get_outer(pawn)
  local world = level and UE.get_outer(level)
  local gi = world and UE.read_property(world, 'OwningGameInstance')
  if not gi or gi == 0 then return false end

  local data_ptr = readPointer(gi + 0x108)
  local num = readInteger(gi + 0x108 + 8)
  if data_ptr and num and num &gt; 0 then
    for i = 0, num - 1 do
      local val = readPointer(data_ptr + i * 24 + 8)
      if val and val &gt; 0 then
        local cname = UE.get_class_name(val)
        if cname == 'AibouInventorySubsystem' then
          inv_cache.inv_sub = val
        elseif cname == 'AibouSaveDataSubsystem' then
          inv_cache.save_sub = val
        end
      end
    end
  end

  if not inv_cache.current_offset then
    local struct_normal = UE.find_struct('AibouSaveData_Normal')
    local prop_norm = struct_normal and UE.find_property(struct_normal, 'CurrentData')
    inv_cache.current_offset = prop_norm and prop_norm.offset or 0x50
  end

  if not inv_cache.inv_offset then
    local struct_each_day = UE.find_struct('AibouSaveData_EachDay')
    local prop_inv = struct_each_day and UE.find_property(struct_each_day, 'InventorySaveData')
    inv_cache.inv_offset = prop_inv and prop_inv.offset or 0x640
  end

  return inv_cache.inv_sub ~= nil and inv_cache.save_sub ~= nil
end

local function apply_function_patches()
  if not inv_cache.inv_sub then return end
  local cls = UE.get_class(inv_cache.inv_sub)

  -- 1. Patch IsMaxItem -&gt; Always return false (xor eax, eax ; nop ; nop ; nop)
  if not INVENTORY_LIMIT_PATCHES.is_max_call_addr then
    local fn_is_max = nil
    UE.for_each_object(function(obj)
      if UE.get_outer(obj) == cls and UE.get_object_name(obj) == 'IsMaxItem' then
        fn_is_max = obj
        return true
      end
    end)
    if fn_is_max then
      local native_fn = readPointer(fn_is_max + 0xD8)
      if native_fn and native_fn &gt; 0x10000000000 then
        local bytes = readBytes(native_fn, 300, true)
        if bytes then
          for j = 1, #bytes - 5 do
            if bytes[j] == 0x48 and bytes[j+1] == 0x89 and bytes[j+2] == 0x7B and bytes[j+3] == 0x20 and bytes[j+4] == 0xE8 then
              INVENTORY_LIMIT_PATCHES.is_max_call_addr = native_fn + (j + 3)
              INVENTORY_LIMIT_PATCHES.orig_is_max_bytes = {bytes[j+4], bytes[j+5], bytes[j+6], bytes[j+7], bytes[j+8]}
              break
            end
          end
        end
      end
    end
  end

  if INVENTORY_LIMIT_PATCHES.is_max_call_addr then
    -- 31 C0 90 90 90 : xor eax, eax ; nop ; nop ; nop
    writeBytes(INVENTORY_LIMIT_PATCHES.is_max_call_addr, {0x31, 0xC0, 0x90, 0x90, 0x90})
  end

  -- 2. Patch CanAddItem -&gt; Always return true (B0 01 90 90 90 : mov al, 1 ; nop ; nop ; nop)
  if not INVENTORY_LIMIT_PATCHES.can_add_call_addr then
    local fn_can_add = nil
    UE.for_each_object(function(obj)
      if UE.get_outer(obj) == cls and UE.get_object_name(obj) == 'CanAddItem' then
        fn_can_add = obj
        return true
      end
    end)
    if fn_can_add then
      local native_fn = readPointer(fn_can_add + 0xD8)
      if native_fn and native_fn &gt; 0x10000000000 then
        local bytes = readBytes(native_fn, 300, true)
        if bytes then
          for j = 1, #bytes - 5 do
            if bytes[j] == 0x48 and bytes[j+1] == 0x89 and bytes[j+2] == 0x7B and bytes[j+3] == 0x20 and bytes[j+4] == 0xE8 then
              INVENTORY_LIMIT_PATCHES.can_add_call_addr = native_fn + (j + 3)
              INVENTORY_LIMIT_PATCHES.orig_can_add_bytes = {bytes[j+4], bytes[j+5], bytes[j+6], bytes[j+7], bytes[j+8]}
              break
            end
          end
        end
      end
    end
  end

  if INVENTORY_LIMIT_PATCHES.can_add_call_addr then
    -- B0 01 90 90 90 : mov al, 1 ; nop ; nop ; nop
    writeBytes(INVENTORY_LIMIT_PATCHES.can_add_call_addr, {0xB0, 0x01, 0x90, 0x90, 0x90})
  end
end

local function update_inventory_limits()
  if not UE_REFLECTION then return end
  if not resolve_subsystems() then return end

  apply_function_patches()

  local inv_sub = inv_cache.inv_sub
  local save_sub = inv_cache.save_sub

  -- Storage and notification bypass
  writeInteger(inv_sub + 0x288, 999999) -- StorageMaxNum
  writeByte(inv_sub + 0x4E8, 0)        -- IsSendBagFullNotify

  -- Player &amp; Buddy Bag capacity &amp; state
  local inv_addr = save_sub + 0x50 + inv_cache.current_offset + inv_cache.inv_offset
  writeByte(inv_addr + 0x308 + 16, 0) -- PlayerBagData.IsBagFull = false
  writeByte(inv_addr + 0x320 + 16, 0) -- BuddyBagData.IsBagFull = false

  -- Extra item limits
  writeInteger(inv_addr + 0xA0, 999)  -- RecoveryItemAdditionMaxNum
  writeInteger(inv_addr + 0x338, 999) -- ResuscitationItemMaxNum
  writeInteger(inv_addr + 0x33C, 999) -- FirstAidItemMaxNum
end

if INFINITE_INVENTORY_TIMER then
  INFINITE_INVENTORY_TIMER.destroy()
  INFINITE_INVENTORY_TIMER = nil
end

INFINITE_INVENTORY_TIMER = createTimer(nil, false)
INFINITE_INVENTORY_TIMER.Interval = UPDATE_INTERVAL_MS
INFINITE_INVENTORY_TIMER.OnTimer = function()
  pcall(update_inventory_limits)
end
INFINITE_INVENTORY_TIMER.Enabled = true
pcall(update_inventory_limits)

{$asm}
[DISABLE]
{$lua}
if syntaxcheck then return end

if INFINITE_INVENTORY_TIMER then
  INFINITE_INVENTORY_TIMER.Enabled = false
  INFINITE_INVENTORY_TIMER.destroy()
  INFINITE_INVENTORY_TIMER = nil
end

if INVENTORY_LIMIT_PATCHES then
  if INVENTORY_LIMIT_PATCHES.is_max_call_addr and INVENTORY_LIMIT_PATCHES.orig_is_max_bytes then
    writeBytes(INVENTORY_LIMIT_PATCHES.is_max_call_addr, INVENTORY_LIMIT_PATCHES.orig_is_max_bytes)
  end
  if INVENTORY_LIMIT_PATCHES.can_add_call_addr and INVENTORY_LIMIT_PATCHES.orig_can_add_bytes then
    writeBytes(INVENTORY_LIMIT_PATCHES.can_add_call_addr, INVENTORY_LIMIT_PATCHES.orig_can_add_bytes)
  end
end
{$asm}
</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
        <CheatEntry>
          <ID>27704</ID>
          <Description>"Debug &amp; Utilities"</Description>
          <Options moHideChildren="1"/>
          <GroupHeader>1</GroupHeader>
          <CheatEntries>
            <CheatEntry>
              <ID>27036</ID>
              <Description>"UE Attribute Mapper (Lua)"</Description>
              <VariableType>Auto Assembler Script</VariableType>
              <AssemblerScript>[ENABLE]

{$lua}

-- UE Attribute Mapper: builds a Cheat Engine pointer-chain table for the local player using UE reflection only.

-- Every chain starts at the static GWorld pointer, so the records keep following the live objects after a

-- world restart or scene change. Offsets are resolved by property NAME at build time (update resilient).

local UE = UE_REFLECTION

if not UE then error('Enable the UE Reflection Library (Lua) record first') end



local OUTPUT_DESCRIPTION = 'UE Attribute Mapper Output'

local WORLD_SYMBOL = 'GWorld_Ptr'

local MAX_INSTANCE_RECORDS = 200



local function log(message) print('[UE Mapper] ' .. message) end



local address_list = getAddressList()

for i = address_list.Count - 1, 0, -1 do

  if address_list[i].Description == OUTPUT_DESCRIPTION then address_list[i].destroy() end

end



local function to_hex_pattern(value)

  local bytes = {}

  for i = 0, 7 do bytes[#bytes + 1] = string.format('%02X', (value &gt;&gt; (i * 8)) &amp; 0xFF) end

  return table.concat(bytes, ' ')

end



-- Finds the live UWorld through reflection, then the static pointer variable (GWorld) that references it.

local function find_world_static()

  assert(UE.ensure_ready())

  local main_module = enumModules()[1]

  local module_start = main_module.Address

  local module_end = module_start + getModuleSize(main_module.Name)

  local candidates = {}

  UE.for_each_object(function(object)

    if UE.get_class_name(object) == 'World' and not (UE.get_object_name(object) or ''):find('^Default__') then

      if UE.read_property(object, 'OwningGameInstance') and UE.read_property(object, 'PersistentLevel') then

        candidates[#candidates + 1] = object

      end

    end

  end)

  for _, world in ipairs(candidates) do

    local hits = AOBScan(to_hex_pattern(world), '+W', 0, '')

    if hits then

      for i = 0, hits.Count - 1 do

        local address = tonumber(hits[i], 16)

        if address &gt;= module_start and address &lt; module_end then hits.destroy() return address, world end

      end

      hits.destroy()

    end

  end

  return nil

end



local world_static, world = find_world_static()

if not world_static then error('live UWorld / GWorld static pointer not found (not in a world?)') end

unregisterSymbol(WORLD_SYMBOL)

registerSymbol(WORLD_SYMBOL, world_static, true)

log(string.format('GWorld static @ 0x%X -&gt; UWorld 0x%X', world_static, world))



local function offset_of(object, property_name)

  local property = UE.find_property(UE.get_class(object), property_name)

  return property and property.offset or nil

end



-- Resolve the local player chain by property names only

local game_instance_offset = offset_of(world, 'OwningGameInstance')

local game_instance = game_instance_offset and readPointer(world + game_instance_offset)

local local_players_offset = game_instance and offset_of(game_instance, 'LocalPlayers')

local local_players_data = local_players_offset and readPointer(game_instance + local_players_offset)

local local_player = UE.is_valid_pointer(local_players_data) and readPointer(local_players_data) or nil

local controller_offset = local_player and offset_of(local_player, 'PlayerController')

local controller = controller_offset and readPointer(local_player + controller_offset)

local pawn_offset = UE.is_valid_pointer(controller) and offset_of(controller, 'AcknowledgedPawn') or nil

local pawn = pawn_offset and readPointer(controller + pawn_offset)

if not UE.is_valid_pointer(pawn) then error('local player pawn not resolved (no controlled pawn yet?)') end



-- Forward step lists (the first step is applied to the pointer stored in GWorld)

local controller_steps = { game_instance_offset, local_players_offset, 0, controller_offset }

local pawn_steps = { game_instance_offset, local_players_offset, 0, controller_offset, pawn_offset }



local function concat_steps(base, extra)

  local result = {}

  for _, v in ipairs(base) do result[#result + 1] = v end

  for _, v in ipairs(extra) do result[#result + 1] = v end

  return result

end



local function create_record(parent, description, steps, var_type, is_hex, is_group)

  local record = address_list.createMemoryRecord()

  record.Description = description

  if is_group then

    record.IsGroupHeader = true

  else

    record.Address = WORLD_SYMBOL

    record.Type = var_type or vtQword

    if is_hex then record.ShowAsHex = true end

    if steps and #steps &gt; 0 then

      record.OffsetCount = #steps

      for i = 1, #steps do record.Offset[i - 1] = steps[#steps - i + 1] end -- CE: Offset[0] is applied last

    end

  end

  if parent then record.appendToEntry(parent) end

  return record

end



local root = create_record(nil, OUTPUT_DESCRIPTION, nil, nil, false, true)



-- [1] Core pointers

local core = create_record(root, '[1] Core pointers', nil, nil, false, true)

create_record(core, 'GWorld (' .. UE.get_class_name(world) .. '*)', {}, vtQword, true)

create_record(core, 'LocalPlayerController (' .. UE.get_class_name(controller) .. '*)', controller_steps, vtQword, true)

create_record(core, 'LocalPlayerPawn (' .. UE.get_class_name(pawn) .. '*)', pawn_steps, vtQword, true)

local player_state_offset = offset_of(controller, 'PlayerState')

if player_state_offset then

  create_record(core, 'LocalPlayerState', concat_steps(controller_steps, { player_state_offset }), vtQword, true)

end



-- [2] Every AttributeSet referenced by the pawn (discovered by reflection, not by name)

local attribute_set_class = UE.find_struct('AttributeSet', 'class')

local attributes_root = create_record(root, '[2] Pawn AttributeSets (GAS)', nil, nil, false, true)

local component_class = UE.find_struct('ActorComponent', 'class')

local pawn_properties = UE.enumerate_properties(UE.get_class(pawn), true)

local set_count, attribute_count = 0, 0

for _, property in ipairs(pawn_properties) do

  if property.type == 'ObjectProperty' and property.offset then

    local instance = readPointer(pawn + property.offset)

    if UE.is_valid_pointer(instance) then

      local instance_class = UE.get_class(instance)

      if instance_class and attribute_set_class and UE.is_a(instance_class, attribute_set_class) then

        set_count = set_count + 1

        local set_steps = concat_steps(pawn_steps, { property.offset })

        local group = create_record(attributes_root, string.format('%s (%s @ +0x%X)', property.name, UE.get_object_name(instance_class), property.offset), nil, nil, false, true)

        create_record(group, 'pointer', set_steps, vtQword, true)

        for _, attribute in ipairs(UE.enumerate_properties(instance_class, true)) do

          if attribute.type == 'StructProperty' then

            local struct = UE.get_struct_of_property(attribute)

            local base_property = struct and UE.find_property(struct, 'BaseValue')

            local current_property = struct and UE.find_property(struct, 'CurrentValue')

            if base_property and current_property and (UE.get_object_name(struct) or ''):find('AttributeData') then

              attribute_count = attribute_count + 1

              create_record(group, string.format('%s.Current (+0x%X)', attribute.name, attribute.offset + current_property.offset),

                concat_steps(set_steps, { attribute.offset + current_property.offset }), vtSingle, false)

              create_record(group, string.format('%s.Base (+0x%X)', attribute.name, attribute.offset + base_property.offset),

                concat_steps(set_steps, { attribute.offset + base_property.offset }), vtSingle, false)

            end

          end

        end

      end

    end

  end

end

log(string.format('%d attribute sets, %d attributes', set_count, attribute_count))



-- [3] Components of the pawn (pointers)

local components_root = create_record(root, '[3] Pawn components', nil, nil, false, true)

for _, property in ipairs(pawn_properties) do

  if property.type == 'ObjectProperty' and property.offset then

    local instance = readPointer(pawn + property.offset)

    local instance_class = UE.is_valid_pointer(instance) and UE.get_class(instance)

    if instance_class and component_class and UE.is_a(instance_class, component_class) then

      create_record(components_root, string.format('%s (%s @ +0x%X)', property.name, UE.get_object_name(instance_class), property.offset),

        concat_steps(pawn_steps, { property.offset }), vtQword, true)

    end

  end

end



-- [4] Movement component: every Float property

local movement_offset = offset_of(pawn, 'CharacterMovement')

local movement = movement_offset and readPointer(pawn + movement_offset)

if UE.is_valid_pointer(movement) then

  local movement_root = create_record(root, string.format('[4] CharacterMovement (+0x%X)', movement_offset), nil, nil, false, true)

  local movement_steps = concat_steps(pawn_steps, { movement_offset })

  for _, property in ipairs(UE.enumerate_properties(UE.get_class(movement), true)) do

    if property.type == 'FloatProperty' and property.offset then

      create_record(movement_root, string.format('%s (+0x%X)', property.name, property.offset), concat_steps(movement_steps, { property.offset }), vtSingle, false)

    end

  end

end



-- [5] Live Character instances (snapshot of addresses, not chains)

local instances = UE.find_live_instances('Character') or {}

local instances_root = create_record(root, string.format('[5] Live Character instances (%d)', #instances), nil, nil, false, true)

for index, object in ipairs(instances) do

  if index &gt; MAX_INSTANCE_RECORDS then break end

  local record = address_list.createMemoryRecord()

  record.Description = string.format('%s%s (%s)', object == pawn and '[LOCAL] ' or '', UE.get_object_name(object), UE.get_class_name(object))

  record.Address = string.format('%X', object)

  record.Type = vtQword

  record.ShowAsHex = true

  record.appendToEntry(instances_root)

end

log('table built')



{$asm}

[DISABLE]

{$lua}

local address_list = getAddressList()

for i = address_list.Count - 1, 0, -1 do

  if address_list[i].Description == 'UE Attribute Mapper Output' then address_list[i].destroy() end

end

unregisterSymbol('GWorld_Ptr')



{$asm}

</AssemblerScript>
            </CheatEntry>
          </CheatEntries>
        </CheatEntry>
      </CheatEntries>
    </CheatEntry>
  </CheatEntries>
  <UserdefinedSymbols/>
</CheatTable>
