Having trouble with triangles in mesh gen

So I'm currently using a script to generate a mesh for a 2d grid-based game I'm planning to make, but for some reason, when I apply a random color to the material during generation,it shows a peculiar occurrence...

Here's the code for it: using UnityEngine; using System.Collections;

 [RequireComponent(typeof(MeshFilter))]
 [RequireComponent(typeof(MeshCollider))]
 [RequireComponent(typeof(MeshRenderer))]
 
 public class GridScript : MonoBehaviour {
 
     // Grid and tile size variables.
     public int size_x;
     public int size_y;
     public int tileSize;
 
     // Tile types and colliders
     string[,] tileType;
 
 
 
 
 
     // Use this for initialization
     void Start() {
 
         // Initialize the Grid Data variables.
         tileType = new string[size_x, size_y];
 
         // Run init functions.
         InitGrid();
         }
 
     void Update() {
         if(Input.GetMouseButtonDown(0)) {
             processGridClick();
             }
         }
 
 
 
     void genGridData() {
         for (int x = 0; x < size_x; x++) {
         for (int y = 0; y < size_y; y++) {
 
             tileType[x, y] = "empty";
         }
         }
         tileType[5, 5] = "wall";
 
     }
 
 
 
     public void processGridClick() {
         Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
         RaycastHit hitInfo;
 
         if (collider.Raycast(ray, out hitInfo, Mathf.Infinity)) {
 
             int x = Mathf.FloorToInt(hitInfo.point.x / tileSize);
             int y = Mathf.FloorToInt(hitInfo.point.y / tileSize);
             Debug.Log(tileType[x,y]);
         }
     }
 
 
 
 
     public void buildTexture() {
         int texWidth = 10;
         int texHeight = 10;
         Texture2D texture = new Texture2D(texWidth, texHeight);
 
         for (int y = 0; y < texHeight; y++) {
             for (int x = 0; x < texWidth; x++) {
                 Color c = new Color(Random.Range  (0f, 1f), Random.Range (0f, 1f) , Random.Range (0f, 1f) );
 
                 texture.SetPixel(x, y, c);
             
             }
         }
 
         texture.filterMode = FilterMode.Point;
         texture.Apply();
         MeshRenderer mesh_renderer = GetComponent<MeshRenderer>();
         mesh_renderer.sharedMaterials[0].mainTexture = texture;
 
         }
 
         public void InitGrid() {
 
             // Initiate the required mesh variables.
             int numTiles = size_x * size_y;
             int vsize_x = size_x + 1;
             int vsize_y = size_y + 1;
             int numVerts = vsize_x * vsize_y;
             int numTris = numTiles * 2;
 
             // Initiate the mesh data.
             Vector3[] vertices = new Vector3[numVerts];
             Vector3[] normals = new Vector3[numVerts];
             Vector2[] uv = new Vector2[numVerts];
             int[] triangles = new int[numTris * 3];
 
 
             // For loops to full the vertices, normals, uvs, and triangles of the mesh.
             int x, y;
             for (y = 0; y < vsize_y; y++) {
                 for (x = 0; x < vsize_x; x++) {
                     vertices[y * vsize_x + x] = new Vector3(x * tileSize, y * tileSize, 0);
                     normals[y * vsize_x + x] = Vector3.forward;
                     uv[y * size_x + x] = new Vector2((float)x / size_x, (float)y / size_y);
                     }
                 }
 
             for (y = 0; y < size_y; y++) {
                 for (x = 0; x < size_x; x++) {
                     int squareIndex = y * size_x + x;
                     int triOffset = squareIndex * 6;
                     triangles[triOffset + 0] = y * vsize_x + x +           0;
                     triangles[triOffset + 1] = y * vsize_x + x + vsize_x + 0;
                     triangles[triOffset + 2] = y * vsize_x + x + vsize_x + 1;
 
                     triangles[triOffset + 3] = y * vsize_x + x +           0;
                     triangles[triOffset + 4] = y * vsize_x + x + vsize_x + 1;
                     triangles[triOffset + 5] = y * vsize_x + x +           1;
                     }
                 }
 
             // Create the mesh itself, and assign the variables used to manipulate it.
             Mesh mesh = new Mesh();
             mesh.vertices = vertices;
             mesh.triangles = triangles;
             mesh.normals = normals;
             mesh.uv = uv;
             MeshFilter mesh_filter = GetComponent<MeshFilter>();
             MeshCollider mesh_collider = GetComponent<MeshCollider>();
 
             mesh_filter.mesh = mesh;
             mesh_collider.sharedMesh = mesh;
 
             buildTexture();
 
             } // End of initGrid
 } // End of script

it's quite a bit, but something tells me the trouble is in initGrid... When it generates, the top triangles and bottom ones don't lie within the same quad, but I just can't seem to find what's causing it...