PresentDATA Elements

class Node {
  constructor(x, y, walkable = true) {
    this.x = x
    this.y = y
    this.walkable = walkable
    this.g = Infinity
    this.h = 0
    this.f = Infinity
    this.parent = null
  }
}

class AStar {
  constructor(rows, cols) {
    this.rows = rows
    this.cols = cols
    this.grid = this.createGrid()
  }

  createGrid() {
    const grid = []
    for (let i = 0; i < this.rows; i++) {
      const row = []
      for (let j = 0; j < this.cols; j++) {
        row.push(new Node(j, i))
      }
      grid.push(row)
    }
    return grid
  }

  setWall(x, y) {
    if (this.inBounds(x, y)) this.grid[y][x].walkable = false
  }

  inBounds(x, y) {
    return x >= 0 && y >= 0 && x < this.cols && y < this.rows
  }

  neighbors(node) {
    const dirs = [[1,0], [0,1], [-1,0], [0,-1]]
    const result = []
    for (const [dx, dy] of dirs) {
      const nx = node.x + dx
      const ny = node.y + dy
      if (this.inBounds(nx, ny)) {
        const neighbor = this.grid[ny][nx]
        if (neighbor.walkable) result.push(neighbor)
      }
    }
    return result
  }

  heuristic(a, b) {
    return Math.abs(a.x - b.x) + Math.abs(a.y - b.y)
  }

  findPath(startX, startY, endX, endY) {
    const start = this.grid[startY][startX]
    const end = this.grid[endY][endX]
    start.g = 0
    start.f = this.heuristic(start, end)

    const openSet = [start]
    const closedSet = new Set()

    while (openSet.length > 0) {
      openSet.sort((a, b) => a.f - b.f)
      const current = openSet.shift()
      if (current === end) return this.reconstructPath(current)

      closedSet.add(current)
      for (const neighbor of this.neighbors(current)) {
        if (closedSet.has(neighbor)) continue

        const tentativeG = current.g + 1
        if (tentativeG < neighbor.g) {
          neighbor.parent = current
          neighbor.g = tentativeG
          neighbor.h = this.heuristic(neighbor, end)
          neighbor.f = neighbor.g + neighbor.h
          if (!openSet.includes(neighbor)) openSet.push(neighbor)
        }
      }
    }

    return null // No path
  }

  reconstructPath(endNode) {
    const path = []
    let current = endNode
    while (current) {
      path.push([current.x, current.y])
      current = current.parent
    }
    return path.reverse()
  }
}

// Example usage
const astar = new AStar(10, 10)
astar.setWall(2, 2)
astar.setWall(2, 3)
astar.setWall(2, 4)

const path = astar.findPath(0, 0, 9, 9)
console.log('Path:', path)