Unity 2D随机生成预制体时避免重叠问题求助

问题描述 #

使用带有Box Collider 2D和Sprite Renderer的预制体在屏幕左边界内随机生成，每8秒增加1个预制体直至达到8个上限。随着生成数量增加，预制体出现重叠（即使仍有可用空间），自定义的GetUniqueSpawnPosition方法无法正确检测重叠，尝试100次寻位仍未解决。

原代码 #

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SpikeController : MonoBehaviour
{
    public int initialSpikeCount = 3;          // Initial number of spikes
    public int maxSpikes = 8;                  // Maximum number of spikes
    public int spikesIncreaseInterval = 8;     // Interval for increasing spikes
    public float spikeSpawnInterval = 1.5f;    // Spikes disappear time
    public GameObject spikePrefab;             // Spike prefab

    public Transform LeftBoundary;            

    private int currentSpikeCount;
    private List<GameObject> spikes = new List<GameObject>();

    // Spike size
    public Vector3 spikeSize = new Vector3(2.84f, 2.84f, 2.84f);

    void Start()
    {
        currentSpikeCount = initialSpikeCount;
        SpawnSpikes();
        StartCoroutine(SpikeIncreaseRoutine());
    }

    void Update()
    {
        if (spikes.Count < currentSpikeCount)
        {
            SpawnSpikes();
        }
    }

    private IEnumerator SpikeIncreaseRoutine()
    {
        while (currentSpikeCount < maxSpikes)
        {
            yield return new WaitForSeconds(spikesIncreaseInterval);
            IncreaseSpikeCount();
        }
    }

    private void SpawnSpikes()
    {
        ClearSpikes();  // Remove previous spikes if any

        for (int i = 0; i < currentSpikeCount; i++)
        {
            Vector3 spawnPosition = GetUniqueSpawnPosition();
            GameObject spike = Instantiate(spikePrefab, spawnPosition, Quaternion.Euler(0, 0, 90f)); // Spawning only on the left
            
            // Set the size of the prefab
            spike.transform.localScale = spikeSize;
            
            spikes.Add(spike);
            StartCoroutine(RemoveSpikeAfterDelay(spike, spikeSpawnInterval));
        }
    }

    private Vector3 GetUniqueSpawnPosition()
    {
        BoxCollider2D boundaryCollider = LeftBoundary.GetComponent<BoxCollider2D>();
        float boundaryYMin = LeftBoundary.position.y - boundaryCollider.size.y / 2;
        float boundaryYMax = LeftBoundary.position.y + boundaryCollider.size.y / 2;

        float x = -2.24f; // Fixed position on the left
        float y = 0;

        float spikeHeight = spikeSize.y;  // Spike height

        // Adjust y range to avoid spawning outside the boundary
        float boundaryMin = boundaryYMin + spikeHeight / 2;
        float boundaryMax = boundaryYMax - spikeHeight / 2;

        // Try to find a unique spawn position
        for (int attempt = 0; attempt < 100; attempt++)
        {
            y = Random.Range(boundaryMin, boundaryMax); // Adjusted for the height of the spike

            Vector3 potentialPosition = new Vector3(x, y, 0);

            if (!IsOverlappingWithExistingSpikes(potentialPosition, spikeSize.x, spikeSize.y))
            {
                return potentialPosition;
            }
        }

        Debug.LogWarning("Cannot find unique positions");
        return new Vector3(x, Random.Range(boundaryMin, boundaryMax), 0);
    }

    private bool IsOverlappingWithExistingSpikes(Vector3 position, float width, float height)
    {
        // Check for overlap with existing colliders
        foreach (var spike in spikes)
        {
            if (Vector2.Distance(position, spike.transform.position) < (width / 2 + spikeSize.x / 2))
            {
                return true;
            }
        }

        return false;
    }

    public void IncreaseSpikeCount() 
    {
        if (currentSpikeCount < maxSpikes)
        {
            currentSpikeCount++;
            SpawnSpikes();  // Create new spikes after increasing the count
        }
    }

    private void ClearSpikes()
    {
        foreach (var spike in spikes)
        {
            Destroy(spike);
        }
        spikes.Clear();
    }

    private IEnumerator RemoveSpikeAfterDelay(GameObject spike, float delay)
    {
        yield return new WaitForSeconds(delay);
        spikes.Remove(spike);
        Destroy(spike);
    }
}

