Mesh creation during runtime

In this code, the vertices are not positionated at all. There are a lot of mesh generation tutorials for Unity, check out this one:

Procedural generated mesh in Unity

as well as the Scripting API for Unity's Mesh class.

Well, it isn't? Now i'm really confused. This is the original script, in javascript, found in one of unity's procedural examples:

 var heightMap : Texture2D;
 var material : Material;
 var size = Vector3(200, 30, 200);
 
 function Start ()
 {
     GenerateHeightmap();
 }
 
 function GenerateHeightmap ()
 {
     // Create the game object containing the renderer
     gameObject.AddComponent(MeshFilter);
     gameObject.AddComponent.<MeshRenderer>();
     if (material)
         GetComponent.<Renderer>().material = material;
     else
         GetComponent.<Renderer>().material.color = Color.white;
 
     // Retrieve a mesh instance
     var mesh : Mesh = GetComponent(MeshFilter).mesh;
 
     var width : int = Mathf.Min(heightMap.width, 255);
     var height : int = Mathf.Min(heightMap.height, 255);
     var y = 0;
     var x = 0;
 
     // Build vertices and UVs
     var vertices = new Vector3[height * width];
     var uv = new Vector2[height * width];
     var tangents = new Vector4[height * width];
     
     var uvScale = Vector2 (1.0 / (width - 1), 1.0 / (height - 1));
     var sizeScale = Vector3 (size.x / (width - 1), size.y, size.z / (height - 1));
     
     for (y=0;y<height;y++)
     {
         for (x=0;x<width;x++)
         {
             var pixelHeight = heightMap.GetPixel(x, y).grayscale;
             var vertex = Vector3 (x, pixelHeight, y);
             vertices[y*width + x] = Vector3.Scale(sizeScale, vertex);
             uv[y*width + x] = Vector2.Scale(Vector2 (x, y), uvScale);
 
             // Calculate tangent vector: a vector that goes from previous vertex
             // to next along X direction. We need tangents if we intend to
             // use bumpmap shaders on the mesh.
             var vertexL = Vector3( x-1, heightMap.GetPixel(x-1, y).grayscale, y );
             var vertexR = Vector3( x+1, heightMap.GetPixel(x+1, y).grayscale, y );
             var tan = Vector3.Scale( sizeScale, vertexR - vertexL ).normalized;
             tangents[y*width + x] = Vector4( tan.x, tan.y, tan.z, -1.0 );
         }
     }
     
     // Assign them to the mesh
     mesh.vertices = vertices;
     mesh.uv = uv;
 
     // Build triangle indices: 3 indices into vertex array for each triangle
     var triangles = new int[(height - 1) * (width - 1) * 6];
     var index = 0;
     for (y=0;y<height-1;y++)
     {
         for (x=0;x<width-1;x++)
         {
             // For each grid cell output two triangles
             triangles[index++] = (y     * width) + x;
             triangles[index++] = ((y+1) * width) + x;
             triangles[index++] = (y     * width) + x + 1;
 
             triangles[index++] = ((y+1) * width) + x;
             triangles[index++] = ((y+1) * width) + x + 1;
             triangles[index++] = (y     * width) + x + 1;
         }
     }
     // And assign them to the mesh
     mesh.triangles = triangles;
         
     // Auto-calculate vertex normals from the mesh
     mesh.RecalculateNormals();
     
     // Assign tangents after recalculating normals
     mesh.tangents = tangents;
 }

Lines 28-54 set the position of the vertices (the points). It also sets up the uvs (used for textures). Then lines 55-75 build the triangles from the vertices.

Every int in int[]triangles is the index of a vertex in Vector3[]vertices. Every 3 ints in int[]triangles defines 1 triangles.

Could you give me an example of how could I change the position of a single vertex? Also, how can I make both triangles separated from each other? This code is really complex for me. I'm really trying to understand it. I can't visualize how does it get each vertex and sets up a position for it.