protected void generateMoves(List<Movement> movesList, Piece piece)
   {
      /************** GENERACIÓN DE LOS MOVIMIENTOS  *************/
      bbPieceOccupation = bbPiecesOccupation[piece.index];
      numPieces = Long.bitCount(bbPieceOccupation);
      for(int i = 0; i < numPieces; i++)
      {
         pieceSquareIndex = Long.numberOfTrailingZeros(bbPieceOccupation);
         
         //Se obtienen las casillas que ataca la pieza
         bbAttacked = bbAttackedFromSquare[pieceSquareIndex];
         bbAttacked &= ~bbTurnOccupied;
         
         //Se comprueba si hay conexión entre la casilla del rey y la casilla de la pieza
         //Si no la hay se generan los movimientos de forma normal
         bbConnection = bbInclusiveConnection[pieceSquareIndex][kingSquareIndex];
         if(bbConnection != 0)
         {
            //Si hay conexión, se comprueba si hay alguna pieza en las casillas
            //que unen la casilla del rey y la casilla de la pieza
            //Si sí que hay alguna pieza se generan los movimientos de la pieza de forma normal
            bbConnection = bbExclusiveConnection[pieceSquareIndex][kingSquareIndex];
            if((bbConnection & bbOccupation) == 0)
            {
               //Si no hay casillas se comprueba si hay alguna pieza de ataque de largo alcance
               //que ataque a la pieza en la misma línea que el rey y la pieza
               //Si no hay ninguna se generan los movimientos de la pieza de forma normal
               bbAttacker = bbFullConnection[pieceSquareIndex][kingSquareIndex] & 
                     bbAttackerToSquare[pieceSquareIndex] & bbOppositeOccupied;
               if(bbAttacker != 0)
               {
                  genericPiece = pieceInSquare[Long.numberOfTrailingZeros(bbAttacker)].genericPiece;
                  if(genericPiece != GenericPiece.PAWN && genericPiece != GenericPiece.KING)
                  {
                     //Si hay alguna pieza atacando en esa línea quiere decir que la pieza
                     //sólo se podrá mover a las casillas entre la pieza clavada y el rey y las 
                     //que se encuentran entre la pieza clavada y la pieza que provoca la clavada
                     bbConnection = bbExclusiveConnection[pieceSquareIndex][Long.numberOfTrailingZeros(bbAttacker)] | bbAttacker;
                     bbConnection |= bbExclusiveConnection[pieceSquareIndex][kingSquareIndex];
                     
                     bbAttacked = bbAttacked & bbConnection;
                  }
               }
            }
         }
         
         
         //En este momento en bitboardAtacadas se encuentran las casillas a las que legarmente puede ir
         //la dama
         numAttacked = Long.bitCount(bbAttacked);
         for(int j = 0; j < numAttacked; j++)
         {
            attackedSquareIndex = Long.numberOfTrailingZeros(bbAttacked);
            
            capture = pieceInSquare[attackedSquareIndex];
            mov = new Movement(square[pieceSquareIndex], square[attackedSquareIndex], piece, capture);
            
            movesList.add(mov);
            
            bbAttacked ^= bbSquare[attackedSquareIndex];
         }
         
         
         bbPieceOccupation ^= bbSquare[pieceSquareIndex];
      }
      /************** FIN DE GENERACIÓN DE LOS MOVIMIENTOS *************/
      
   }