问题根源分析 #

1. 重叠检测逻辑错误：预制体旋转90度后，碰撞体的y轴占用对应原预制体的x轴尺寸，但检测时误用了x轴尺寸计算距离，导致判断不准确。
2. 生成逻辑矛盾：每次增加数量时调用ClearSpikes清空所有预制体重生成，同时RemoveSpikeAfterDelay会定时删除单个预制体，触发Update重复生成，逻辑混乱。
3. 边界计算未考虑父物体缩放：LeftBoundary的BoxCollider2D尺寸未结合自身缩放计算，导致边界范围不准确。

修复方案 #

1. 修正重叠检测逻辑 #

因为预制体旋转90度，实际y轴方向的碰撞范围是原size的x值，直接检测y轴间距即可：

private bool IsOverlappingWithExistingSpikes(Vector3 position, float spikeWidth, float spikeHeight)
{
    // 旋转90度后，y轴方向的半占用尺寸为spikeWidth的一半
    float halfYExtent = spikeWidth / 2f;
    foreach (var spike in spikes)
    {
        float yDistance = Mathf.Abs(position.y - spike.transform.position.y);
        // 两个预制体的半高之和即为最小安全间距
        if (yDistance < halfYExtent * 2f)
        {
            return true;
        }
    }
    return false;
}

2. 重构生成逻辑，避免频繁清空 #

改为只补充缺失的预制体，而非全部重生成：

private void SpawnSpikes()
{
    // 仅生成当前数量不足的预制体
    while (spikes.Count < currentSpikeCount)
    {
        Vector3 spawnPosition = GetUniqueSpawnPosition();
        GameObject spike = Instantiate(spikePrefab, spawnPosition, Quaternion.Euler(0, 0, 90f));
        spike.transform.localScale = spikeSize;
        spikes.Add(spike);
        StartCoroutine(RemoveSpikeAfterDelay(spike, spikeSpawnInterval));
    }
}

public void IncreaseSpikeCount() 
{
    if (currentSpikeCount < maxSpikes)
    {
        currentSpikeCount++;
        // 移除此处的SpawnSpikes调用，由Update自动检测补充
    }
}

3. 修正边界计算，考虑父物体缩放 #

计算边界时结合LeftBoundary的缩放值，确保范围准确：

private Vector3 GetUniqueSpawnPosition()
{
    BoxCollider2D boundaryCollider = LeftBoundary.GetComponent<BoxCollider2D>();
    // 计算边界的实际尺寸，乘以父物体的y轴缩放
    Vector2 boundarySize = boundaryCollider.size * LeftBoundary.localScale.y;
    float boundaryYMin = LeftBoundary.position.y - boundarySize.y / 2;
    float boundaryYMax = LeftBoundary.position.y + boundarySize.y / 2;

    float x = -2.24f;
    float y = 0;

    // 旋转后，预制体在y轴的半占用尺寸为spikeSize.x的一半
    float spikeYExtent = spikeSize.x / 2f;
    float boundaryMin = boundaryYMin + spikeYExtent;
    float boundaryMax = boundaryYMax - spikeYExtent;

    for (int attempt = 0; attempt < 100; attempt++)
    {
        y = Random.Range(boundaryMin, boundaryMax);
        Vector3 potentialPosition = new Vector3(x, y, 0);

        if (!IsOverlappingWithExistingSpikes(potentialPosition, spikeSize.x, spikeSize.y))
        {
            return potentialPosition;
        }
    }

    Debug.LogWarning("无法找到不重叠的生成位置");
    return new Vector3(x, Random.Range(boundaryMin, boundaryMax), 0);
}

4. 可选：使用物理碰撞检测增强准确性 #

如果上述修改仍有问题，可直接用Physics2D.OverlapBox检测物理碰撞：

private bool IsOverlappingWithExistingSpikes(Vector3 position, float spikeWidth, float spikeHeight)
{
    // 旋转90度后，碰撞体尺寸为(spikeHeight, spikeWidth)
    Vector2 boxSize = new Vector2(spikeHeight, spikeWidth);
    // 检测对应位置和旋转角度的碰撞体
    Collider2D hit = Physics2D.OverlapBox(position, boxSize, 90f, LayerMask.GetMask("Spike"));
    return hit != null;
}

注意给预制体设置Spike层，避免检测到其他无关物体。

内容的提问来源于stack exchange，提问作者aloe