Unity 3D：如何进行地形流？

Question

I want to make a terrain mechanism that will work according to my character's position. I am only working on the y-axis. And the fundamental composition of my game is, that my character(a sphere) goes up in the y-axis on tapping, and as I am on the y-axis as soon as I stop tapping no force is applied in an upward direction and gravity kicks in so the sphere starts falling.

What I basically want to do is, I have made Crossy road type roads and the sphere will go up and there are cars incoming from the left and right direction on these roads(terrains) and I want that as soon as my player goes up and gets to a specific position, say (0,10) I want the terrain mechanism to kick in and lock the gap from the first and last terrain, like at (0,10) position of sphere, there are 10 terrains below it and 10 above it. And from now on I want it to go up in chunks, like say if the player moved to (0,12) then the terrain at (0,1) gets destroyed and new one spawn at (0,2), and the same happen at the top. Kind of like min and max, like if position is (0,15) min = (0,5) and max = (0,25). All my terrains are prefabs.

I am kinda bad at explaining so I explained in the word file below. Please check Please answer, I would really appreciate it.

[Detailed] https://drive.google.com/file/d/1iDmaq-8hGVPNldbpM81axYaJ1PXVcDoo/view?usp=drivesdk

Answer 1

If I understand your question correctly you are trying to find out which terrains to spawn (aka. choose from your terrain list). The math behind this is actually fairly simple:

public class TerrainLoader : MonoBehaviour
{
    private const float STEP_HEIGHT = 1;
    private const int NR_OF_STEPS_BELOW = 10;
    private const int NR_OF_STEPS_ABOVE = 10;

    private int currentMin;
    private int currentMax;
    
    [SerializeField] private Transform player;

    private void Awake()
    {
        if(player == null)
        {
            Debug.LogError("no player set");
            enabled = false;
            return;
        }
        Check();
    }

    private void Update()
    {
        // Can be moved to a coroutine. Checking in Update is inefficient.
        Check();
    }

    /// <summary>
    /// Checks if player reached a new step
    /// </summary>
    private void Check()
    {
        int currentStep = player.position.y / STEP_HEIGHT;
        int minStep = Mathf.Max(0, currentStep - NR_OF_STEPS_BELOW);
        int usedStepsBelow = currentStep - minStep;
        int maxStep = currentStep + NR_OF_STEPS_ABOVE + (NR_OF_STEPS_BELOW - usedStepsBelow);

        if(minStep == currentMin && maxStep == currentMax)
            return;

        LoadTerrain(minStep, maxStep);
    }

    /// <summary>
    /// Loads terrain between min and max steps.
    /// </summary>
    private void LoadTerrain(int min, int max)
    {
        for (int i = currentMin; i < min; i++)
        {
            UnloadTerrain(i);
        }

        for (int i = min; i < max; i++)
        {
            LoadTerrain(i);
        }

        for (int i = max; i < currentMax; i++)
        {
            UnloadTerrain(i);
        }

        currentMin = min;
        currentMax = max;
    }

    /// <summary>
    /// Loads a certain terrain step if it is not loaded already
    /// </summary>
    private void LoadTerrain(int index)
    {
        if(IsTerrainLoaded(index))
            return;

        // TODO: implement
    }

    /// <summary>
    /// Checks if a certain terrain step is already loaded
    /// </summary>
    private bool IsTerrainLoaded(int index)
    {
        // TODO: implement
    }

    /// <summary>
    /// Unloads a certain terrain step
    /// </summary>
    private void UnloadTerrain(int index)
    {
        // TODO: implement
    }
}

You could store your terrains in as array inside this class or make them addressable as loadable assets, depending on the complexity of your future/finished software.

Calculating the destined y position of each terrain is simply

terrainIndex * STEP_HEIGHT

NOTE: If you have lots of steps you will need a spawning mechanism sooner or later moving your player (and the whole world with him) back to the origin if he moves far away. (You may read about float imprecision for this issue.)