#define MAPX 4
#define MAPY 3

struct aStar
{
  int F, G, H;
  int list;  // -1 = no list, 0 = open, 1 = closed, 2 = unwalkable
  int parentX, parentY;
}  path[MAPX][MAPY];

int lastSquareX, lastSquareY, targetX = 3, targetY = 0;

void main()
{
  // this is the chunk of the program... just for example
  while((lastSquareX != targetX) && (lastSquareY != targetY))
  {
   runAStar();
  }
  // go through path
  // this is where the enemy would go through the path... i'm thinking of using another struct called pathToFollow for this
  
  
}


void runAStar()
{
int tempF, lowestF, tempMapX, tempMapY;
bool firstTime = true;

tempF = 5000;  // any number should be lower than this... this gets the ball rolling so to speak

if(firstTime != true)
{


for(int x = 0; x < MAPX; x++)
{

// go through x

    for (int y = 0; y < MAPY; y++)
    {

/// go through y

      // if F value is lower than lowest at time then update
      if((path[x][y].F < tempF) && (path[x][y].list = 0))
      {
        tempF = path[x][y].F  // new lowest F cost
        tempMapX = x;
        tempMapY = y;
       }
     }
}

}

else
{
tempMapX = 0;
tempMapY = 0;
firstTime = false;

// go through the map and make everything so that it isn't on either open or closed list

for(int x = 0; x < MAPX; x++)
{

// go through x

    for (int y = 0; y < MAPY; y++)
    {

// go through y

    // set path on NO list
    path[x][y].list = -1;

     }
}

}

path[tempMapX][tempMapY].list = 1;  // put current square on closed list

// now check the adjacent squares and make sure they are valid

if(tempMapX+1 <= MAPX)
{
adjSquares(tempMapX+1, tempMapY, targetX, targetY, tempMapX, tempMapY, 10);
}

if(tempMapY+1 <= MAPY)
{
adjSquares(tempMapX, tempMapY+1, targetX, targetY, tempMapX, tempMapY, 10);
}

if(tempMapX-1 >= 0)
{
adjSquares(tempMapX-1, tempMapY, targetX, targetY, tempMapX, tempMapY, 10);
}

if(tempMapY-1 >= 0)
{
adjSquares(tempMapX, tempMapY-1, targetX, targetY, tempMapX, tempMapY, 10);
}

// diagonal
if((tempMapX+1 <= MAPX) && (tempMapY+1 <= MAPY))
{
adjSquares(tempMapX+1, tempMapY+1, targetX, targetY, tempMapX, tempMapY, 14);
}

if((tempMapX-1 >= 0) && (tempMapY-1 >= 0))
{
adjSquares(tempMapX-1, tempMapY-1, targetX, targetY, tempMapX, tempMapY, 14);
}

if((tempMapX-1 >= 0) && (tempMapY+1 <= MAPY))
{
adjSquares(tempMapX-1, tempMapY+1, targetX, targetY, tempMapX, tempMapY, 14);
}

if((tempMapX+1 <= MAPX) && (tempMapY-1 >= 0))
{
adjSquares(tempMapX+1, tempMapY-1, targetX, targetY, tempMapX, tempMapY, 14);
}

}


void adjSquares(int adjX, int adjY, int targetX, int targetY, int currentX, int currentY, int starting X, int starting Y, int modifier)
{

if(path[adjX][adjY].list == -1)
{
  int parentGx, parentGy;  // this holds our temporary parent data;  it tells us what the next parent is

  // if it isn't on a list
  parentGx = currentX;
  parentGy = currentY;

  // determine heuristic
  path[adjX][adjY].H = 10*(abs((adjX)-targetX) + abs(adjY-targetY));

  // now the fun part, determine the G value
  while ((parentGx != startingX) && (parentGy != startingY))
  {
     path[adjX][adjY].G += path[parentGx][parentGy].G;
     parentGx = path[parentGx][parentGy].parentX;
     parentGy = path[parentGx][parentGy].parentY;
  }
  // add appropriate modifier
  path[adjX][adjY].G += modifier;

  // figure out F
  path[adjX][adjY].F = path[adjX][adjY].G + path[adjX][adjY].H;

  // add to open list
  path[adjX][adjY].list = 0;

  // update the last square added to open list
  lastSquareX = adjX;
  lastSquareY = adjY;

}

else if(path[adjX][adjY].list == 0)
{

  int tempG;  // holds G to compare to current G value of square

  // if it's on the open list
  // get parent G value, add modifier, determine if that's lower than its current cost
  tempG = path[currentX][currentY].G + modifier

  // if lower than current cost than make that square the parent square
  if (tempG < path[adjX][adjY].G)
  {
      path[adjX][adjY].parentX = currentX;
      path[adjX][adjY].parentY = currentY;
  }
  
}

}