[Update] NPC Navigation System is Nearly Complete (Full NavMesh Integration & Stop-Fix Implemented)

[eyes-and-brain]

🚀 Overview
I am using a custom navigation system composed of two integrated parts:

Server-side script (navto.lua): Handles target searching (!navto npc/mob) via database query and broadcasts coordinates to the client.

Client-side Addon (autonav.lua): Intercepts the NAVTO_COORDS string and moves the character using setkey (W, A, D) inputs to simulate manual keyboard movement.

💡 The Core Intent: "High-Momentum" Movement
Unlike standard navigation scripts that stop to rotate, this version prioritizes forward velocity. The design goal is to keep the 'W' key pressed as long as possible.

Key Parameters in autonav.lua:

max_turn_threshold = 1.2 (68°): Keeps 'W' down even if significantly off-course.

turn_threshold = 0.5 (28°): Starts 'A' or 'D' steering while moving.

arrival_distance = 4.0: Large tolerance to prevent circling around the target.

⚠️ Current Technical Issues
I have identified three specific bottlenecks where I need expert advice:

Delayed Stuck Detection: stuck_check_interval is currently 8.0s. This causes the character to run against walls for too long. Reducing this value often triggers "false positives" during normal turns.

Inefficient Obstacle Marking: When stuck, it marks the grid ahead as blocked. However, since the grid_size is large (8.0), it often blocks out valid paths nearby.

W/A/D Oscillation: When turning, the character sometimes vibrates (oscillates) between 'A' and 'D' keys rapidly, which kills the forward momentum.

🛠️ Request for Assistance
Could you suggest improvements for the update_nav function? Specifically:

How to implement a "Back-up and retry" routine when a collision is detected?

Ways to improve the A pathfinding precision* without hitting the 300-iteration limit or causing lag.

Strategies to maintain the "Aggressive W-key" philosophy in narrow corridors.

I've attached/pasted the full source of both scripts for reference. Thank you for your support!

navto.lua:

-----------------------------------
-- func: navto <type> <name_or_id>
-- desc: Navigate to NPC or Mob by querying database
--       Returns coordinates to client for navigation
--
-- Usage:
--   !navto npc Moogle
--   !navto npc 17723579
--   !navto mob Goblin
--   !navto mob 17203201
-----------------------------------

---@type TCommand
local commandObj = {}

commandObj.cmdprops =
{
    permission = 0,  -- Anyone can use
    parameters = 'ss'
}

-- Query NPC position from database or zone
local function getNPCPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    
    -- Try as ID first
    local npcId = tonumber(searchTerm)
    
    if npcId then
        -- Get NPC by ID
        local npc = GetNPCByID(npcId)
        if npc and npc:getZoneID() == zone:getID() then
            table.insert(results, {
                id = npc:getID(),
                name = npc:getName(),
                x = npc:getXPos(),
                y = npc:getYPos(),
                z = npc:getZPos(),
                rot = npc:getRotPos()
            })
        end
    else
        -- Search by name in current zone
        for _, npc in pairs(zone:getNPCs()) do
            if npc and npc:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {
                    id = npc:getID(),
                    name = npc:getName(),
                    x = npc:getXPos(),
                    y = npc:getYPos(),
                    z = npc:getZPos(),
                    rot = npc:getRotPos()
                })
                
                -- Limit to 10 results
                if #results >= 10 then
                    break
                end
            end
        end
    end
    
    return results
end

-- Query Mob spawn position from zone
local function getMobPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    
    -- Try as ID first
    local mobId = tonumber(searchTerm)
    
    if mobId then
        -- Get Mob by ID
        local mob = GetMobByID(mobId)
        if mob and mob:getZoneID() == zone:getID() then
            table.insert(results, {
                id = mob:getID(),
                name = mob:getName(),
                x = mob:getXPos(),
                y = mob:getYPos(),
                z = mob:getZPos(),
                rot = mob:getRotPos()
            })
        end
    else
        -- Search by name in current zone
        for _, mob in pairs(zone:getMobs()) do
            if mob and mob:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {
                    id = mob:getID(),
                    name = mob:getName(),
                    x = mob:getXPos(),
                    y = mob:getYPos(),
                    z = mob:getZPos(),
                    rot = mob:getRotPos()
                })
                
                -- Limit to 10 results
                if #results >= 10 then
                    break
                end
            end
        end
    end
    
    return results
end

