Making a 2D random cave generator. No errors in script or console, but nothing happens. Can anyone tell me why?

I the original code for the 3D Procedural Cave Generation to produce a map of 2D Sprites. It won't do anything though even though it isn't throwing any errors. Can anyone assist please?

 using UnityEngine;
 using System.Collections;
 using System;
 
 public class MapGenerator : MonoBehaviour {
 
     public int width;
     public int height;
 
     public GameObject wallSprite;
 
     public string seed;
     public bool useRandomSeed;
 
     [Range(0,100)]
     public int randomFillPercent;
 
     int[,] map;
 
     void Start() {
         GenerateMap();
     }
 
     void Update() {
         if (Input.GetMouseButtonDown(0)) {
             GenerateMap();
         }
     }
 
     void GenerateMap() {
         map = new int[width,height];
         RandomFillMap();
 
         for (int i = 0; i < 5; i ++) {
             SmoothMap();
         }
     }
 
 
     void RandomFillMap() {
         if (useRandomSeed) {
             seed = Time.time.ToString();
         }
 
         System.Random pseudoRandom = new System.Random(seed.GetHashCode());
 
         for (int x = 0; x < width; x ++) {
             for (int y = 0; y < height; y ++) {
                 if (x == 0 || x == width-1 || y == 0 || y == height -1) {
                     map[x,y] = 1;
                 }
                 else {
                     map[x,y] = (pseudoRandom.Next(0,100) < randomFillPercent)? 1: 0;
                 }
             }
         }
     }
 
     void SmoothMap() {
         for (int x = 0; x < width; x ++) {
             for (int y = 0; y < height; y ++) {
                 int neighbourWallSprite = GetSurroundingWallCount(x,y);
 
                 if (neighbourWallSprite > 4)
                     map[x,y] = 1;
                 else if (neighbourWallSprite < 4)
                     map[x,y] = 0;
 
             }
         }
     }
 
     int GetSurroundingWallCount(int gridX, int gridY) {
         int wallCount = 0;
         for (int neighbourX = gridX - 1; neighbourX <= gridX + 1; neighbourX ++) {
             for (int neighbourY = gridY - 1; neighbourY <= gridY + 1; neighbourY ++) {
                 if (neighbourX >= 0 && neighbourX < width && neighbourY >= 0 && neighbourY < height) {
                     if (neighbourX != gridX || neighbourY != gridY) {
                         wallCount += map[neighbourX,neighbourY];
                     }
                 }
                 else {
                     wallCount ++;
                 }
             }
         }
 
         return wallCount;
     }
     Vector3 CoordToWorldPoint(Coord wallSprite)
     {
         return new Vector3(-width / 2 + .5f + wallSprite.wallSpriteX, 2, -height / 2 + .5f + wallSprite.wallSpriteY);
     }
     struct Coord
     {
         public int wallSpriteX;
         public int wallSpriteY;
 
         public Coord(int x, int y)
         {
             wallSpriteX = x;
             wallSpriteY = y;
         }
     }
 
     void CreateSpriteMap(int[,] borderedMap) {
         if (GameObject.Find ("Map2D")) {
             Destroy (GameObject.Find ("Map2D"));
         }
         GameObject holder = new GameObject ("Map2D");
 
         for (int x = 0; x < borderedMap.GetLength (0); x++) {
             for (int y = 0; y < borderedMap.GetLength (1); y++) {
                 if (borderedMap [x, y] == 1) {
                     Vector3 pos3D = CoordToWorldPoint (new Coord(x, y));
                     Vector3 pos2D = new Vector3 (pos3D.x, pos3D.z, 0);
                     GameObject newWallSprite = Instantiate (wallSprite, pos2D, Quaternion.identity) as GameObject;
                     newWallSprite.transform.parent = holder.transform;}
                 }
             }
         }
     }