chess.grid

import gridBasics.grid

int flag;
int checkGameEnd()
{
  /*First trigger checkIfUnderAttack for current location of opposing king. 
  Then, trigger rule for king to see if he can move anywhere. 
  But triggerRule() takes a destination coordinate.*/ 

  Player* p;
  Piece GenericPiece* kp;
  int dst_x, dst_y, tempx, tempy;

  /*Temporarily change current player*/
  nextPlayer();

  if (currentPlayerIndex == 0)
  {
    kp = getPieceFromGrid(p1.king.displayString);
  }
  else
  {
    kp = getPieceFromGrid(p2.king.displayString);
  }

  if (checkIfUnderAttack(kp.x, kp.y))
  {
    print("Currently under check");

    flag = 1;
    for(dst_x = 0; dst_x < rows; dst_x = dst_x + 1)
    {
      for(dst_y = 0; dst_y < cols; dst_y = dst_y + 1)
      {
        if (triggerRule(kp.x, kp.y, dst_x, dst_y, kp.typetag) == 1)
        {
          print("Can move to: ");
          print(dst_x);
          print(dst_y);
          nextPlayer();
          flag = 0;
          return 0;
        }
      }
    }
    flag = 0;
    printGrid();
    print("Checkmate!");
    return 1;
  }
  /*Change back*/
  nextPlayer();
  return 0;
}

int attx;
int atty;
bool checkIfUnderAttack(int dst_x, int dst_y)
{
  Player* p;
  int x, y;
  Piece GenericPiece* l;

  /*Switch players to see if any of enemy's items are attacking the king*/
  nextPlayer();
  if (currentPlayerIndex == 0)
  {
    p = &p1;
  }
  else
  {
    p = &p2;
  }

  for(x = 0; x < rows; x = x+1)
  {
    for(y = 0; y < cols; y = y+1)
    {
      l = getPieceAtLocation(x,y);
      if (l != None)
      {
        if (l.owner == p)
        {
          if (triggerRule(x, y, dst_x, dst_y, l.typetag) == 1)
          {
            attx = x;
            atty = y;
            nextPlayer();
            return true;
          }
        }
      }
    }
  }
  /*Switch back*/
  nextPlayer();
  return false;
}

Piece King
{
  string displayString;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    Piece GenericPiece* src, dst;
    Player* owner1, owner2;
    Player cur;
    int xdiff, ydiff;

    src = getPieceAtLocation(src_x, src_y);
    dst = getPieceAtLocation(dst_x, dst_y);

    /*Check if your piece*/
    cur = playerOrder[currentPlayerIndex];
    owner1 = src.owner;
    if (cur.color != owner1.color)
    {
      return 0;
    }

    xdiff = abs(dst_x - src_x);
    ydiff = abs(dst_y - src_y);
    if (xdiff > 1 || ydiff > 1)
    {
      return 0;
    }

    if (dst != None)
    {
      owner2 = dst.owner;
      if(owner2.color == owner1.color)
      {
        return 0;
      }
    }

    if (checkIfUnderAttack(dst_x, dst_y))
    {
      return 0;
    }
    return 1;
  }
}

Piece Pawn
{
  string displayString;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    int direction;
    Piece GenericPiece* src, dst, king_item;
    Player* owner1, owner2;
    Player cur;

    src = getPieceAtLocation(src_x, src_y);
    dst = getPieceAtLocation(dst_x, dst_y);

    /*Check if your piece*/
    cur = playerOrder[currentPlayerIndex];
    owner1 = src.owner;
    if (cur.color != owner1.color)
    {
      return 0;
    }

    direction = getDirectionFromIndex();

    if(dst_x != src_x + direction)
    {
      return 0;
    }
    if (dst_y - src_y > 1 || dst_y - src_y < -1)
    {
      return 0;
    }
    if(dst_y == src_y - 1 || dst_y == src_y + 1) 
    {
      if (dst != None)
      {
        owner2 = dst.owner;
        if (owner1.color == owner2.color && flag!=1)
        {
          return 0;
        }
        else
        {
          return 1;
        }
      }
      else
      {
        return 0;
      }
    }
    if (dst!=None)
    {
      return 0;
    }


    if (currentPlayerIndex == 0)
    {
      king_item = getPieceFromGrid(p1.king.displayString);
    }
    else
    {
      king_item = getPieceFromGrid(p2.king.displayString);
    }
    if (checkIfUnderAttack(king_item.x, king_item.y))
    {
      return 0;
    }
    
    return 1;
  }
}

Piece Bishop
{
  string displayString;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    Piece GenericPiece* src, dst, king_item;
    Player* owner1, owner2;
    Player cur;
    src = getPieceAtLocation(src_x, src_y);
    dst = getPieceAtLocation(dst_x, dst_y);

    /*Check if your piece*/
    cur = playerOrder[currentPlayerIndex];
    owner1 = src.owner;
    if (cur.color != owner1.color)
    {
      return 0;
    }

    if(abs(dst_x - src_x) == abs(dst_y - src_y))  /* moves diagonally only*/
    {
      if (dst != None)
      {
        owner2 = dst.owner;
        if(owner2.color == owner1.color && flag!=1)  
        {
          return 0;
        }
      }

      if (traverse(src_x, src_y, dst_x, dst_y) == 1)
      {
        return 0;
      }

      if (currentPlayerIndex == 0)
      {
        king_item = getPieceFromGrid(p1.king.displayString);
      }
      else
      {
        king_item = getPieceFromGrid(p2.king.displayString);
      }
      if (checkIfUnderAttack(king_item.x, king_item.y))
      {
        return 0;
      }
      return 1;
    }
    return 0;
  }
}

