How can I instantiate a wall in pieces, rather then stretching?

Questions & Answers
1

Hello,
Working on a building game, and currently have my walls set up to a) snap to my X and Z axis, and b) to instantiate as a stretch between the start and end transform.position.

So basically, my wall ends up looking like this -------. I’d like to be able to have a post instantiate every so many units along the wall, so I end up with |—|—|—|, as an example. A little unsure of exactly how to do this. Any help would be appreciated.

Thanks

Below is my current wall generation script.

using UnityEngine;

public class RoadGen : MonoBehaviour
{
    public GameObject start;
    public GameObject end;
    public GameObject mouseTracker;
    public GameObject roadPreFab;
    GameObject road;
    GameObject roadGhost;

    public Vector3 specificVector;
    public Vector3 getWorldPoint;

    public bool goReady;
    bool ghostActive;
    bool zSnapping;
    bool xSnapping;
    ;
    float differenceX;
    float differenceZ;
   
    void Start()
    {
    }
    void Update()
    {
        if (goReady == true)
        {
            getInput();
        }
        specificVector = mouseTracker.transform.position + new Vector3(0.0f, 0.0f, 0.0f);
        snapSet();
    }

    public void buildRoad()
    {
        goReady = true;
        {
            roadGhost = Instantiate(start, specificVector, Quaternion.identity) as GameObject;
            roadGhost.transform.parent = mouseTracker.transform;
        }
    }

    void snapSet()
    {
       findDifference();
            if (differenceX < differenceZ)
            {
                xSnapping = true;
                zSnapping = false;
            }
            else
           {
                zSnapping = true;
                xSnapping = false;
            }       
    }

    void setStart()
    {
        if (goReady == true)
        {
            start.transform.position = gridSnap(specificVector);
            road = (GameObject)Instantiate(roadPreFab, start.transform.position, Quaternion.identity);
            ghostActive = true;
        }
    }

    void findDifference()
    {
        differenceX = Mathf.Abs(specificVector.x - start.transform.position.x);
        differenceZ = Mathf.Abs(specificVector.z - start.transform.position.z);
    }

    void setEnd()
    {
        ghostActive = false;
        end.transform.position = gridSnap(specificVector);
    }

    void adjust()
    {
        end.transform.position = gridSnap(specificVector);     
        if (xSnapping)
        {
            end.transform.position = new Vector3(start.transform.position.x, end.transform.position.y, end.transform.position.z);
        }
        if (zSnapping)
        {
            end.transform.position = new Vector3(end.transform.position.x, end.transform.position.y, start.transform.position.z);
        }
        adjustRoad();
    }

    void adjustRoad()
    {
        start.transform.LookAt(end.transform.position);
        end.transform.LookAt(start.transform.position);
        float distance = Vector3.Distance(start.transform.position, end.transform.position);
        road.transform.position = start.transform.position + distance / 2 * start.transform.forward;
        road.transform.rotation = start.transform.rotation;
        road.transform.localScale = new Vector3(road.transform.localScale.x, road.transform.localScale.y, distance);
    }

    Vector3 gridSnap(Vector3 originalPosition)
    {
        int granularity = 2;
        Vector3 snappedPosition = new Vector3(Mathf.Floor(originalPosition.x / granularity) * granularity, originalPosition.y, Mathf.Floor(originalPosition.z / granularity) * granularity);
        return snappedPosition;
    }

    void getInput()
    {
        if (Input.GetMouseButtonDown(1))
        {
            goReady = false;
            Destroy(roadGhost);
        }
        if (Input.GetMouseButtonDown(0))
        {
            setStart();
        }
        else if (Input.GetMouseButtonUp(0))
        {
            setEnd();
        }
        else
        {
            if (ghostActive)
            {
                adjust();
            }
        }
    }
}
2

I figured it out. Not sure if optimal but… Added to the bottom of setEndPoles. Dist can be adjusted to whatever spacing you prefer. If any suggestions on it, let me know. Thanks!

 void setEndPoles()
    {
      
        GameObject p1 = (GameObject)Instantiate(start, start.transform.position, start.transform.rotation);
        GameObject p2 = (GameObject)Instantiate(end, end.transform.position, end.transform.rotation);
        p1.tag = "Pole";
        p2.tag = "Pole";
        poles.Add(p1);
        poles.Add(p2);
        Vector3 spacing = p2.transform.position - p1.transform.position;
        for (int dist = 2; dist < spacing.magnitude; dist += 2)
        {
            GameObject midPoles = GameObject.Instantiate(start);
            midPoles.transform.position = p1.transform.position + spacing.normalized * dist;
        }
    }