Нерест случайных платформ в единстве

Question

Так что в моем стремлении сделать игру, похожую на очень популярную зигзагообразную игру, я застрял на случайно генерируемых платформах.Платформы генерируют случайным образом в направлениях X, -X, Z, -Z.Я написал свой код, где он генерирует платформы.Я мог бы использовать очень длинный подход (альтернативные подходы, если таковые имеются)

                void Start () 
                {
                    lastPos = platform.transform.position;
                    size = platform.transform.localScale.x;

                    InvokeRepeating("SpawnXZ",1f,0.2f);
                }

                void SpawnX()
                {   
                    Vector3 pos = lastPos;
                    pos.x += size;
                    lastPos = pos;
                    Instantiate(platform, pos, Quaternion.identity);    
                }

                void SpawnZ()
                {
                    Vector3 pos = lastPos;
                    pos.z += size;
                    lastPos = pos;
                    Instantiate(platform, pos, Quaternion.identity); 
                }

                void SpawnNegX()
                {
                    Vector3 pos = lastPos;
                    pos.x -= size;
                    lastPos = pos;
                    Instantiate(platform, pos, Quaternion.identity);  
                }

                void SpawnNegZ()
                {
                    Vector3 pos = lastPos;
                    pos.z -= size;
                    lastPos = pos;
                    Instantiate(platform, pos, Quaternion.identity);
                }

                void SpawnXZ()
                {

                        int rand = Random.Range(0, 6);
                        if (rand < 3)
                        {
                                SpawnX();
                        }
                        else if(rand >= 3)
                        {
                                SpawnZ();
                        }

                        if(--counter == 0) { CancelInvoke("SpawnXZ"); };


                    if(counter == 0)
                    {   
                        counter = 25;
                        int r = Random.Range(0,2);
                        if(r == 0)
                        {   
                            InvokeRepeating("SpawnNegXZ",0f,0.2f);
                        }
                        else
                        {       
                            InvokeRepeating("SpawnXNegZ",0f,0.2f);
                        }
                    }

                }

                void SpawnNegXZ()
                {
                    int rand = Random.Range(0, 6);
                        if (rand < 3)
                        {   
                                SpawnNegX();
                        }
                        else if(rand >= 3)
                        {   
                                SpawnZ();
                        }

                    if(--counter == 0) { CancelInvoke("SpawnNegXZ"); };


                    if(counter == 0)
                    {   
                        counter = 25;
                        int r = Random.Range(0,2);
                        if(r == 0)
                        {   
                            InvokeRepeating("SpawnXZ",0f,0.2f);
                        }
                        else
                        {   
                            InvokeRepeating("SpawnNegXNegZ",0f,0.2f);
                        }
                    }
                }

                void SpawnXNegZ()
                {
                        int rand = Random.Range(0, 6);
                        if (rand < 3)
                        {   
                                SpawnX();
                        }
                        else if(rand >= 3)
                        {   
                                SpawnNegZ();
                        }       


                    if(--counter == 0) { CancelInvoke("SpawnXNegZ"); };


                    if(counter == 0)
                    {   
                        counter = 25;
                        int r = Random.Range(0,2);
                        if(r == 0)
                        {   
                            InvokeRepeating("SpawnXZ",0f,0.2f);
                        }
                        else
                        {   
                            InvokeRepeating("SpawnNegXNegZ",0f,0.2f);
                        }
                    }
                }

                void SpawnNegXNegZ()
                {

                        int rand = Random.Range(0, 6);
                        if (rand < 3)
                        {
                                SpawnNegX();    
                        }
                        else if(rand >= 3)
                        {   
                                SpawnNegZ();
                        }

                    if(--counter == 0) { CancelInvoke("SpawnNegXNegZ"); };


                    if(counter == 0)
                    {   
                        counter = 25;
                        int r = Random.Range(0,2);
                        if(r == 0)
                        {   
                            InvokeRepeating("SpawnNegXZ",0f,0.2f);
                        }
                        else
                        {   
                            InvokeRepeating("SpawnXNegZ",0f,0.2f);
                        }
                    }
                }

У меня есть дубинки xz, -xz, x -z и -x -z.Сначала я вызываю платформу в направлении X и Z, затем переключаюсь на -XZ или x -Z и так далее.Но есть 2 основных вопроса.

PS: эти маленькие черные квадраты - не что иное, как алмазы (игнорируйте их).

Онилибо образуют блок 2X2, либо перекрывают друг друга.

Как мне избежать этого?или есть более простой способ создания платформ, которые мне не хватает.

Answer 1

Вам нужен массив, чтобы указать, какие плитки заняты:

bool[,] tiles = new bool[N,N];

или словарь

Dictionary<XZ, bool> tiles = new Dictionary<XZ, bool>();
public struct XZ { public int X; public int Z; }

всякий раз, когда плитка порождается, проверьте значение, чтобы увидеть, возможно лиspawn или нет:

           void SpawnXZ()
           {
                int x = (int) (lastpos.x / size);
                int z = (int) (lastpos.z / size);

                int rand = Random.Range(0, 6);
                if (rand < 3 && !tiles[x + 1, z])
                {
                    SpawnX();
                    tiles[x + 1, z] = true;
                }
                else if(rand >= 3 && && !tiles[x, z + 1])
                {
                    SpawnZ();
                    tiles[x, z + 1] = true;
                }
                else
                {
                     ...
                }

Обратите внимание, что этот код не будет работать, и это всего лишь отправная точка для его дальнейшего развития.