Piece Knight
{
  string displayString;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    Piece GenericPiece* src, dst, king_item;
    Player* owner1, owner2;
    Player cur;
    int xdiff, ydiff;

    src = getPieceAtLocation(src_x, src_y);
    dst = getPieceAtLocation(dst_x, dst_y);

    /*Check if your piece*/
    cur = playerOrder[currentPlayerIndex];
    owner1 = src.owner;
    if (cur.color != owner1.color)
    {
      return 0;
    }

    xdiff = abs(dst_x - src_x);
    ydiff = abs(dst_y - src_y);
    if(xdiff == 2 && ydiff == 1 || xdiff == 1 && ydiff == 2) 
    {
      if (dst!= None)
      {
        owner2 = dst.owner;
        if(owner2.color == owner1.color && flag!=1)  
        {
          return 0;
        }
      }

      if (currentPlayerIndex == 0)
      {
        king_item = getPieceFromGrid(p1.king.displayString);
      }
      else
      {
        king_item = getPieceFromGrid(p2.king.displayString);
      }
      if (checkIfUnderAttack(king_item.x, king_item.y))
      {
        return 0;
      }
      return 1;
    }
    return 0;
  }
}

Piece Rook
{
  string displayString;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    Piece GenericPiece* src, dst, king_item;
    Player* owner1, owner2;
    Player cur;
    int xdiff, ydiff;

    src = getPieceAtLocation(src_x, src_y);
    dst = getPieceAtLocation(dst_x, dst_y);

    /*Check if your piece*/
    cur = playerOrder[currentPlayerIndex];
    owner1 = src.owner;
    if (cur.color != owner1.color)
    {
      return 0;
    }

    if(dst_x == src_x || dst_y == src_y)
    {
      if (dst != None)
      {
        owner2 = dst.owner;
        if(owner2.color == owner1.color && flag!=1)
        {
          return 0;
        }
      }
      /*Check if there is an obstacle in the way*/
      if (traverse(src_x, src_y, dst_x, dst_y) == 1)
      {
        return 0;
      }
      if (currentPlayerIndex == 0)
      {
        king_item = getPieceFromGrid(p1.king.displayString);
      }
      else
      {
        king_item = getPieceFromGrid(p2.king.displayString);
      }
      if (checkIfUnderAttack(king_item.x, king_item.y))
      {
        return 0;
      }
      return 1;
    }
    return 0;
  }
}

Player
{ 
  Piece Pawn pawn;
  Piece Bishop bishop;
  Piece Knight knight;
  Piece Rook rook;
  Piece King king;
  string color;
  int rule(int src_x, int src_y, int dst_x, int dst_y)
  {
    return 1;
  }
}

int getDirectionFromIndex()
{
  int direction;
  if(currentPlayerIndex == 0)
  {
    direction = -1;
  }
  else
  {
    direction = 1;
  }
  return direction;
}

int colocation(int x, int y, Piece GenericPiece* i1, Piece GenericPiece* i2)
{
  deleteFromGrid(x,y,i2.nametag);
  return 0;
}

Grid_Init<5,4>;
Player p1, p2;
Player[2] playerOrder;
int count;

int setup(){
  p1.color = "White";
  p2.color = "Black"; 
  playerOrder[0] = p1;
  playerOrder[1] = p2;
  flag = 0;

  p1.king.displayString = "W-King";
  p1.rook.displayString = "W-Rook";
  p1.knight.displayString = "W-Knight";
  p1.bishop.displayString = "W-Bishop";
  p1.pawn.displayString = "W-Pawn";

  p2.king.displayString = "B-King";
  p2.rook.displayString = "B-Rook";
  p2.knight.displayString = "B-Knight";
  p2.bishop.displayString = "B-Bishop";
  p2.pawn.displayString = "B-Pawn";

  Grid <4,3> <-- p1.king;
  Grid <3,3> <-- p1.pawn;
  Grid <4,1> <-- p1.bishop;
  Grid <4,2> <-- p1.knight;
  Grid <4,0> <-- p1.rook;

  Grid <0,0> <-- p2.king;
  Grid <1,0> <-- p2.pawn;
  Grid <0,2> <-- p2.bishop;
  Grid <0,1> <-- p2.knight;
  Grid <0,3> <-- p2.rook;
  return 0;
}

int gameloop(){ 
  int src_x, src_y, dst_x, dst_y;
  Piece GenericPiece* headnode, p_n;
  Player cur;
  cur = playerOrder[currentPlayerIndex];
  printGrid();
  print(cur.color);
  src_x = prompt("Enter source x:");
  src_y = prompt("Enter source y:");
  dst_x = prompt("Enter destination x:");
  dst_y = prompt("Enter destination y:");
  p_n = getPieceAtLocation(src_x, src_y);
  if (moveOnGrid(p_n, dst_x,dst_y) != 1)
  {
    print("Invalid move");
  }
  return 0; 
}