Recomend a build strategy

Welcome to the community! The 'for' loop is your friend here ;)

I just did something like this for an enemy spawning process in my game.

All righty. Well you'll need to familiarize yourself with some common Unity classes. Two things you'll definitely be using are instantiate and Vector3.

Instantiate spawns something at a given location with a given rotation, and Vector3 is a class that describes a point in space (X,Y, and Z) with Y being Up, Z being Forward, and X being Sideways.

Now, you have said you want this grid on a plane, so I imagine you'll want the Y axis to be uniform throughout.

What I would do is this:

1. Make an Empty GameObject and name it 'Grid'

2. Place it at the desired grid location

3. Make a script and attach it to the grid

The script would loosely follow this (I'm just handing you some math don't worry)

Oh and before we move on you should learn about transform. "Every object in a scene has a Transform. It's used to store and manipulate the position, rotation and scale of the object. Every Transform can have a parent, which allows you to apply position, rotation and scale hierarchically. This is the hierarchy seen in the Hierarchy pane. They also support enumerators so you can loop through children using:

 // Moves all transform children 10 units upwards!
 
 for (var child : Transform in transform) {
     child.position += Vector3.up * 10.0;
 }

" So you would have one variable for columns of type int, one variable for rows of type int, one variable for gridWidth in real world units of type float, and another variable of gridHeight in real world units of type float.

You would also have two non-exposed variables (this can be done by putting @HideInInspector on the line before the variable) that are deltaWidth and deltaHeight, the define the width and height between each point on the grid, respectively.

you would then make a 2D array called gridArray of type Vector 3. In UnityScript, you would define it like so:

var gridArray : Vector3[,];

Because things are being indexed, your deltaWidth would be equivalent to (gridWidth / ( columns-1 )) and your deltaHeight would be equivalent to ( gridHeight / ( rows-1 )). I recommend you do this math and cache these values in the Start() function.

you then construct a double-nested for-loop that goes through number of columns and rows, and for each one, assigns a new Vector3 to the current placeholder in the gridArray. My math for this went as follows:

 gridArray[u,i] = new Vector3( transform.position.x + (deltaWidth*i), transform.position.y + ( -deltaHeight*u ), transform.position.z );

with u and i being the for loop placeholders.

Your grid is done! To offset the grid so that your empty gameObject actually exists in the center of the grid, add this (you don't have to if you want it to exist as the upper-left corner):

       gridArray[u,i].x = gridArray[u,i].x - ( gridWidth/2);
       gridArray[u,i].y = gridArray[u,i].y + ( gridHeight/2);  

Now remember that in this code I am constructing a grid that is a flat plane running on the Y and X axes. You need to change the code so that it runs on the X and Z axes.

In your instantiation code, you would just run through it with a 'for' loop and spawn whatever prefab you want every x amount of columns / rows.

And now that I have given most of my code already, I am going to post the rest of it (there is also a useful debugging tool that draws the array for you. Be warned: it is in UnityScript. It is also annoying in the sense that when you change things in the editor, it spits out nasty warnings. I don't know how to fix that. ;)

Good Luck!

-YA

 #pragma strict
 @script ExecuteInEditMode
 var debug : boolean;
 
 var columns : int;
 var rows : int;
 
 var gridWidth : int;
 var gridHeight : int;
 
 @HideInInspector
 var deltaWidth : float;
 @HideInInspector
 var deltaHeight : float;
 @HideInInspector
 var gridArray : Vector3[,];
 
 function Awake () {
 
   //Does the math to find the relative distance between points (Index-Based means we have to subtract 1 from column/row count)
  deltaWidth = ( gridWidth / ( columns-1 ));
  deltaHeight = ( gridHeight / ( rows-1 ));
 
   gridArray = new Vector3[ rows , columns ];
   
   for( var u = 0; u < rows; u++ ){
   
       for( var i = 0; i < columns; i++ ){
           
           //Constructing grid using the transform as the UPPER LEFT CORNER
           gridArray[u,i] = new Vector3( transform.position.x + (deltaWidth*i), transform.position.y + ( -deltaHeight*u ), transform.position.z );
           //These next two lines offset the points so that the transform is now used as the CENTER --(remove these if you want to use it as the corner)--
           gridArray[u,i].x = gridArray[u,i].x - ( gridWidth/2);
           gridArray[u,i].y = gridArray[u,i].y + ( gridHeight/2);          
   }}}
   //Used to draw the grid in Editor
   function DrawGrid(){
       
       for( var q = 0; q < (columns); q++){
           
           var column_top : Vector3 = gridArray[q,0];
         var column_bottom : Vector3 = gridArray[q, (rows-1) ];
         Debug.DrawLine (column_top, column_bottom, Color.red);
           
       }
       
       for( var w = 0; w < (rows); w++){
           
           var row_top : Vector3 = gridArray[0,w];
           var row_bottom : Vector3 = gridArray[ (columns-1), w ];
           Debug.DrawLine ( row_top, row_bottom, Color.red);
           
       }}
   //If debug is active, draw the grid
   function Update(){
       if(debug)    DrawGrid();    
   }