Method getNearestClearNode

plugins/pathFinder.js:324–363

Find the clear (walkable, zero-cost) node closest to the given world * position. Spirals outward in expanding boxes until a clear node is * found or the search range is exhausted. Useful for snapping a click * or NPC spawn position to the nearest open tile. * * By defaul

(worldPos, searchRange = 10, rebuild = true)

     *  @returns {PathFinderNode|null}
     *  @memberof PathFinding */
    getNearestClearNode(worldPos, searchRange = 10, rebuild = true)
    {
        ASSERT(isVector2(worldPos), 'worldPos must be a Vector2');
        if (rebuild) this.buildNodeData();

        // Inline worldToTile to avoid a Vector2 allocation per call.
        const ox = this.tileLayer ? this.tileLayer.pos.x : 0;
        const oy = this.tileLayer ? this.tileLayer.pos.y : 0;
        const centerX = floor(worldPos.x - ox);
        const centerY = floor(worldPos.y - oy);

        for (let offset = 0; offset <= searchRange; ++offset)
        {
            let nearest = null;
            let nearestDistSq = 0;

            for (let dy = -offset; dy <= offset; ++dy)
            for (let dx = -offset; dx <= offset; ++dx)
            {
                // Only scan the perimeter of the current ring (skip the
                // interior we've already searched in earlier iterations).
                if (offset > 0 && abs(dx) !== offset && abs(dy) !== offset)
                    continue;

                const node = this.getNode(centerX + dx, centerY + dy);
                if (!node || !node.isClear()) continue;

                const ddx = node.posWorld.x - worldPos.x;
                const ddy = node.posWorld.y - worldPos.y;
                const distSq = ddx * ddx + ddy * ddy;
                if (!nearest || distSq < nearestDistSq)
                {
                    nearest = node;
                    nearestDistSq = distSq;
                }
            }
            if (nearest) return nearest;
        }
        return null;
    }

    /** Smooth a node path by removing redundant turns and tightening corners
     *  where a grid-aligned diagonal is clear. Modifies the path in place.