sketch.js

var cols, rows;
var w = 20;

var grid = [];

var currentCell;

var stack = [];

var openSet = [];
var closedSet = [];

var start;
var end;
var path = [];

var solving = false;

var frameNbr = 0;

// Get cell(i,j) index
function index(i, j) {
  if (i < 0 || j < 0 || i > cols - 1 || j > rows - 1) {
    return -1;
  }
  return i + j * cols;
}

// Remove cell walls
function removeWalls(a, b) {

  var x = a.i - b.i;
  var y = a.j - b.j;

  if (x === 1) {
    a.walls[3] = false;
    b.walls[1] = false;
  } else if (x === -1) {
    a.walls[1] = false;
    b.walls[3] = false;
  } else if (y === 1) {
    a.walls[0] = false;
    b.walls[2] = false;
  } else if (y === -1) {
    a.walls[2] = false;
    b.walls[0] = false;
  }
}

// Remove object from array
function removeFromArray(arr, elt) {
  for (var i = arr.length - 1; i >= 0; i--) {
    if (arr[i] == elt) {
      arr.splice(i, 1);
    }
  }
}

// Calculate heuristic between a and b object
function heuristic(a, b) {
  // var d = dist(a.i, a.j, b.i, b.j);
  var d = abs(a.i - b.i) + abs(a.j - b.j);
  return d;
}


function setup() {
  createCanvas(600, 600);

  cols = floor(width / w);
  rows = floor(height / w);

  for (var j = 0; j < rows; j++) {
    for (var i = 0; i < cols; i++) {
      var cell = new Cell(i, j);
      grid.push(cell);
    }
  }
  currentCell = grid[0];

  console.log(currentCell);
}


function draw() {
  background(51);

  for (var i = 0; i < grid.length; i++) {
    grid[i].show();
  }

  frameNbr++;
  console.log(frameNbr);
  console.log(solving);
  console.log(currentCell);

  if (solving) {
    if(openSet.length > 0) {

      var winner = 0;
      for (var i = 0; i < openSet.length; i++) {
        if(openSet[i].f < openSet[winner].f){
          winner = i;
        }
      }

      var currentCell = openSet[winner];

      if(currentCell === end) {
        noLoop();
        console.log("DONE");
      }

      removeFromArray(openSet, currentCell);
      closedSet.push(currentCell);

      var neighbors = currentCell.getNeighbors();

      for (var i = 0; i < neighbors.length; i++) {
        var neighbor = neighbors[i];
        if (!closedSet.includes(neighbor)) {
          var tempG = currentCell.g + 1;
          if(openSet.includes(neighbor)) {
            if (tempG < neighbor.g) {
              neighbor.g = tempG;
              neighbor.previous = currentCell;
            }
          } else {
            neighbor.g = tempG;
            neighbor.previous = currentCell;
            openSet.push(neighbor);
          }

          neighbor.h = heuristic(neighbor, end);
          neighbor.f = neighbor.g + neighbor.h;

        }
      }

    } else {
      console.log('No solution');
      noLoop();
      return;
    }

    noFill();
    stroke(color(0,0,255));
    strokeWeight(w/2);
    beginShape();
    for (var i = 0; i < path.length; i++) {
      vertex((path[i].x+0.5)*w, (path[i].y+0.5)*h);
    }
    endShape();

  } else {
    // 1
    currentCell.visited = true;
    currentCell.highlight();
    var next = currentCell.checkNeighbors();
    if (next) {
      next.visited = true;
      // 2
      stack.push(currentCell);
      // 3
      removeWalls(currentCell, next);
      // 4
      currentCell = next;
    } else if (stack.length > 0) {
      currentCell = stack.pop();
    } else if(currentCell.visited) {
      solving = true;

      start = grid[0];
      end = grid[grid.length - 1];

      openSet.push(start);
    }
  }
}