title: Time comparing on debug mode and release mode(Visual studio 2008)
body: <p>I implemented A* and JPS(Jump Point Search) using VS2008. 
  Then i tried comparing time cost of these code.</p>
  
  <p>On debug mode, (my) JPS is faster than A* about 2.0~50 times .
  But on release mode, JPS is faster than A* about 0.6~3.0 times.
  Especially, almost cases of test on release mode, JPS slower than A*.</p>
  
  <p>Why results are so different?
  In the paper( "Online Graph Pruning for Pathfinding on Grid Maps", 2011 ), 
  JPS is faster than A* about 20~30 times.
  If i want to get a similar results in the paper, what should i do? </p>
  
  <p>I just call map1.A_star() and map2.JPS() in main.cpp.
  and I used prioiry_queue(STL) for A* and JPS.</p>
  
  <p>↓ pathfinding.cpp</p>
  
  <pre><code>#include "util.h"
  
  using namespace std;
  
  
  int DIR_X[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
  int DIR_Y[8] = { -1, -1, 0, 1, 1, 1, 0, -1 };
  // diagonal index {1, 3, 5, 7}
  
  template&lt;class T&gt;
  void vector_clear(vector&lt;T&gt;&amp; vecObj)
  {
      vector&lt;T&gt; tempObj;
      tempObj.swap(vecObj);
  }
  
  
  
  bool operator&lt;(const Node&amp; a, const Node&amp; b)
  {
      return a.getPriority() &gt; b.getPriority();
  }
  
  void read_scenario(char* path, char(*scenarios)[256], int&amp; total) {
  
      ifstream scen_file(path);
      char buffer[256];
      int num = 0;
      scen_file.getline(buffer, 256);
  
  
      while (!scen_file.eof()) {
          scen_file.getline(buffer, 256);
          num++;
          int index1;
          int index2;
          int count = 0;
  
          for (int i = 0; i&lt;256; i++) {
              if (buffer[i] == ' ')
                  count++;
  
              if (buffer[i] == ' ' &amp;&amp; count == 4)
                  index1 = i;
  
              if (buffer[i] == ' ' &amp;&amp; count == 8)
                  index2 = i;
  
          }
  
          for (int i = index1 + 1; i &lt;= index2 - 1; i++) {
              scenarios[num][i - (index1 + 1)] = buffer[i];
          }
          scenarios[num][index2] = NULL;
      }
  
  
      std::cout &lt;&lt; num &lt;&lt; " 개의 시나리오가 있습니다." &lt;&lt; endl;
  
      total = num;
      scen_file.close();
  }
  
  
  Map::Map(int* START_GOAL, char* IN_PATH, char* OUT_PATH, string MODE) {
      sx = START_GOAL[0];
      sy = START_GOAL[1];
      gx = START_GOAL[2];
      gy = START_GOAL[3];
  
      mode = MODE;
  
      in_path = IN_PATH;
      out_path = OUT_PATH;
  
      ifstream map_file(in_path);
  
  
      if (!map_file.is_open()) {
          std::cout &lt;&lt; "there is no map_file" &lt;&lt; endl;
      }
  
      char buffer[128];
      char ch[4];
      char cw[4];
  
      map_file.getline(buffer, 128);
  
  
      map_file.getline(buffer, 128);
      for (int i = 7; i &lt; strlen(buffer); i++) {
          ch[i - 7] = buffer[i];
      }
      h = atoi(ch);
      std::cout &lt;&lt; "height = " &lt;&lt; h &lt;&lt; endl;;
  
      map_file.getline(buffer, 128);
      for (int i = 6; i &lt; strlen(buffer); i++) {
          cw[i - 6] = buffer[i];
      }
      w = atoi(cw);
      std::cout &lt;&lt; "width = " &lt;&lt; w &lt;&lt; endl;;
  
      map_file.getline(buffer, 128);
  
      std::cout &lt;&lt; "Start at (" &lt;&lt; sx &lt;&lt; " " &lt;&lt; sy &lt;&lt; ")" &lt;&lt; endl;
      std::cout &lt;&lt; "Goal  is (" &lt;&lt; gx &lt;&lt; " " &lt;&lt; gy &lt;&lt; ")" &lt;&lt; endl;
      std::cout &lt;&lt; endl;
  
      in_map = new char*[h];
      direction_map = new int*[h];
      visit_map = new bool*[h];
      out_map = new char*[h];
      parent_map = new int*[h];
      open_node_map = new double*[h];
  
  
      for (int j = 0; j&lt;h; j++) {
          in_map[j] = new char[w];
          direction_map[j] = new int[w];
          visit_map[j] = new bool[w];
          out_map[j] = new char[w];
          parent_map[j] = new int[w];
          open_node_map[j] = new double[w];
  
          for (int i = 0; i &lt;= w; i++) {
  
              char tmp;
              map_file.get(tmp);
  
              if (w == i)
                  continue;
  
              in_map[j][i] = tmp;
              direction_map[j][i] = -1;
              visit_map[j][i] = false;
              out_map[j][i] = tmp;
              open_node_map[j][i] = 0.0;
          }
      }
  
      map_file.close();
  }
  
  Map::~Map() {
      for (int i = 0; i&lt;h; i++) {
          delete[] parent_map[i];
          delete[] in_map[i];
          delete[] direction_map[i];
          delete[] visit_map[i];
          delete[] out_map[i];
          delete[] open_node_map[i];
      }
      delete[] parent_map;
      delete[] in_map;
      delete[] direction_map;
      delete[] visit_map;
      delete[] out_map;
      delete[] open_node_map;
  }
  
  int Map::getGx() const { return gx; }
  int Map::getGy() const { return gy; }
  int Map::getSx() const { return sx; }
  int Map::getSy() const { return sy; }
  
  int Map::getHeight() const { return h; }
  int Map::getWidth() const { return w; }
  double Map::getOptimalLength() const { return optimal_length; }
  
  char Map::getInMapData(int x, int y) { return in_map[y][x]; }
  int Map::getDirectionData(int x, int y) { return direction_map[y][x]; }
  bool Map::getVisitMapData(int x, int y) { return visit_map[y][x]; }
  int Map::getParentMapData(int x, int y) { return parent_map[y][x]; }
  double Map::getOpen_NodeData(int x, int y) { return open_node_map[y][x]; }
  
  
  char Map::getOutMapData(int x, int y) const { return out_map[y][x]; }
  
  void Map::setVisitMap(int x, int y, bool data) { visit_map[y][x] = data; }
  void Map::setDirectionMap(int x, int y, int data) { direction_map[y][x] = data; }
  void Map::setOutMap(int x, int y, char data) { out_map[y][x] = data; }
  void Map::setParentMap(int x, int y, int data) { parent_map[y][x] = data; }
  void Map::setOpen_NodeMap(int x, int y, double data) { open_node_map[y][x] = data; }
  
  
  void Map::initialize() {}
  void Map::draw_map() {
  
      ofstream out_file(out_path);
  
      for (int j = 0; j&lt;h; j++) {
          for (int i = 0; i&lt;w; i++) {
              if (j == sy &amp;&amp; i == sx)
                  out_map[j][i] = 'S';
  
              if (j == gy &amp;&amp; i == gx)
                  out_map[j][i] = 'G';
  
              out_file &lt;&lt; out_map[j][i];
  
          }
          out_file &lt;&lt; "\r\n";
      }
      out_file.close();
  }
  
  void Map::A_star() {
  
      priority_queue&lt;Node&gt; search_q[2];
  
      Node startPoint(sx, sy, gx, gy, -1, 0, mode);
      int pqi = 0;
      search_q[pqi].push(startPoint);
  
      Map::setOpen_NodeMap(sx, sy, startPoint.getPriority());
  
  
  
      while (!search_q[pqi].empty()) {
  
  
  
          int cx = search_q[pqi].top().getX();    // current x, y
          int cy = search_q[pqi].top().getY();
  
  
          double passedLength_c = search_q[pqi].top().getPassedLength();
  
          Map::setVisitMap(cx, cy, true);
          Map::setOpen_NodeMap(cx, cy, search_q[pqi].top().getPriority());
  
          search_q[pqi].pop();
  
  
          if (cx == gx &amp;&amp; cy == gy) {
  
              double shortestLength = 0;
              while (1) {
  
  
                  if ((cx == sx) &amp;&amp; (cy == sy)) break;
  
                  int tmp_x, tmp_y, tmp_dir;
                  tmp_x = cx;
                  tmp_y = cy;
                  tmp_dir = getDirectionData(tmp_x, tmp_y);
  
                  cx -= DIR_X[tmp_dir];
                  cy -= DIR_Y[tmp_dir];
  
                  setOutMap(cx, cy, '#');
  
                  if (tmp_dir % 2 == 1)
                      shortestLength += sqrt(2.0);
                  else
                      shortestLength += 1.0;
  
              }
  
              cout &lt;&lt; "A_star find!" &lt;&lt; endl;
              cout &lt;&lt; "Path Length = " &lt;&lt; shortestLength &lt;&lt; endl;
              optimal_length = shortestLength;
  
  
              while (!search_q[pqi].empty()) {
                  search_q[pqi].pop();
              }
  
              return;
          }
  
          for (int dir = 0; dir&lt;8; dir++) {
              // next_node
              int nx = cx + DIR_X[dir];
              int ny = cy + DIR_Y[dir];
  
              if (!(nx &gt;(w - 1) || nx &lt; 0 || ny &gt;(h - 1) || ny &lt; 0 || getInMapData(nx, ny) == '@' || getVisitMapData(nx, ny) == true)) {
  
                  Node next_node(nx, ny, gx, gy, passedLength_c, dir, mode, 1);
  
                  if (Map::getOpen_NodeData(nx, ny) == 0) {
  
                      Map::setOutMap(nx, ny, 'I');
                      Map::setOpen_NodeMap(nx, ny, next_node.getPriority());
                      search_q[pqi].push(next_node);
                      Map::setDirectionMap(nx, ny, dir);
  
                  }
  
                  else if (Map::getOpen_NodeData(nx, ny) &gt; next_node.getPriority()) {
  
  
                      Map::setOpen_NodeMap(nx, ny, next_node.getPriority());
                      Map::setDirectionMap(nx, ny, dir);
                      search_q[pqi].push(next_node);
                      /*
                      while (!(search_q[pqi].top().getX() == nx &amp;&amp; search_q[pqi].top().getY() == ny))
                      search_q[1 - pqi].push(search_q[pqi].top());
                      search_q[pqi].pop();
                      }
                      search_q[pqi].pop();
  
                      if (search_q[pqi].size() &gt; search_q[1 - pqi].size()) {
                      pqi = 1 - pqi;
                      }
                      while (!search_q[pqi].empty()) {
                      search_q[1 - pqi].push(search_q[pqi].top());
                      search_q[pqi].pop();
                      }
                      pqi = 1 - pqi;
                      search_q[pqi].push(next_node);
                      */
                  }
  
  
              }
  
          }
  
      }
  }
  
  void Map::JPS() {
  
  
      priority_queue &lt;Node&gt; JumpPoints;
      Node startPoint(sx, sy, gx, gy, 0, -1, mode, 1);
  
      startPoint.calculateDistanceToGoal();
      startPoint.updatePriority();
  
      JumpPoints.push(startPoint);
  
  
      while (!JumpPoints.empty()) {
          int x = JumpPoints.top().getX();
          int y = JumpPoints.top().getY();
  
  
          if (x == gx &amp;&amp; y == gy) {
              cout &lt;&lt; "JPS find!!!" &lt;&lt; endl;
  
              double shortestLength = 0;
              while (!(x == Map::getSx() &amp;&amp; y == Map::getSy())) {
  
                  int fix_x = x;
                  int fix_y = y;
  
                  int tmp_dir = getDirectionData(fix_x, fix_y);
  
  
                  int px = Map::getParentMapData(fix_x, fix_y) % 512;
                  int py = Map::getParentMapData(fix_x, fix_y) / 512;
  
  
                  //while(!(Map::getOutMapData(x, y) == 'J')){
                  while (!(px == x &amp;&amp; py == y)) {
  
  
                      if (Map::getParentMapData(fix_x, fix_y) == (y * Map::getWidth() + x)) break;
  
                      //if(!(Map::getOutMapData(x, y) == 'J')){
                      if (!(Map::getOutMapData(x, y) == 'J')) {
                          setOutMap(x, y, '#');
                      }
  
                      x -= DIR_X[tmp_dir];
                      y -= DIR_Y[tmp_dir];
  
                      if (tmp_dir % 2 == 1)
                          shortestLength += sqrt(2.0);
                      else
                          shortestLength += 1.0;
  
                  }
              }
              optimal_length = shortestLength;
              cout &lt;&lt; "Path Length = " &lt;&lt; shortestLength &lt;&lt; endl;
              //cout&lt;&lt;"Path Length = "&lt;&lt; passedLength_c &lt;&lt; endl;
  
              return;
          }
  
          else
              Map::identifySuccessors(JumpPoints);
  
  
      }
  
      while (!JumpPoints.empty()) {
          JumpPoints.pop();
      }
  
  
  
      cout &lt;&lt; "not found" &lt;&lt; endl;
  
  }
  
  /*
  Node Map::jump(Node const node, int dir, int&amp; off) {
  int nx = node.getX() + DIR_X[dir];
  int ny = node.getY() + DIR_Y[dir];
  
  if (nx &gt; (w - 1) || nx &lt; 0 || ny &gt;(h - 1) || ny &lt; 0) {
  // Map::setOutMap(nx, ny, 'B');
  Node NULL_node(-100, -100, 0, 0, 0, 0, "OCTILE", 1);
  return NULL_node;
  }
  char n_MapData = Map::getOutMapData(nx, ny);
  
  if (n_MapData == '@') {
  Node NULL_node(-100, -100, 0, 0, 0, 0, "OCTILE", 1);
  return NULL_node;
  }
  Node n_node(nx, ny, gx, gy, node.getPassedLength(), dir);
  
  if (n_MapData == 'I')
  Map::setOutMap(nx, ny, 'X');
  
  if (nx == gx &amp;&amp; ny == gy) {
  off = 1;
  return n_node;
  }
  
  int forced_neighbours_bits = Map::forced_neighbours(nx, ny, dir);
  
  if (forced_neighbours_bits &gt; 0) {
  //Map::setOutMap(nx, ny, 'F');
  return n_node;
  }
  
  if (dir % 2 == 1) {
  // Algorithm 2 function jump 8th line)
  
  if (Map::jump(n_node, (dir + 7) % 8, off).getX() != -100)
  return n_node;
  
  if (Map::jump(n_node, (dir + 1) % 8, off).getX() != -100)
  return n_node;
  
  }
  
  if (n_MapData != 'S' &amp;&amp; n_MapData != 'I' &amp;&amp; n_MapData != 'G' &amp;&amp; n_MapData != '@' &amp;&amp; n_MapData != 'J')
  Map::setOutMap(nx, ny, 'I');
  //draw_map();
  
  
  return Map::jump(n_node, dir, off);
  }
  
  */
  
  
  
  int Map::jump(int index, int dir, int&amp; off) {
  
      int x = index % w;
      int y = index / w;
  
  
      int nx = x + DIR_X[dir];
      int ny = y + DIR_Y[dir];
      int n_index = ny * w + nx;
  
      if (nx &gt; (w - 1) || nx &lt; 0 || ny &gt;(h - 1) || ny &lt; 0) {
          // Map::setOutMap(nx, ny, 'B');     
          return -1;
      }
      char n_MapData = Map::getOutMapData(nx, ny);
  
      if (n_MapData == '@') {
          return -1;
      }
  
      if (n_MapData == 'I')
          Map::setOutMap(nx, ny, 'X');
  
      if (nx == gx &amp;&amp; ny == gy) {
          off = 1;
          return n_index;
      }
  
      int forced_neighbours_bits = Map::forced_neighbours(nx, ny, dir);
  
      if (forced_neighbours_bits &gt; 0) {
          //Map::setOutMap(nx, ny, 'F');
          return n_index;
      }
  
      if (dir % 2 == 1) {
          // Algorithm 2 function jump 8th line)
  
          if (Map::jump(n_index, (dir + 7) % 8, off) != -1)
              return n_index;
  
          if (Map::jump(n_index, (dir + 1) % 8, off) != -1)
              return n_index;
  
      }
  
      if (n_MapData != 'S' &amp;&amp; n_MapData != 'I' &amp;&amp; n_MapData != 'G' &amp;&amp; n_MapData != '@' &amp;&amp; n_MapData != 'J')
          Map::setOutMap(nx, ny, 'I');
      //draw_map();
  
  
      return Map::jump(n_index, dir, off);
  }
  
  
  void Map::identifySuccessors(priority_queue &lt;Node&gt;&amp; successors) {
  
  
      int x = successors.top().getX();
      int y = successors.top().getY();
  
  
  
      if (x == gx &amp;&amp; y == gy)
          return;
  
      int index = y * Map::getWidth() + x;
  
      int dir = successors.top().getDirection();
      double passedLength = successors.top().getPassedLength();
  
  
  
      Node start(x, y, gx, gy, passedLength, dir, mode, 1);
  
      start.updatePassedLength();
      start.calculateDistanceToGoal();
      start.updatePriority();
  
      successors.pop();
  
      vector&lt;int&gt; candidate_dir;
      if (dir == -1) {
          for (int i = 0; i&lt;8; i++) {
              int dx = x + DIR_X[i];
              int dy = y + DIR_Y[i];
              if (!(dx &lt; 0 || dx &gt;(w - 1) || dy &lt; 0 || dy &gt;(h - 1) || Map::getOutMapData(dx, dy) == '@'))
                  candidate_dir.push_back(i);
          }
      }
  
      else {
          int bits = Map::forced_neighbours(x, y, dir);
          for (int i = 0; i&lt;8; i++) {
              if (bits &amp; (1 &lt;&lt; i))
                  candidate_dir.push_back(i);
          }
  
  
          if (dir % 2 == 1) {
              int dx = x + DIR_X[(dir + 1) % 8];
              int dy = y + DIR_Y[(dir + 1) % 8];
  
              if (!(dx &lt; 0 || dx &gt;(w - 1) || dy &lt; 0 || dy &gt;(h - 1) || Map::getOutMapData(dx, dy) == '@'))
                  candidate_dir.push_back((dir + 1) % 8);
  
              dx = x + DIR_X[(dir + 7) % 8];
              dy = y + DIR_Y[(dir + 7) % 8];
  
              if (!(dx &lt; 0 || dx &gt;(w - 1) || dy &lt; 0 || dy &gt;(h - 1) || Map::getOutMapData(dx, dy) == '@'))
                  candidate_dir.push_back((dir + 7) % 8);
  
              dx = x + DIR_X[dir];
              dy = y + DIR_Y[dir];
  
              if (!(dx &lt; 0 || dx &gt;(w - 1) || dy &lt; 0 || dy &gt;(h - 1) || Map::getOutMapData(dx, dy) == '@'))
                  candidate_dir.push_back(dir);
          }
          else {
              int dx = x + DIR_X[dir];
              int dy = y + DIR_Y[dir];
              if (!(dx &lt; 0 || dx &gt;(w - 1) || dy &lt; 0 || dy &gt;(h - 1) || Map::getOutMapData(dx, dy) == '@'))
                  candidate_dir.push_back(dir);
          }
      }
  
  
      for (int i = 0; i&lt;candidate_dir.size(); i++) {
  
          int nx, ny, n_index;
          int n_dir = candidate_dir[i];
  
          nx = x + DIR_X[n_dir];
          ny = y + DIR_Y[n_dir];
  
  
          int jx, jy;
          double  j_passedLength, s_dist = 0.0, d_dist = 0.0;
  
  
          int off = 0;
          int j_index = Map::jump(index, n_dir, off);
  
          if (j_index == -1)
              continue;
  
          jx = j_index % w;
          jy = j_index / w;
          j_passedLength = passedLength + sqrt((x - jx)*(x - jx) + (y - jy)*(y - jy));
  
          Node j_node(jx, jy, gx, gy, j_passedLength, n_dir, mode, 1);
  
          j_node.setPassedLength(j_passedLength);
          j_node.calculateDistanceToGoal();
          j_node.updatePriority();
  
          if (Map::getOpen_NodeData(jx, jy) == 0) {
  
              Map::setOutMap(jx, jy, 'J');
              Map::setParentMap(jx, jy, y * Map::getWidth() + x);
  
              Map::setDirectionMap(jx, jy, n_dir);
              Map::setOpen_NodeMap(jx, jy, j_node.getPriority());
              successors.push(j_node);
          }
  
          else if (Map::getOpen_NodeData(jx, jy) &gt; j_node.getPriority()) {
              Map::setOpen_NodeMap(jx, jy, j_node.getPriority());
              Map::setDirectionMap(jx, jy, n_dir);
  
              Map::setParentMap(jx, jy, y * Map::getWidth() + x);
  
          }
  
  
  
      }
  
      candidate_dir.clear();
      return;
      cout &lt;&lt; "not found" &lt;&lt; endl;
  }
  
  
  /*
  */
  bool Map::is_obstacle(int x, int y, int dir) {
      int nx = x + DIR_X[dir];
      int ny = y + DIR_Y[dir];
  
      if (nx &lt; 0 || nx &gt;(w - 1) || ny &lt; 0 || ny &gt;(h - 1))
          return false;
  
      if (Map::getInMapData(nx, ny) == '@')
          return true;
      else
          return false;
  }
  
  int Map::forced_neighbours(int x, int y, int dir) {
      int bits = 0;
  
      if (dir == -1)
          return -1;
  
      if (dir % 2 == 0) {
          // straight
          int ndir1 = (dir + 2) % 8;
          int ndir2 = (dir + 6) % 8;
  
          if (Map::is_obstacle(x, y, ndir1)) {
              if (!Map::is_obstacle(x, y, (dir + 1) % 8))
                  bits = bits | 1 &lt;&lt; ((dir + 1) % 8);
          }
          if (Map::is_obstacle(x, y, ndir2))
              if (!Map::is_obstacle(x, y, (dir + 7) % 8))
                  bits = bits | 1 &lt;&lt; ((dir + 7) % 8);
      }
      else {
          int ndir1 = (dir + 3) % 8;
          int ndir2 = (dir + 5) % 8;
  
          if (Map::is_obstacle(x, y, ndir1))
              if (!Map::is_obstacle(x, y, (dir + 1) % 8))
                  bits = bits | 1 &lt;&lt; ((dir + 1) % 8);
          if (Map::is_obstacle(x, y, ndir2))
              if (!Map::is_obstacle(x, y, (dir + 7) % 8))
                  bits = bits | 1 &lt;&lt; ((dir + 7) % 8);
      }
      return bits;
  }
  
  Node::Node(int const x, int const y, int const gx, int const gy, double const passedLength, int const direction, string const mode, int const k) {
      this-&gt;x = x; this-&gt;y = y;
  
      this-&gt;direction = direction;
      this-&gt;passedLength = passedLength;
      this-&gt;gx = gx; this-&gt;gy = gy;
      this-&gt;mode = mode;
  
      if (k == 1) {
  
          updatePassedLength();
          calculateDistanceToGoal();
          updatePriority();
      }
  }
  
  Node::~Node() {}
  
  int Node::getX() const { return x; }
  int Node::getY() const { return y; }
  int Node::getDirection() const { return direction; }
  double Node::getPriority() const { return priority; }
  double Node::getPassedLength() const { return passedLength; }
  double Node::getDistanceToGoal() const { return distanceToGoal; }
  
  void Node::calculateDistanceToGoal() {
  
      double xd = abs(x - gx);
      double yd = abs(y - gy);
  
      if (mode.compare("MANHATTAN") == 0)
          distanceToGoal = abs(xd) + abs(yd);
  
      else if (mode.compare("EUCLIDIAN") == 0)
          distanceToGoal = sqrt((xd*xd) + (yd*yd));
  
      else if (mode.compare("CHEBYSHEV") == 0)
          distanceToGoal = max(abs(xd), abs(yd));
  
      else if (mode.compare("OCTILE") == 0)
          distanceToGoal = max(xd, yd) + (sqrt(2.0) - 1) + min(xd, yd);
  
      else
          cout &lt;&lt; "plz input mode" &lt;&lt; endl;
  
  }
  
  
  
  void Node::updatePassedLength() {
  
      if (direction == -1);
  
      else if (direction % 2 == 1)
          passedLength += (sqrt(2.0));
      else
          passedLength += (1);
  }
  
  void Node::updatePriority() {
      priority = passedLength + distanceToGoal;
  }
  
  void Node::setPassedLength(double data) {
      passedLength = data;
  }
  </code></pre>
  
  <p>util.h</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;string&gt;
  #include &lt;queue&gt;
  #include &lt;math.h&gt;
  #include &lt;fstream&gt;
  #include &lt;istream&gt;
  #include &lt;cstdio&gt;
  #include &lt;vector&gt;
  
  using namespace std;
  
  
  class Node {
  
  private:
      int x;
      int y;
  
      int gx;
      int gy;
  
      int direction;      // direction from past node
      double passedLength;
      double distanceToGoal;
      double priority;
      string mode;        // mode -&gt; "MANHATTAN", "EUCLIDIAN", CHEBYSHEV", "OCTILE"
  
  public:
  
      Node(int const x, int const y, int const gx, int const gy, double const passedLength, int const direction = 0,  string const mode = "MANHATTAN" , int const k = 0 );
      ~Node();
      int getX() const;
      int getY() const;
      int getDirection() const;
  
      double getPriority() const;
      double getPassedLength() const;
      double getDistanceToGoal() const;
  
      void setPassedLength(double data);
  
      void calculateDistanceToGoal();
      void updatePassedLength();
      void updatePriority();
  
  };
  
  
  class Map {
  
  public:
      int gx, gy, sx, sy, w, h;
      char* in_path, *out_path;
      string mode;
  
      char** in_map;
      int** direction_map;
      bool** visit_map;
      char** out_map;
      int** parent_map;
      double** open_node_map;
      double optimal_length;
  
  public:
      Map(int* START_GOAL, char* IN_PATH, char* OUT_PATH, string MODE);
      ~Map();
  
      int getGx() const;
      int getGy() const;
      int getSx() const;
      int getSy() const;
  
  
      char getInMapData(int x, int y);
      int getDirectionData(int x, int y);
      bool getVisitMapData(int x, int y);
      int getParentMapData(int x, int y);
      double getOpen_NodeData(int x, int y);
  
      int getHeight() const;
      int getWidth() const;
      double getOptimalLength() const;
  
      char getOutMapData(int x, int y) const;
  
      void setVisitMap(int x, int y, bool data);
      void setDirectionMap(int x, int y, int data);
      void setOutMap(int x, int y, char data);
      void setParentMap(int x, int y, int data);
      void setOpen_NodeMap(int x, int y, double data);
  
      void initialize();
      void draw_map();
  
      void A_star();
      void JPS();
  
      //int identifySuccessors(int x, int y);
  
  
  
      void identifySuccessors(priority_queue &lt;Node&gt;&amp; successors);
      //int jump(int node_index, int dir, double&amp; s_distance, priority_queue &lt;Node&gt;&amp; successors, double&amp; d_distance, int&amp; trig, int&amp; fx_fy);
      //Node Map::jump(Node node, int dir, int&amp; off);
      int Map::jump(int index, int dir, int&amp; off);
  
      bool is_obstacle(int x, int n, int dir);
      int Map::forced_neighbours(int x, int y, int dir);
  
  
  };
  
  
  void read_scenario(char* path, char(*scenarios)[256], int&amp; total);
  </code></pre>