commandObj.onTrigger = function(player, entityType, searchTerm)
    if not entityType or not searchTerm then
        player:printToPlayer('Usage: !navto <npc|mob> <name or ID>', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('Examples:', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('  !navto npc Moogle', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('  !navto npc 17723579', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('  !navto mob Goblin', xi.msg.channel.SYSTEM_3)
        return
    end
    
    entityType = entityType:lower()
    
    local results
    if entityType == 'npc' then
        results = getNPCPosition(player, searchTerm)
    elseif entityType == 'mob' then
        results = getMobPosition(player, searchTerm)
    else
        player:printToPlayer('Invalid type. Use "npc" or "mob"', xi.msg.channel.SYSTEM_3)
        return
    end
    
    if not results or #results == 0 then
        player:printToPlayer(string.format('No %s found matching: %s', entityType, searchTerm), xi.msg.channel.SYSTEM_3)
        return
    end
    
    if #results == 1 then
        -- Single result - send coordinates
        local target = results[1]
        player:printToPlayer(string.format('[NavTo] %s: %s', entityType:upper(), target.name), xi.msg.channel.SYSTEM_3)
        player:printToPlayer(string.format('[NavTo] Position: %.2f, %.2f, %.2f', target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
        player:printToPlayer(string.format('[NavTo] ID: %d', target.id), xi.msg.channel.SYSTEM_3)
        
        -- Send special message that Windower addon can intercept
        player:printToPlayer(string.format('NAVTO_COORDS:%s:%.2f:%.2f:%.2f', target.name, target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
    else
        -- Multiple results - show list
        player:printToPlayer(string.format('Found %d matches for "%s":', #results, searchTerm), xi.msg.channel.SYSTEM_3)
        for i, target in ipairs(results) do
            player:printToPlayer(string.format('  %d. %s (ID: %d) at (%.0f, %.0f, %.0f)', 
                i, target.name, target.id, target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
        end
        player:printToPlayer('Use ID to select specific target: !navto npc <ID>', xi.msg.channel.SYSTEM_3)
    end
end

return commandObj

autonav.lua:

--[[
    AutoNav - Aggressive Movement Version
    
    Key changes:
    - Always move forward unless turn is VERY large
    - Much more lenient turning threshold
    - Simplified stuck detection
    - Larger waypoint arrival distance
]]

_addon.name = 'AutoNav'
_addon.version = '5.0'
_addon.commands = {'nav'}

local state = {
    active = false,
    path = {},
    current_step = 1,
    last_update = 0,
    target = nil,
    target_name = nil,
    mode = 'direct',
}

local config = {
    update_interval = 0.2,           -- Slower updates
    arrival_distance = 4.0,          -- Much larger - don't be picky
    turn_threshold = 0.5,            -- 28 degrees - very lenient
    max_turn_threshold = 1.2,        -- 68 degrees - stop forward only if VERY wrong
    grid_size = 8.0,                 -- Larger grid
    pathfind_distance = 30.0,
    stuck_check_interval = 8.0,      -- Check every 8 seconds
    stuck_distance = 2.0,            -- Must move 2m in 8s
    max_attempts = 3,
}

local obstacle_grid = {}
local stuck_state = {
    last_pos = nil,
    last_check = 0,
    attempts = 0,
    gave_up = false,
}

-- Utilities
local function get_player()
    return windower.ffxi.get_mob_by_target('me')
end

local function distance(p1, p2)
    local dx = p2.x - p1.x
    local dz = p2.z - p1.z
    return math.sqrt(dx * dx + dz * dz)
end

local function normalize_angle(angle)
    while angle > math.pi do angle = angle - 2 * math.pi end
    while angle < -math.pi do angle = angle + 2 * math.pi end
    return angle
end

-- Grid
local function world_to_grid(x, z)
    return math.floor(x / config.grid_size), math.floor(z / config.grid_size)
end

local function grid_to_world(gx, gz)
    return gx * config.grid_size + config.grid_size / 2, 
           gz * config.grid_size + config.grid_size / 2
end

local function is_blocked(gx, gz)
    return obstacle_grid[gx] and obstacle_grid[gx][gz]
end

local function mark_blocked(gx, gz)
    obstacle_grid[gx] = obstacle_grid[gx] or {}
    obstacle_grid[gx][gz] = true
end

-- A* (simplified)
local function find_path(start_x, start_z, goal_x, goal_z)
    local start_gx, start_gz = world_to_grid(start_x, start_z)
    local goal_gx, goal_gz = world_to_grid(goal_x, goal_z)
    
    if start_gx == goal_gx and start_gz == goal_gz then
        return {{x = goal_x, z = goal_z}}
    end
    
    local open = {{x = start_gx, z = start_gz, f = 0, g = 0}}
    local came_from = {}
    local g_score = {}
    local key = function(x, z) return x .. ',' .. z end
    
    g_score[key(start_gx, start_gz)] = 0
    
    local iter = 0
    while #open > 0 and iter < 300 do
        iter = iter + 1
        table.sort(open, function(a, b) return a.f < b.f end)
        local cur = table.remove(open, 1)
        
        if cur.x == goal_gx and cur.z == goal_gz then
            local path = {}
            local cx, cz = goal_gx, goal_gz
            while came_from[key(cx, cz)] do
                local wx, wz = grid_to_world(cx, cz)
                table.insert(path, 1, {x = wx, z = wz})
                local prev = came_from[key(cx, cz)]
                cx, cz = prev.x, prev.z
            end
            return path
        end
        
        for dx = -1, 1 do
            for dz = -1, 1 do
                if not (dx == 0 and dz == 0) then
                    local nx, nz = cur.x + dx, cur.z + dz
                    if not is_blocked(nx, nz) then
                        local cost = (dx ~= 0 and dz ~= 0) and 1.414 or 1.0
                        local tent_g = g_score[key(cur.x, cur.z)] + cost
                        local nk = key(nx, nz)
                        
                        if not g_score[nk] or tent_g < g_score[nk] then
                            came_from[nk] = {x = cur.x, z = cur.z}
                            g_score[nk] = tent_g
                            local h = math.abs(goal_gx - nx) + math.abs(goal_gz - nz)
                            table.insert(open, {x = nx, z = nz, f = tent_g + h, g = tent_g})
                        end
                    end
                end
            end
        end
    end
    
    return nil
end

-- Keys - Using W/A/D
local function set_key(key, down)
    windower.send_command('setkey ' .. key .. ' ' .. (down and 'down' or 'up'))
end

local function stop_movement()
    set_key('w', false)      -- Forward
    set_key('a', false)      -- Left
    set_key('d', false)      -- Right
    state.active = false
end

-- Stuck check - SIMPLIFIED
local function check_stuck(pos)
    local now = os.clock()
    
    if stuck_state.gave_up then
        return 'gave_up'
    end
    
    if not stuck_state.last_pos then
        stuck_state.last_pos = pos
        stuck_state.last_check = now
        return false
    end
    
    if now - stuck_state.last_check < config.stuck_check_interval then
        return false
    end
    
    local moved = distance(stuck_state.last_pos, pos)
    
    if moved < config.stuck_distance then
        stuck_state.attempts = stuck_state.attempts + 1
        
        if stuck_state.attempts >= config.max_attempts then
            windower.add_to_chat(167, '[Nav] Path blocked - giving up')
            windower.add_to_chat(200, '[Nav] Try: //nav clear, then move manually')
            stuck_state.gave_up = true
            return 'gave_up'
        end
        
        windower.add_to_chat(167, string.format('[Nav] Slow progress (%.1fm) - Rerouting %d/%d', 
            moved, stuck_state.attempts, config.max_attempts))
        
        -- Mark ahead
        local player = get_player()
        if player then
            for i = 1, 3 do
                local ax = pos.x + math.sin(player.facing) * config.grid_size * i
                local az = pos.z + math.cos(player.facing) * config.grid_size * i
                local gx, gz = world_to_grid(ax, az)
                mark_blocked(gx, gz)
            end
        end
        
        stuck_state.last_pos = pos
        stuck_state.last_check = now
        return 'reroute'
    end
    
    -- Good progress
    stuck_state.last_pos = pos
    stuck_state.last_check = now
    stuck_state.attempts = 0
    return false
end

-- Navigation update - AGGRESSIVE MOVEMENT
local function update_nav()
    if not state.active then return end
    
    local player = get_player()
    if not player then
        stop_movement()
        return
    end
    
    local pos = {x = player.x, y = player.y, z = player.z}
    
    -- Stuck check
    local stuck = check_stuck(pos)
    if stuck == 'gave_up' then
        stop_movement()
        return
    elseif stuck == 'reroute' then
        set_key('numpad8', false)
        set_key('numpad4', false)
        set_key('numpad6', false)
        
        -- Recalculate
        if state.mode == 'pathfind' then
            local new_path = find_path(pos.x, pos.z, state.target.x, state.target.z)
            if new_path then
                table.insert(new_path, {x = state.target.x, z = state.target.z})
                state.path = new_path
                state.current_step = 1
                windower.add_to_chat(200, string.format('[Nav] New route: %d waypoints', #new_path))
            else
                stop_movement()
                return
            end
        else
            -- Direct mode - try simple sidestep
            local sidestep_angle = player.facing + (math.random() > 0.5 and 1.5 or -1.5)
            local sx = pos.x + math.sin(sidestep_angle) * 5
            local sz = pos.z + math.cos(sidestep_angle) * 5
            state.path = {{x = sx, z = sz}, {x = state.target.x, z = state.target.z}}
            state.current_step = 1
        end
        return
    end
    
    -- Get waypoint
    local wp = state.path[state.current_step]
    if not wp then
        local msg = state.target_name and 
            string.format('[Nav] Reached %s!', state.target_name) or '[Nav] Arrived!'
        windower.add_to_chat(158, msg)
        stop_movement()
        return
    end
    
    local dist = distance(pos, {x = wp.x, y = pos.y, z = wp.z})
    
    -- Next waypoint
    if dist < config.arrival_distance then
        state.current_step = state.current_step + 1
        if state.current_step <= #state.path and state.target_name then
            windower.add_to_chat(200, string.format('[Nav] → %s (%d/%d)', 
                state.target_name, state.current_step - 1, #state.path))
        end
        return
    end
    
    -- Movement - AGGRESSIVE
    local dx = wp.x - pos.x
    local dz = wp.z - pos.z
    local target_angle = math.atan2(dx, dz)
    local turn = normalize_angle(target_angle - player.facing)
    
    -- ALWAYS move forward unless angle is VERY wrong
    if math.abs(turn) < config.max_turn_threshold then
        set_key('w', true)  -- GO FORWARD (W key)
    else
        set_key('w', false)  -- Stop only if > 68 degrees off
    end
    
    -- Turn gently while moving
    if turn > config.turn_threshold then
        set_key('a', true)   -- Turn left (A key)
        set_key('d', false)
    elseif turn < -config.turn_threshold then
        set_key('d', true)   -- Turn right (D key)
        set_key('a', false)
    else
        set_key('a', false)
        set_key('d', false)
    end
end

-- Start navigation
local function start_nav(x, y, z, name)
    local player = get_player()
    if not player then return false end
    
    local dist = distance({x = player.x, z = player.z}, {x = x, z = z})
    local desc = name or string.format('(%.0f, %.0f, %.0f)', x, y, z)
    
    windower.add_to_chat(158, string.format('[Nav] → %s (%.0fm)', desc, dist))
    
    local path
    if dist < config.pathfind_distance then
        state.mode = 'direct'
        path = {{x = x, z = z}}
    else
        state.mode = 'pathfind'
        windower.add_to_chat(200, '[Nav] Pathfinding...')
        path = find_path(player.x, player.z, x, z)
        if not path then
            windower.add_to_chat(167, '[Nav] No path')
            return false
        end
        table.insert(path, {x = x, z = z})
        windower.add_to_chat(158, string.format('[Nav] Path: %d waypoints', #path))
    end
    
    set_key('numpad8', false)
    set_key('numpad4', false)
    set_key('numpad6', false)
    
    state.path = path
    state.current_step = 1
    state.target = {x = x, y = y, z = z}
    state.target_name = name
    state.active = true
    state.last_update = 0
    
    stuck_state.last_pos = nil
    stuck_state.last_check = 0
    stuck_state.attempts = 0
    stuck_state.gave_up = false
    
    return true
end

-- Main loop
windower.register_event('prerender', function()
    if not state.active then return end
    
    local now = os.clock()
    if now - state.last_update >= config.update_interval then
        update_nav()
        state.last_update = now
    end
end)

windower.register_event('unload', function()
    stop_movement()
end)

-- Intercept server coords
windower.register_event('incoming text', function(original)
    if not original then return end
    
    local name, x, y, z = original:match('NAVTO_COORDS:([^:]+):([^:]+):([^:]+):([^:]+)')
    if name and x and y and z then
        x, y, z = tonumber(x), tonumber(y), tonumber(z)
        if x and y and z then
            coroutine.schedule(function()
                start_nav(x, y, z, name)
            end, 0.3)
        end
        return true
    end
end)

-- Commands
windower.register_event('addon command', function(...)
    local args = {...}
    
    if #args == 0 then
        windower.add_to_chat(158, '[Nav] AutoNav v5.0 - Aggressive Movement')
        windower.add_to_chat(200, '  //nav X Y Z - Navigate')
        windower.add_to_chat(200, '  //nav stop - Stop')
        windower.add_to_chat(200, '  //nav clear - Clear obstacles')
        windower.add_to_chat(200, '  !navto npc <name|ID> - Server search')
        windower.add_to_chat(200, '  !navto mob <name|ID> - Server search')
        return
    end
    
    local cmd = args[1]:lower()
    
    if cmd == 'stop' then
        stop_movement()
        windower.add_to_chat(158, '[Nav] Stopped')
        return
    end
    
    if cmd == 'clear' then
        obstacle_grid = {}
        stuck_state.gave_up = false
        windower.add_to_chat(158, '[Nav] Reset')
        return
    end
    
    -- Coords
    local x, y, z = tonumber(args[1]), tonumber(args[2]), tonumber(args[3])
    if x and y and z then
        start_nav(x, y, z)
    else
        windower.add_to_chat(167, '[Nav] Invalid command')
    end
end)

windower.add_to_chat(158, '[AutoNav] v5.0 - Aggressive Forward Movement (WASD)')
windower.add_to_chat(200, '[Nav] Using W/A/D keys for movement')

[eyes-and-brain]

Integrating a navigation system using the LandSandBoat server-side NavMesh. Please note that this is a work-in-progress, as the character still frequently gets stuck on obstacles.

Key Changes:

• Server-Side Pathfinding: Added navto.lua to utilize the server's zone:findPath for route generation.
• Improved Movement Logic: Updated autonav.lua with more aggressive forward movement using W/A/D keys and lenient turning thresholds.
• Communication Protocol: Implemented a system to parse NAVTO_PATH (waypoint list) and NAVTO_COORDS (direct coordinates) sent from the server to initiate movement.

Current Issues:

• Stuck Detection: The character still gets stuck on specific terrain or small objects.
• Rerouting: Need to improve the reliability of the rerouting logic after a collision is detected.

navto.lua

-----------------------------------
-- func: navto <type> <name_or_id>
-- desc: Navigate to NPC or Mob using existing NavMesh system
--
-- Usage:
--   !navto npc Moogle
--   !navto mob Goblin
-----------------------------------

---@type TCommand
local commandObj = {}

commandObj.cmdprops =
{
    permission = 0,
    parameters = 'ss'
}

-- Query NPC position from zone
local function getNPCPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    
    local npcId = tonumber(searchTerm)
    
    if npcId then
        local npc = GetNPCByID(npcId)
        if npc and npc:getZoneID() == zone:getID() then
            table.insert(results, {
                id = npc:getID(),
                name = npc:getName(),
                x = npc:getXPos(),
                y = npc:getYPos(),
                z = npc:getZPos(),
            })
        end
    else
        for _, npc in pairs(zone:getNPCs()) do
            if npc and npc:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {
                    id = npc:getID(),
                    name = npc:getName(),
                    x = npc:getXPos(),
                    y = npc:getYPos(),
                    z = npc:getZPos(),
                })
                
                if #results >= 10 then
                    break
                end
            end
        end
    end
    
    return results
end

-- Query Mob spawn position from zone
local function getMobPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    
    local mobId = tonumber(searchTerm)
    
    if mobId then
        local mob = GetMobByID(mobId)
        if mob and mob:getZoneID() == zone:getID() then
            table.insert(results, {
                id = mob:getID(),
                name = mob:getName(),
                x = mob:getXPos(),
                y = mob:getYPos(),
                z = mob:getZPos(),
            })
        end
    else
        for _, mob in pairs(zone:getMobs()) do
            if mob and mob:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {
                    id = mob:getID(),
                    name = mob:getName(),
                    x = mob:getXPos(),
                    y = mob:getYPos(),
                    z = mob:getZPos(),
                })
                
                if #results >= 10 then
                    break
                end
            end
        end
    end
    
    return results
end

commandObj.onTrigger = function(player, entityType, searchTerm)
    if not entityType or not searchTerm then
        player:printToPlayer('Usage: !navto <npc|mob> <name or ID>', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('Examples:', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('  !navto npc Moogle', xi.msg.channel.SYSTEM_3)
        player:printToPlayer('  !navto mob Goblin', xi.msg.channel.SYSTEM_3)
        return
    end
    
    entityType = entityType:lower()
    
    local results
    if entityType == 'npc' then
        results = getNPCPosition(player, searchTerm)
    elseif entityType == 'mob' then
        results = getMobPosition(player, searchTerm)
    else
        player:printToPlayer('Invalid type. Use "npc" or "mob"', xi.msg.channel.SYSTEM_3)
        return
    end
    
    if not results or #results == 0 then
        player:printToPlayer(string.format('No %s found matching: %s', entityType, searchTerm), xi.msg.channel.SYSTEM_3)
        return
    end
    
    if #results == 1 then
        -- Single result - use existing NavMesh for pathfinding
        local target = results[1]
        local zone = player:getZone()
        
        player:printToPlayer(string.format('[NavTo] %s: %s', entityType:upper(), target.name), xi.msg.channel.SYSTEM_3)
        player:printToPlayer(string.format('[NavTo] Position: %.2f, %.2f, %.2f', target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
        player:printToPlayer(string.format('[NavTo] ID: %d', target.id), xi.msg.channel.SYSTEM_3)
        
        -- Use zone:findPath() from existing NavMesh system
        local startX = player:getXPos()
        local startY = player:getYPos()
        local startZ = player:getZPos()
        
        local path = zone:findPath(
            startX, startY, startZ,
            target.x, target.y, target.z
        )
        
        if path and #path > 0 then
            player:printToPlayer(string.format('[NavTo] NavMesh path: %d waypoints', #path), xi.msg.channel.SYSTEM_3)
            
            -- Send path to client
            -- Format: name:x1,y1,z1;x2,y2,z2;...
            local pathStr = ''
            for i, point in ipairs(path) do
                pathStr = pathStr .. string.format('%.1f,%.1f,%.1f', point.x, point.y, point.z)
                if i < #path then
                    pathStr = pathStr .. ';'
                end
            end
            
            -- Send full path to Windower
            player:printToPlayer(string.format('NAVTO_PATH:%s:%s', target.name, pathStr), xi.msg.channel.SYSTEM_3)
        else
            -- Fallback to direct coordinates if no NavMesh available
            player:printToPlayer('[NavTo] NavMesh unavailable, using direct path', xi.msg.channel.SYSTEM_3)
            player:printToPlayer(string.format('NAVTO_COORDS:%s:%.2f:%.2f:%.2f', target.name, target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
        end
    else
        -- Multiple results - show list
        player:printToPlayer(string.format('Found %d matches for "%s":', #results, searchTerm), xi.msg.channel.SYSTEM_3)
        for i, target in ipairs(results) do
            player:printToPlayer(string.format('  %d. %s (ID: %d) at (%.0f, %.0f, %.0f)', 
                i, target.name, target.id, target.x, target.y, target.z), xi.msg.channel.SYSTEM_3)
        end
        player:printToPlayer('Use ID to select specific target: !navto npc <ID>', xi.msg.channel.SYSTEM_3)
    end
end

return commandObj

autonav.lua:

--[[
    AutoNav - Aggressive Movement Version
    
    Key changes:
    - Always move forward unless turn is VERY large
    - Much more lenient turning threshold
    - Simplified stuck detection
    - Larger waypoint arrival distance
]]

_addon.name = 'AutoNav'
_addon.version = '5.0'
_addon.commands = {'nav'}

local state = {
    active = false,
    path = {},
    current_step = 1,
    last_update = 0,
    target = nil,
    target_name = nil,
    mode = 'direct',
}

local config = {
    update_interval = 0.2,           -- Slower updates
    arrival_distance = 4.0,          -- Much larger - don't be picky
    turn_threshold = 0.5,            -- 28 degrees - very lenient
    max_turn_threshold = 1.2,        -- 68 degrees - stop forward only if VERY wrong
    grid_size = 8.0,                 -- Larger grid
    pathfind_distance = 30.0,
    stuck_check_interval = 8.0,      -- Check every 8 seconds
    stuck_distance = 2.0,            -- Must move 2m in 8s
    max_attempts = 3,
}

local obstacle_grid = {}
local stuck_state = {
    last_pos = nil,
    last_check = 0,
    attempts = 0,
    gave_up = false,
}

-- Utilities
local function get_player()
    return windower.ffxi.get_mob_by_target('me')
end

local function distance(p1, p2)
    local dx = p2.x - p1.x
    local dz = p2.z - p1.z
    return math.sqrt(dx * dx + dz * dz)
end

local function normalize_angle(angle)
    while angle > math.pi do angle = angle - 2 * math.pi end
    while angle < -math.pi do angle = angle + 2 * math.pi end
    return angle
end

-- Grid
local function world_to_grid(x, z)
    return math.floor(x / config.grid_size), math.floor(z / config.grid_size)
end

local function grid_to_world(gx, gz)
    return gx * config.grid_size + config.grid_size / 2, 
           gz * config.grid_size + config.grid_size / 2
end

local function is_blocked(gx, gz)
    return obstacle_grid[gx] and obstacle_grid[gx][gz]
end

local function mark_blocked(gx, gz)
    obstacle_grid[gx] = obstacle_grid[gx] or {}
    obstacle_grid[gx][gz] = true
end

-- A* (simplified)
local function find_path(start_x, start_z, goal_x, goal_z)
    local start_gx, start_gz = world_to_grid(start_x, start_z)
    local goal_gx, goal_gz = world_to_grid(goal_x, goal_z)
    
    if start_gx == goal_gx and start_gz == goal_gz then
        return {{x = goal_x, z = goal_z}}
    end
    
    local open = {{x = start_gx, z = start_gz, f = 0, g = 0}}
    local came_from = {}
    local g_score = {}
    local key = function(x, z) return x .. ',' .. z end
    
    g_score[key(start_gx, start_gz)] = 0
    
    local iter = 0
    while #open > 0 and iter < 300 do
        iter = iter + 1
        table.sort(open, function(a, b) return a.f < b.f end)
        local cur = table.remove(open, 1)
        
        if cur.x == goal_gx and cur.z == goal_gz then
            local path = {}
            local cx, cz = goal_gx, goal_gz
            while came_from[key(cx, cz)] do
                local wx, wz = grid_to_world(cx, cz)
                table.insert(path, 1, {x = wx, z = wz})
                local prev = came_from[key(cx, cz)]
                cx, cz = prev.x, prev.z
            end
            return path
        end
        
        for dx = -1, 1 do
            for dz = -1, 1 do
                if not (dx == 0 and dz == 0) then
                    local nx, nz = cur.x + dx, cur.z + dz
                    if not is_blocked(nx, nz) then
                        local cost = (dx ~= 0 and dz ~= 0) and 1.414 or 1.0
                        local tent_g = g_score[key(cur.x, cur.z)] + cost
                        local nk = key(nx, nz)
                        
                        if not g_score[nk] or tent_g < g_score[nk] then
                            came_from[nk] = {x = cur.x, z = cur.z}
                            g_score[nk] = tent_g
                            local h = math.abs(goal_gx - nx) + math.abs(goal_gz - nz)
                            table.insert(open, {x = nx, z = nz, f = tent_g + h, g = tent_g})
                        end
                    end
                end
            end
        end
    end
    
    return nil
end

-- Keys - Using W/A/D
local function set_key(key, down)
    windower.send_command('setkey ' .. key .. ' ' .. (down and 'down' or 'up'))
end

local function stop_movement()
    set_key('w', false)      -- Forward
    set_key('a', false)      -- Left
    set_key('d', false)      -- Right
    state.active = false
end

-- Stuck check - SIMPLIFIED
local function check_stuck(pos)
    local now = os.clock()
    
    if stuck_state.gave_up then
        return 'gave_up'
    end
    
    if not stuck_state.last_pos then
        stuck_state.last_pos = pos
        stuck_state.last_check = now
        return false
    end
    
    if now - stuck_state.last_check < config.stuck_check_interval then
        return false
    end
    
    local moved = distance(stuck_state.last_pos, pos)
    
    if moved < config.stuck_distance then
        stuck_state.attempts = stuck_state.attempts + 1
        
        if stuck_state.attempts >= config.max_attempts then
            windower.add_to_chat(167, '[Nav] Path blocked - giving up')
            windower.add_to_chat(200, '[Nav] Try: //nav clear, then move manually')
            stuck_state.gave_up = true
            return 'gave_up'
        end
        
        windower.add_to_chat(167, string.format('[Nav] Slow progress (%.1fm) - Rerouting %d/%d', 
            moved, stuck_state.attempts, config.max_attempts))
        
        -- Mark ahead
        local player = get_player()
        if player then
            for i = 1, 3 do
                local ax = pos.x + math.sin(player.facing) * config.grid_size * i
                local az = pos.z + math.cos(player.facing) * config.grid_size * i
                local gx, gz = world_to_grid(ax, az)
                mark_blocked(gx, gz)
            end
        end
        
        stuck_state.last_pos = pos
        stuck_state.last_check = now
        return 'reroute'
    end
    
    -- Good progress
    stuck_state.last_pos = pos
    stuck_state.last_check = now
    stuck_state.attempts = 0
    return false
end

-- Navigation update - AGGRESSIVE MOVEMENT
local function update_nav()
    if not state.active then return end
    
    local player = get_player()
    if not player then
        stop_movement()
        return
    end
    
    local pos = {x = player.x, y = player.y, z = player.z}
    
    -- Stuck check
    local stuck = check_stuck(pos)
    if stuck == 'gave_up' then
        stop_movement()
        return
    elseif stuck == 'reroute' then
        set_key('numpad8', false)
        set_key('numpad4', false)
        set_key('numpad6', false)
        
        -- Recalculate
        if state.mode == 'pathfind' then
            local new_path = find_path(pos.x, pos.z, state.target.x, state.target.z)
            if new_path then
                table.insert(new_path, {x = state.target.x, z = state.target.z})
                state.path = new_path
                state.current_step = 1
                windower.add_to_chat(200, string.format('[Nav] New route: %d waypoints', #new_path))
            else
                stop_movement()
                return
            end
        else
            -- Direct mode - try simple sidestep
            local sidestep_angle = player.facing + (math.random() > 0.5 and 1.5 or -1.5)
            local sx = pos.x + math.sin(sidestep_angle) * 5
            local sz = pos.z + math.cos(sidestep_angle) * 5
            state.path = {{x = sx, z = sz}, {x = state.target.x, z = state.target.z}}
            state.current_step = 1
        end
        return
    end
    
    -- Get waypoint
    local wp = state.path[state.current_step]
    if not wp then
        local msg = state.target_name and 
            string.format('[Nav] Reached %s!', state.target_name) or '[Nav] Arrived!'
        windower.add_to_chat(158, msg)
        stop_movement()
        return
    end
    
    local dist = distance(pos, {x = wp.x, y = pos.y, z = wp.z})
    
    -- Next waypoint
    if dist < config.arrival_distance then
        state.current_step = state.current_step + 1
        if state.current_step <= #state.path and state.target_name then
            windower.add_to_chat(200, string.format('[Nav] → %s (%d/%d)', 
                state.target_name, state.current_step - 1, #state.path))
        end
        return
    end
    
    -- Movement - AGGRESSIVE
    local dx = wp.x - pos.x
    local dz = wp.z - pos.z
    local target_angle = math.atan2(dx, dz)
    local turn = normalize_angle(target_angle - player.facing)
    
    -- ALWAYS move forward unless angle is VERY wrong
    if math.abs(turn) < config.max_turn_threshold then
        set_key('w', true)  -- GO FORWARD (W key)
    else
        set_key('w', false)  -- Stop only if > 68 degrees off
    end
    
    -- Turn gently while moving
    if turn > config.turn_threshold then
        set_key('a', true)   -- Turn left (A key)
        set_key('d', false)
    elseif turn < -config.turn_threshold then
        set_key('d', true)   -- Turn right (D key)
        set_key('a', false)
    else
        set_key('a', false)
        set_key('d', false)
    end
end

-- Start navigation
local function start_nav(x, y, z, name)
    local player = get_player()
    if not player then return false end
    
    local dist = distance({x = player.x, z = player.z}, {x = x, z = z})
    local desc = name or string.format('(%.0f, %.0f, %.0f)', x, y, z)
    
    windower.add_to_chat(158, string.format('[Nav] → %s (%.0fm)', desc, dist))
    
    local path
    if dist < config.pathfind_distance then
        state.mode = 'direct'
        path = {{x = x, z = z}}
    else
        state.mode = 'pathfind'
        windower.add_to_chat(200, '[Nav] Pathfinding...')
        path = find_path(player.x, player.z, x, z)
        if not path then
            windower.add_to_chat(167, '[Nav] No path')
            return false
        end
        table.insert(path, {x = x, z = z})
        windower.add_to_chat(158, string.format('[Nav] Path: %d waypoints', #path))
    end
    
    set_key('numpad8', false)
    set_key('numpad4', false)
    set_key('numpad6', false)
    
    state.path = path
    state.current_step = 1
    state.target = {x = x, y = y, z = z}
    state.target_name = name
    state.active = true
    state.last_update = 0
    
    stuck_state.last_pos = nil
    stuck_state.last_check = 0
    stuck_state.attempts = 0
    stuck_state.gave_up = false
    
    return true
end

-- Main loop
windower.register_event('prerender', function()
    if not state.active then return end
    
    local now = os.clock()
    if now - state.last_update >= config.update_interval then
        update_nav()
        state.last_update = now
    end
end)

windower.register_event('unload', function()
    stop_movement()
end)

-- Intercept server messages for navigation
windower.register_event('incoming text', function(original)
    if not original then return end
    
    -- Check for NAVTO_PATH (full NavMesh path)
    local name, pathStr = original:match('NAVTO_PATH:([^:]+):(.+)')
    if name and pathStr then
        windower.add_to_chat(158, string.format('[Nav] Received NavMesh path for %s', name))
        
        -- Parse waypoints: "x1,y1,z1;x2,y2,z2;..."
        local waypoints = {}
        for wp in pathStr:gmatch('[^;]+') do
            local x, y, z = wp:match('([^,]+),([^,]+),([^,]+)')
            if x and y and z then
                table.insert(waypoints, {
                    x = tonumber(x),
                    y = tonumber(y),
                    z = tonumber(z)
                })
            end
        end
        
        if #waypoints > 0 then
            windower.add_to_chat(200, string.format('[Nav] Using NavMesh: %d waypoints', #waypoints))
            
            -- Convert to path format
            coroutine.schedule(function()
                state.path = waypoints
                state.current_step = 1
                state.target = waypoints[#waypoints]
                state.target_name = name
                state.active = true
                state.last_update = 0
                
                stuck_state.last_pos = nil
                stuck_state.last_check = 0
                stuck_state.attempts = 0
                stuck_state.gave_up = false
            end, 0.3)
        end
        
        return true
    end
    
    -- Check for NAVTO_COORDS (fallback direct path)
    local name2, x, y, z = original:match('NAVTO_COORDS:([^:]+):([^:]+):([^:]+):([^:]+)')
    if name2 and x and y and z then
        x, y, z = tonumber(x), tonumber(y), tonumber(z)
        if x and y and z then
            windower.add_to_chat(158, string.format('[Nav] Direct path to %s', name2))
            
            coroutine.schedule(function()
                start_nav(x, y, z, name2)
            end, 0.3)
        end
        return true
    end
end)

-- Commands
windower.register_event('addon command', function(...)
    local args = {...}
    
    if #args == 0 then
        windower.add_to_chat(158, '[Nav] AutoNav v5.0 - Aggressive Movement')
        windower.add_to_chat(200, '  //nav X Y Z - Navigate')
        windower.add_to_chat(200, '  //nav stop - Stop')
        windower.add_to_chat(200, '  //nav clear - Clear obstacles')
        windower.add_to_chat(200, '  !navto npc <name|ID> - Server search')
        windower.add_to_chat(200, '  !navto mob <name|ID> - Server search')
        return
    end
    
    local cmd = args[1]:lower()
    
    if cmd == 'stop' then
        stop_movement()
        windower.add_to_chat(158, '[Nav] Stopped')
        return
    end
    
    if cmd == 'clear' then
        obstacle_grid = {}
        stuck_state.gave_up = false
        windower.add_to_chat(158, '[Nav] Reset')
        return
    end
    
    -- Coords
    local x, y, z = tonumber(args[1]), tonumber(args[2]), tonumber(args[3])
    if x and y and z then
        start_nav(x, y, z)
    else
        windower.add_to_chat(167, '[Nav] Invalid command')
    end
end)

windower.add_to_chat(158, '[AutoNav] v5.0 - Aggressive Forward Movement (WASD)')
windower.add_to_chat(200, '[Nav] Using W/A/D keys for movement')

[eyes-and-brain]

[Update] NPC Navigation System is Nearly Complete (Full NavMesh Integration & Stop-Fix Implemented)

I've been working on an NPC navigation system and have now reached a near-complete, highly functional version. I managed to overcome previous bottlenecks regarding collision recovery and WASD oscillation.

Key Improvements:

• Full NavMesh Integration: It now fully utilizes the server-side zone:findPath, allowing for highly accurate routing.
• Long-Distance Stability: Implemented a segment-based fetching system, enabling stable navigation across entire zones.
• Precise Arrival Logic: Fixed the issue where the character would "overshoot" or run past the target NPC. It now stops exactly at the destination.
• File-Based Sync: Transitioned from chat-log parsing to a .dat file sync method between the server and client to bypass string length limits and ensure reliability.

I have maintained the "Aggressive Forward Momentum" philosophy (keeping the W-key down as much as possible). I'm sharing the latest source code below.

Please feel free to test it in your environment! If you have any ideas to make this even better, feel free to modify the code and share your improvements in the replies. I’m especially interested in more efficient turning logic or smarter collision recovery. Let's make FFXI navigation better together!

⚠️ IMPORTANT: Configuration Required

Before using these scripts, you must update the file path in both the server-side and client-side scripts to match your own environment. Look for the PATH_CONFIG section at the top of the code.

How to Use

1. Search and Navigate (Server Command)
Use the !navto command to find a target and start moving.

!navto npc <name>   -- Example: !navto npc Moogle
!navto mob <name>   -- Example: !navto mob Rabbit
!navto npc <ID>     -- Example: !navto npc 17723579

2. Stop Navigation (Addon Command)

//nav stop          -- Emergency stop and release all keys

1. Server-side (scripts/commands/navto.lua)

-----------------------------------
-- func: navto <type> <name_or_id>
-- desc: Navigate to NPC or Mob using NavMesh
-----------------------------------
local commandObj = {}

-- [PATH_CONFIG] UPDATE THIS TO YOUR SERVER PATH
local PATH_FILE = 'C:/game/PC/FF11/server/navmeshes/autonav_path.dat'

commandObj.cmdprops = {
    permission = 0,
    parameters = 'ss'
}

-- Query NPC position from zone
local function getNPCPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    local npcId = tonumber(searchTerm)
    if npcId then
        local npc = GetNPCByID(npcId)
        if npc and npc:getZoneID() == zone:getID() then
            table.insert(results, {id = npc:getID(), name = npc:getName(), x = npc:getXPos(), y = npc:getYPos(), z = npc:getZPos()})
        end
    else
        for _, npc in pairs(zone:getNPCs()) do
            if npc and npc:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {id = npc:getID(), name = npc:getName(), x = npc:getXPos(), y = npc:getYPos(), z = npc:getZPos()})
                if #results >= 10 then break end
            end
        end
    end
    return results
end

-- Query Mob spawn position from zone
local function getMobPosition(player, searchTerm)
    local zone = player:getZone()
    local results = {}
    local mobId = tonumber(searchTerm)
    if mobId then
        local mob = GetMobByID(mobId)
        if mob and mob:getZoneID() == zone:getID() then
            table.insert(results, {id = mob:getID(), name = mob:getName(), x = mob:getXPos(), y = mob:getYPos(), z = mob:getZPos()})
        end
    else
        for _, mob in pairs(zone:getMobs()) do
            if mob and mob:getName():lower():find(searchTerm:lower(), 1, true) then
                table.insert(results, {id = mob:getID(), name = mob:getName(), x = mob:getXPos(), y = mob:getYPos(), z = mob:getZPos()})
                if #results >= 10 then break end
            end
        end
    end
    return results
end

commandObj.onTrigger = function(player, entityType, searchTerm)
    if not entityType or not searchTerm then return end
    entityType = entityType:lower()
    local results = (entityType == 'npc') and getNPCPosition(player, searchTerm) or getMobPosition(player, searchTerm)
    
    if not results or #results == 0 then return end
        local zone = player:getZone()
    
    if #results == 1 then
        local target = results[1]
        local startX, startY, startZ = player:getXPos(), player:getYPos(), player:getZPos()
        
        -- Get path via server's NavMesh
        local path = zone:findPath(startX, startY, startZ, target.x, target.y, target.z)
        
        if path and type(path) == 'table' and #path > 0 then
            local pathStr = ''
            for i, point in ipairs(path) do
                pathStr = pathStr .. string.format('%.1f,%.1f,%.1f', point.x, point.y, point.z)
                if i < #path then pathStr = pathStr .. ';' end
            end
            
            -- Save path to file (Use the path defined in PATH_CONFIG)
            local f = io.open(PATH_FILE, 'w')
            if f then
                f:write(string.format('TARGET:%s\nPOINTS:%d\n%s', target.name, #path, pathStr:gsub(';', '\n')))
                f:close()
            end
            player:printToPlayer(string.format('[NavTo] %s: %s (Path Saved)', entityType:upper(), target.name), xi.msg.channel.SYSTEM_3)
            player:printToPlayer('NAVTO_FILE_READY', xi.msg.channel.SYSTEM_3)
        end
    end
end

return commandObj

2. Client-side Addon (addons/AutoNav/autonav.lua)

--[[
    AutoNav v16.49 - Aggressive Movement with Precise Stop Fix
]]
_addon.name = 'AutoNav'
_addon.version = '16.49'
_addon.commands = {'nav'}

-- [PATH_CONFIG] UPDATE THIS TO MATCH YOUR SERVER'S DATA PATH
local PATH_FILE = 'C:/game/PC/FF11/server/navmeshes/autonav_path.dat'

local config = {
    update_interval = 0.1,
    arrival_distance = 2.0,   
    max_altitude_diff = 1.8,  
    pivot_threshold = 2.6, 
    deadzone = 0.15,
    retry_delay = 5.0,
}

local state = {
    active = false, path = {}, current_step = 1,
    pivoting = false, fetching = false,
    last_update = 0, target_name = "", last_retry_time = 0
}

-- Reset all movement keys and state
local function hard_stop(reason)
    state.active = false
    state.path = {}
    windower.send_command('setkey w up; setkey s up; setkey a up; setkey d up; setkey j up; setkey l up')
    if reason then windower.add_to_chat(200, '[AutoNav] ' .. reason) end
end

-- Load path coordinates from the .dat file
local function load_path_from_file()
    local f = io.open(PATH_FILE, 'r')
    if not f then return nil end
    local new_path = {}
    for line in f:lines() do
        if not line:find('TARGET') and not line:find('POINTS') then
            local coords = {}
            for val in line:gmatch("([^,]+)") do table.insert(coords, tonumber(val)) end
            if #coords >= 3 then table.insert(new_path, {x = coords[1], z = coords[2], y = coords[3]}) end
        end
    end
    f:close()
    return new_path
end

function update_navigation()
    if not state.active or state.pivoting then return end
    local now = os.clock()
    if now - state.last_update < config.update_interval then return end
    state.last_update = now

    local p = windower.ffxi.get_mob_by_target('me')
    local wp = state.path[state.current_step]
    
    -- If path segment is empty
    if not wp then
        windower.send_command('setkey w up; setkey a up; setkey d up')
        if state.target_name ~= "" and not state.fetching then
            if (now - state.last_retry_time) > config.retry_delay then
                local target_npc = windower.ffxi.get_mob_by_name(state.target_name)
                -- Final destination check
                if target_npc and math.sqrt((target_npc.x - p.x)^2 + (target_npc.y - p.y)^2) < 4.0 then
                    hard_stop('Final Destination Reached.')
                else
                    -- Request next segment from server
                    state.fetching = true
                    state.last_retry_time = now
                    windower.send_command('input /!navto npc '..state.target_name)
                end
            end
        end
        return 
    end

    local dx, dy = wp.x - p.x, wp.y - p.y
    local dist_h = math.sqrt(dx*dx + dy*dy)

    -- Arrival at waypoint
    if dist_h < config.arrival_distance and math.abs(wp.z - p.z) < config.max_altitude_diff then
        if state.current_step < #state.path then
            state.current_step = state.current_step + 1
        else
            -- Ensure full stop at the end of path
            windower.send_command('setkey w up; setkey a up; setkey d up')
            state.path = {} 
            return
        end
    end

    -- Angle and steering logic
    local target = math.atan2(-dy, dx)
    local turn = target - p.facing
    while turn > math.pi do turn = turn - 2 * math.pi end
    while turn < -math.pi do turn = turn + 2 * math.pi end

    -- Sharp turn handling (Stationary Pivot)
    if math.abs(turn) > config.pivot_threshold then
        state.pivoting = true
        local cam_key = turn > 0 and 'l' or 'j'
        windower.send_command('setkey w up; setkey s up; setkey a up; setkey d up; setkey '..cam_key..' down')
        coroutine.schedule(function()
            windower.send_command('setkey '..cam_key..' up')
            coroutine.schedule(function()
                windower.send_command('setkey s down')
                coroutine.schedule(function()
                    windower.send_command('setkey s up; setkey w down')
                    coroutine.schedule(function() state.pivoting = false end, 0.2)
                end, 0.15)
            end, 0.2)
        end, 2.0)
        return
    end

    -- Movement execution
    windower.send_command('setkey w down')
    if turn > config.deadzone then windower.send_command('setkey d down; setkey a up')
    elseif turn < -config.deadzone then windower.send_command('setkey a down; setkey d up')
    else windower.send_command('setkey a up; setkey d up') end
end

windower.register_event('incoming text', function(original)
    local t_name = original:match("%[NavTo%] NPC: (.+)")
    if t_name then state.target_name = t_name:lower() end
    if original:find('NAVTO_FILE_READY') then
        coroutine.schedule(function()
            local p = load_path_from_file()
            if p and #p > 0 then
                state.path, state.current_step, state.fetching, state.active = p, 1, false, true
                windower.send_command('setkey w down')
            end
        end, 0.5)
    end
end)

windower.register_event('prerender', update_navigation)
windower.register_event('addon command', function(input)
    if input == 'stop' or input == 'off' then hard_stop('Manual Stop') end
end)

[eyes-and-brain]

[Update] NPC Navigation v16.50 - Smart Door Opener & Packet Interaction

I am excited to share a major update for the NPC navigation system. The new version, v16.50, solves one of the biggest challenges in automated movement: Doors and Gates.

In previous versions, characters would get stuck running against closed doors. v16.50 now interacts with doors automatically using background packet injection, ensuring a seamless journey to your destination.

Key Features

• Packet-Based Auto Door Opening: Uses 0x01A packet injection to interact with doors. This happens "silently" in the background—no target switching, no UI flickering, and no interruption to your movement.
• Intelligent Field-of-View Detection: The system only attempts to open doors within a ~70-degree cone in front of the character to avoid accidental interactions with objects behind you.
• Smart Cooldown Logic: Includes a 10-second per-door cooldown to prevent redundant packet spamming while waiting for door animations.
• Full Integration: Combined with the "Aggressive Forward Momentum" logic and the "Precise Destination Stop" fix from v16.49.

How to Use

1. Configuration: Open autonav.lua and set your server's .dat file path in the PATH_CONFIG section.
2. Execution: Use the standard server-side command: !navto npc <name>.
3. Automatic Interaction: The character will automatically open any detected doors or gates while moving.

---

Source Code (AutoNav v16.50)

--[[
    AutoNav v16.50 - Integrated Smart Door Opener (Packet Method)
]]

_addon.name = 'AutoNav'
_addon.version = '16.50'
_addon.commands = {'nav'}

-- Load packets library
local packets = require('packets')

-- [PATH_CONFIG] UPDATE THIS TO YOUR SERVER PATH
local PATH_FILE = 'C:/game/PC/FF11/server/navmeshes/autonav_path.dat'

local config = {
    update_interval = 0.1,
    arrival_distance = 2.0,   
    max_altitude_diff = 1.8,  
    pivot_threshold = 2.6, 
    deadzone = 0.15,
    camera_hold = 2.0,        
    camera_inertia = 0.2,
    retry_delay = 5.0,
    door_check_dist = 5.0,
}

local state = {
    active = false, path = {}, current_step = 1,
    pivoting = false, fetching = false,
    last_update = 0, target_name = "", last_retry_time = 0
}

local door_state = {
    last_attempt = 0,
    cooldown = 2.5,
    attempted_doors = {},
}

local DOOR_KEYWORDS = {
    'Door', 'door', 'Gate', 'gate', 'Hatch', 'hatch',
    'Portal', 'portal', 'Entrance', 'entrance',
    '扉', 'ゲート', 'Iron', 'Metal', 'Stone', 'Wood'
}

-- Door Detection Logic
local function is_door(name)
    if not name then return false end
    for _, keyword in ipairs(DOOR_KEYWORDS) do
        if name:find(keyword) then return true end
    end
    return false
end

local function get_nearby_door()
    local p = windower.ffxi.get_mob_by_target('me')
    if not p then return nil end
    local mobs = windower.ffxi.get_mob_array()
    local closest_door = nil
    local min_dist = config.door_check_dist
    for _, mob in pairs(mobs) do
        if mob and mob.valid_target and is_door(mob.name) then
            local dx, dy = mob.x - p.x, mob.y - p.y
            local dist = math.sqrt(dx*dx + dy*dy)
            if dist < min_dist then
                local angle = math.atan2(-dy, dx)
                local angle_diff = math.abs(angle - p.facing)
                while angle_diff > math.pi do angle_diff = angle_diff - 2*math.pi end
                while angle_diff < -math.pi do angle_diff = angle_diff + 2*math.pi end
                if math.abs(angle_diff) < 1.2 then 
                    min_dist = dist
                    closest_door = mob
                end
            end
        end
    end
    return closest_door
end

local function try_open_door(door)
    local now = os.clock()
    if now - door_state.last_attempt < door_state.cooldown then return false end
    if door_state.attempted_doors[door.id] and (now - door_state.attempted_doors[door.id] < 10.0) then
        return false
    end
    door_state.last_attempt = now
    door_state.attempted_doors[door.id] = now
    
    local packet = packets.new('outgoing', 0x01A)
    packet['Target'] = door.id
    packet['Target Index'] = door.index
    packet['Category'] = 0 
    packets.inject(packet)
    
    windower.add_to_chat(209, string.format('[AutoNav] Opening Door: %s (%.1fm)', door.name, math.sqrt((door.x - windower.ffxi.get_mob_by_target('me').x)^2 + (door.y - windower.ffxi.get_mob_by_target('me').y)^2)))
    return true
end

-- Core Navigation Logic
local function hard_stop(reason)
    state.active, state.pivoting, state.fetching = false, false, false
    state.target_name, state.path = "", {}
    windower.send_command('setkey w up; setkey s up; setkey a up; setkey d up; setkey j up; setkey l up')
    if reason then windower.add_to_chat(200, '[AutoNav] ' .. reason) end
end

local function load_path_from_file()
    local f = io.open(PATH_FILE, 'r')
    if not f then return nil end
    local new_path = {}
    for line in f:lines() do
        if not line:find('TARGET') and not line:find('POINTS') then
            local coords = {}
            for val in line:gmatch("([^,]+)") do table.insert(coords, tonumber(val)) end
            if #coords >= 3 then table.insert(new_path, {x = coords[1], z = coords[2], y = coords[3]}) end
        end
    end
    f:close()
    return new_path
end

function update_navigation()
    if not state.active or state.pivoting then return end
    local now = os.clock()
    if now - state.last_update < config.update_interval then return end
    state.last_update = now

    local p = windower.ffxi.get_mob_by_target('me')
    local wp = state.path[state.current_step]
    
    if not wp then
        windower.send_command('setkey w up; setkey a up; setkey d up')
        if state.target_name ~= "" and not state.fetching then
            if (now - state.last_retry_time) > config.retry_delay then
                local target_npc = windower.ffxi.get_mob_by_name(state.target_name)
                if target_npc and math.sqrt((target_npc.x - p.x)^2 + (target_npc.y - p.y)^2) < 4.0 then
                    hard_stop('Final Destination Reached.')
                else
                    state.fetching = true
                    state.last_retry_time = now
                    windower.send_command('input /!navto npc '..state.target_name)
                end
            end
        end
        return 
    end

    -- Door Check
    local door = get_nearby_door()
    if door then try_open_door(door) end

    local dx, dy = wp.x - p.x, wp.y - p.y
    local dist_h = math.sqrt(dx*dx + dy*dy)

    if dist_h < config.arrival_distance and math.abs(wp.z - p.z) < config.max_altitude_diff then
        if state.current_step < #state.path then
            state.current_step = state.current_step + 1
        else
            windower.send_command('setkey w up; setkey a up; setkey d up')
            state.path = {} 
            return
        end
    end

    local target = math.atan2(-dy, dx)
    local turn = target - p.facing
    while turn > math.pi do turn = turn - 2 * math.pi end
    while turn < -math.pi do turn = turn + 2 * math.pi end

    if math.abs(turn) > config.pivot_threshold then
        state.pivoting = true
        local cam_key = turn > 0 and 'l' or 'j'
        windower.send_command('setkey w up; setkey s up; setkey a up; setkey d up; setkey '..cam_key..' down')
        coroutine.schedule(function()
            windower.send_command('setkey '..cam_key..' up')
            coroutine.schedule(function()
                windower.send_command('setkey s down')
                coroutine.schedule(function()
                    windower.send_command('setkey s up; setkey w down')
                    coroutine.schedule(function() state.pivoting = false end, 0.2)
                end, 0.15)
            end, 0.2)
        end, 2.0)
        return
    end

    windower.send_command('setkey w down')
    if turn > config.deadzone then windower.send_command('setkey d down; setkey a up')
    elseif turn < -config.deadzone then windower.send_command('setkey a down; setkey d up')
    else windower.send_command('setkey a up; setkey d up') end
end

-- Events
windower.register_event('incoming text', function(original)
    local t_name = original:match("%[NavTo%] NPC: (.+)")
    if t_name then state.target_name = t_name:lower() end
    if original:find('NAVTO_FILE_READY') then
        coroutine.schedule(function()
            local p = load_path_from_file()
            if p and #p > 0 then
                state.path, state.current_step, state.fetching, state.active = p, 1, false, true
                windower.send_command('setkey w down')
            end
        end, 0.5)
    end
end)

windower.register_event('prerender', function()
    local now = os.clock()
    if not door_state.last_cleanup or now - door_state.last_cleanup > 30 then
        door_state.last_cleanup = now
        for id, time in pairs(door_state.attempted_doors) do
            if now - time > 30 then door_state.attempted_doors[id] = nil end
        end
    end
end)

windower.register_event('prerender', update_navigation)
windower.register_event('addon command', function(input)
    if input == 'stop' or input == 'off' then hard_stop('Manual Stop') end
end)