Procedurally generated mesh acting weird.

I follow a tutorial on how to make a procedurally generated mesh. I managed to get through it but I wanted to texture it by face instead of by vertex so I changed the code to have 6 vertexes instead of one, so adjacent faces could be different shades. Now my mesh looks like this: (nvm, it says error parsing the file when I try to upload) It generates the mesh for me but there's other random bits as well. Like there's a flat plane in the middle and it's also visible from underneath, which it wasn't meant to do before. On top of that I can't get it to render colour per face even with six times the vertices. I'll try to put in the code.

Any advice would be appreciated.

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using System.Linq;
 
 [RequireComponent(typeof(MeshFilter))]
 public class MeshGenerator : MonoBehaviour
 {
     Mesh mesh;
     private int MESH_SCALE = 100;
     public AnimationCurve heightCurve;
     public VertArray[] verticies;
     public List<int> triangles;
     public HeightColor[] cols;
 
     public int xSize;
     public int zSize;
     public float frequency = 1;
     public float amplitude = 12;
 
     private List<Color> colors;
     private float minHeight;
     private float maxHeight;
     private Vector3[] points;
 
     public float scale;
     public int octaves;
     public float lacunarity;
 
     public int highnum;
 
     [SerializeField]
     private Gradient gradient;
 
     public int seed;
     
 
     void Start()
     {
         Debug.Log("START");
         mesh = new Mesh();
         GetComponent<MeshFilter>().mesh = mesh;
         StartCoroutine(GenerateMap());
     }
 
     IEnumerator GenerateMap()
     {
         CreateMapShape();
         Debug.Log("CREATED MAP SHAPE");
         yield return new WaitForEndOfFrame();
         CreateTriangles();
         Debug.Log("CREATED TRIANGLES");
         yield return new WaitForEndOfFrame();
         ColorMap();
         Debug.Log("MAP COLORED");
         yield return new WaitForEndOfFrame();
         UpdateMesh();
         Debug.Log("DONE");
     }
 
     void CreateMapShape()
     {
         Vector2[] octaveOffsets = GetOffsetSeed();
 
         if (scale <= 0)
             scale = 0.0001f;
 
         foreach(VertArray v in verticies)
         {
             v.verticies = new Vector3[xSize * zSize];
             for (int o = 0; o < 1; o++)
             {
                 for (int i = 0, z = v.z; z < zSize + v.z; z++) 
                 {
                     for (int x = v.x; x < xSize + v.x; x++)
                     {
                         float noiseHeight = GenerateNoiseHeight(z, x, octaveOffsets);
                         SetMinMaxHeights(noiseHeight);
                         v.verticies[i] = new Vector3(x, noiseHeight, z);
                         i++;
                     }
                 }
             }
         }
     }
 
     Vector2[] GetOffsetSeed()
     {
         System.Random prng = new System.Random(seed);
         Vector2[] octaveOffsets = new Vector2[octaves];
 
         for (int o = 0; o < octaves; o++)
         {
             float offsetX = prng.Next(-100000, 100000);
             float offsetY = prng.Next(-100000, 100000);
             octaveOffsets[o] = new Vector2(offsetX, offsetY);
         }
         return octaveOffsets;
     }
 
     private float GenerateNoiseHeight(int z, int x, Vector2[] offsets)
     {
         amplitude = 12;
         float persistance = 0.5f;
         float freq = frequency;
         float noiseHeight = 0;
 
         for(int y = 0; y < octaves; y++)
         {
             float MapZ = z / scale * freq + offsets[y].y;
             float MapX = x / scale * freq + offsets[y].x;
 
             float perlinValue = (Mathf.PerlinNoise(MapZ, MapX)) * 2 - 1;
             noiseHeight += heightCurve.Evaluate(perlinValue) * amplitude;
             freq *= lacunarity;
             amplitude *= persistance;
         }
         return noiseHeight;
     }
 
     private void SetMinMaxHeights(float noiseHeight)
     {
         if(noiseHeight > maxHeight)
             maxHeight = noiseHeight;
         if (noiseHeight < minHeight)
             minHeight = noiseHeight;
     }
 
     void CreateTriangles()
     {
         triangles = new List<int>();
         int vert = 0;
         int tris = 0;
 
         for(int z = 0; z < zSize; z++)
         {
             for(int x = 0; x < xSize; x++)
             {
                 foreach(VertArray v in verticies)
                 {
                     Debug.Log($"{vert} + {v.x} + ({v.z} * {xSize}) = {vert + v.x + (v.z * xSize)}");
                     triangles.Add(vert + v.x + (v.z * xSize));
                 }
                 vert++;
                 tris++;
             }
 
         }
 /*
         for (int z = 0; z < xSize; z++)
         {
 
             for(int x = 0; x < xSize; x++)
             {
                 triangles[tris + 0] = vert + 0;
                 triangles[tris + 1] = vert + xSize + 1;
                 triangles[tris + 2] = vert + 1;
                 triangles[tris + 3] = vert + 1;
                 triangles[tris + 4] = vert + xSize + 1;
                 triangles[tris + 5] = vert + xSize + 2;
 
                 vert++;
                 tris += 6;
             }
             vert++;
         }
 */
 
     }
 
     void ColorMap()
     {
         colors = new List<Color>();
         float change = Random.Range(-0.2f, 0.2f);
         for (int v = 0; v < 6;)
         {
             
             for (int i = 0, z = 0; z < verticies[v].verticies.Length; z++)
             {
                 foreach (HeightColor h in cols)
                 {
                     //if (verticies[0].verticies[i].y > 2)
                         //Debug.Log($"Max is: {h.max}, Y level is: {verticies[0].verticies[i].y}");
                     if (verticies[v].verticies[i].y < h.max)
                     {
                         colors.Add(new Color(h.color.r + change, h.color.g + change, h.color.b + change));
                         break;
                     }
                 }
                 i++;
             }
             v++;
             Debug.Log("V = " + v);
 
         }
         /*
         List<Color> cool = colors;
         colors = new List<Color>();
         for (int i = 0; i < 6; i++)
         {
             foreach (Color c in cool)
             {
                 colors.Add(c);
             }
         }
         */
     }
 
     void UpdateMesh()
     {
         List <Vector3> verts = new List<Vector3>();
         foreach(VertArray vert in verticies)
         {
             foreach (Vector3 v in vert.verticies)
                 verts.Add(v);
         }
         points = verts.ToArray();
         
         mesh.Clear();
         mesh.vertices = verts.ToArray();
         mesh.triangles = triangles.ToArray();
         mesh.colors = colors.ToArray();
         mesh.name = "Terrain Mesh";
         mesh.RecalculateNormals();
         mesh.RecalculateTangents();
 
         GetComponent<MeshCollider>().sharedMesh = mesh;
         gameObject.transform.localScale = new Vector3(MESH_SCALE, MESH_SCALE, MESH_SCALE);
     }
 
     public void OnDrawGizmos()
     {
         /*
        // Mesh meshy = GetComponent<MeshCollider>().sharedMesh;
         if (points.Length>0)
         {
             //Debug.Log("Should be working");
             
             for(int i = 0; i < triangles.Count;)
             {
                 if(triangles[i] == highnum)
                 {
                     Gizmos.color = Color.red;
                     Vector3 v1 = points[triangles[i]] * MESH_SCALE;
                     Gizmos.DrawSphere(v1, 10);
                     Gizmos.color = Color.green;
                     Vector3 v2 = points[triangles[i+1]] * MESH_SCALE;
                     Gizmos.DrawSphere(v2, 10);
                     Vector3 v3 = points[triangles[i+2]] * MESH_SCALE;
                     Gizmos.DrawSphere(v3, 10);
                     Vector3 v4 = points[triangles[i+3]] * MESH_SCALE;
                     Gizmos.DrawSphere(v4, 10);
                     Vector3 v5 = points[triangles[i+4]] * MESH_SCALE;
                     Gizmos.DrawSphere(v5, 10);
                     Vector3 v6 = points[triangles[i+5]] * MESH_SCALE;
                     Gizmos.DrawSphere(v6, 10);
                     Gizmos.color = Color.blue;
                     
                     Gizmos.DrawLine(v1, v2);
                     Gizmos.DrawLine(v2, v3);
                     Gizmos.DrawLine(v3, v4);
                     Gizmos.DrawLine(v4, v5);
                     Gizmos.DrawLine(v5, v6);
                 }
                 i+=6;
             }
         }
     */
         
         
     }
 }