当前位置：首页 > news >正文

Unity中基于2.5D的碰撞系统

news 2025/7/12 2:32:11

在2.5D游戏中实现精确的碰撞检测是一个关键挑战，因为我们需要在视觉上有深度感的同时保持游戏逻辑的准确性。下面我将详细解析2.5D碰撞系统的实现方法。

1. 2.5D碰撞的核心问题

1.1 Z轴深度与碰撞的关系

视觉表现：物体通过Y轴位置影响Z轴排序，产生深度错觉
逻辑需求：碰撞应该只发生在"同一平面"的物体间
矛盾点：两个物体可能在屏幕上重叠，但逻辑上不应碰撞

1.2 主要解决方案对比

方法	优点	缺点	适用场景
纯2D碰撞	简单高效	无法处理深度	简单2.5D
2D碰撞+Z轴检测	平衡性能与效果	需要额外计算	大多数2.5D
3D碰撞系统	精确	性能开销大	复杂3D投影

2. 混合碰撞系统实现(推荐)

2.1 基础组件设置

[RequireComponent(typeof(BoxCollider2D))]
[RequireComponent(typeof(SpriteRenderer))]
public class Collider2_5D : MonoBehaviour
{
    public float collisionDepthRange = 0.5f; // 视为同一平面的Z轴范围
    private BoxCollider2D col2D;
    
    void Awake()
    {
        col2D = GetComponent<BoxCollider2D>();
        // 根据精灵大小自动调整碰撞体
        col2D.size = GetComponent<SpriteRenderer>().bounds.size;
    }
}

2.2 碰撞检测逻辑

void CheckCollisions()
{
    // 1. 获取所有可能碰撞的物体
    ContactFilter2D filter = new ContactFilter2D();
    filter.SetLayerMask(Physics2D.GetLayerCollisionMask(gameObject.layer));
    List<Collider2D> results = new List<Collider2D>();
    
    // 2. 执行2D物理检测
    int count = col2D.OverlapCollider(filter, results);
    
    // 3. 筛选有效碰撞(考虑Z轴)
    foreach(Collider2D other in results)
    {
        float zDiff = Mathf.Abs(transform.position.z - other.transform.position.z);
        
        if(zDiff <= collisionDepthRange)
        {
            // 真正的有效碰撞处理
            HandleCollision(other.gameObject);
        }
    }
}

3. 高级碰撞处理技术

3.1 分层碰撞系统

public class LayeredCollision : MonoBehaviour
{
    [System.Serializable]
    public struct CollisionLayer
    {
        public string name;
        public float zMin;
        public float zMax;
        public LayerMask interactLayers;
    }
    
    public CollisionLayer[] layers;
    public int currentLayer = 0;
    
    void CheckLayerCollisions()
    {
        CollisionLayer layer = layers[currentLayer];
        transform.position = new Vector3(
            transform.position.x,
            transform.position.y,
            (layer.zMin + layer.zMax) / 2f); // 居中Z位置
            
        // 只检测当前层的碰撞
        Collider2D[] hits = Physics2D.OverlapBoxAll(
            (Vector2)transform.position, 
            GetComponent<BoxCollider2D>().size, 
            0, 
            layer.interactLayers);
            
        foreach(var hit in hits)
        {
            // 确保在Z轴范围内
            if(hit.transform.position.z >= layer.zMin && 
               hit.transform.position.z <= layer.zMax)
            {
                ProcessCollision(hit);
            }
        }
    }
}

3.2 斜坡和高度检测

public class SlopeDetection : MonoBehaviour
{
    public float maxSlopeAngle = 45f;
    public float heightCheckDistance = 0.5f;
    
    void CheckGround()
    {
        RaycastHit2D hit = Physics2D.Raycast(
            transform.position, 
            Vector2.down, 
            heightCheckDistance);
            
        if(hit.collider != null)
        {
            float angle = Vector2.Angle(hit.normal, Vector2.up);
            
            // 坡度处理
            if(angle <= maxSlopeAngle)
            {
                // 可以行走的斜坡
                AdjustPositionOnSlope(hit);
            }
            else
            {
                // 太陡无法攀爬
                BlockMovement();
            }
        }
    }
    
    void AdjustPositionOnSlope(RaycastHit2D hit)
    {
        // 根据法线调整位置
        float adjustAmount = heightCheckDistance - hit.distance;
        transform.position += new Vector3(0, adjustAmount, 0);
    }
}

4. 性能优化方案

4.1 空间分区优化

public class SpatialPartitionCollision : MonoBehaviour
{
    public static Dictionary<Vector2Int, List<Collider2_5D>> grid = 
        new Dictionary<Vector2Int, List<Collider2_5D>>();
    public float cellSize = 2f;
    private Vector2Int lastCell;
    
    void Update()
    {
        Vector2Int currentCell = new Vector2Int(
            Mathf.FloorToInt(transform.position.x / cellSize),
            Mathf.FloorToInt(transform.position.y / cellSize));
            
        if(currentCell != lastCell)
        {
            // 从旧格子移除
            if(grid.ContainsKey(lastCell))
                grid[lastCell].Remove(this);
                
            // 添加到新格子
            if(!grid.ContainsKey(currentCell))
                grid[currentCell] = new List<Collider2_5D>();
                
            grid[currentCell].Add(this);
            lastCell = currentCell;
        }
        
        // 只检查相邻格子的碰撞
        CheckNearbyCells(currentCell);
    }
    
    void CheckNearbyCells(Vector2Int centerCell)
    {
        for(int x = -1; x <= 1; x++)
        {
            for(int y = -1; y <= 1; y++)
            {
                Vector2Int checkCell = centerCell + new Vector2Int(x, y);
                if(grid.TryGetValue(checkCell, out var objects))
                {
                    foreach(var obj in objects)
                    {
                        if(obj != this) CheckCollisionWith(obj);
                    }
                }
            }
        }
    }
}

4.2 碰撞缓存系统

public class CollisionCache : MonoBehaviour
{
    private HashSet<GameObject> lastFrameCollisions = new HashSet<GameObject>();
    private HashSet<GameObject> currentFrameCollisions = new HashSet<GameObject>();
    
    void LateUpdate()
    {
        // 检测碰撞结束
        foreach(var obj in lastFrameCollisions)
        {
            if(!currentFrameCollisions.Contains(obj))
            {
                OnCollisionExit2D(obj);
            }
        }
        
        // 交换集合
        var temp = lastFrameCollisions;
        lastFrameCollisions = currentFrameCollisions;
        currentFrameCollisions = temp;
        currentFrameCollisions.Clear();
    }
    
    void RegisterCollision(GameObject other)
    {
        if(currentFrameCollisions.Add(other) && !lastFrameCollisions.Contains(other))
        {
            OnCollisionEnter2D(other);
        }
    }
}

5. 特殊碰撞场景处理

5.1 平台边缘检测

public class PlatformEdgeDetector : MonoBehaviour
{
    public float edgeCheckDistance = 0.2f;
    public LayerMask platformLayer;
    
    public bool IsNearEdge()
    {
        // 左右两侧检测
        bool leftClear = !Physics2D.Raycast(
            transform.position + Vector3.left * edgeCheckDistance,
            Vector2.down,
            0.1f,
            platformLayer);
            
        bool rightClear = !Physics2D.Raycast(
            transform.position + Vector3.right * edgeCheckDistance,
            Vector2.down,
            0.1f,
            platformLayer);
            
        return leftClear || rightClear;
    }
}

5.2 动态Z轴碰撞调整

public class DynamicZCollision : MonoBehaviour
{
    public AnimationCurve zDepthCurve; // 根据Y位置定义Z深度曲线
    public float depthScale = 0.1f;
    
    void Update()
    {
        // 根据Y位置动态调整Z值
        float zValue = zDepthCurve.Evaluate(transform.position.y) * depthScale;
        transform.position = new Vector3(
            transform.position.x,
            transform.position.y,
            zValue);
            
        // 同时调整碰撞深度范围
        GetComponent<Collider2_5D>().collisionDepthRange = 
            Mathf.Abs(zDepthCurve.Evaluate(transform.position.y + 1f) - 
            Mathf.Abs(zDepthCurve.Evaluate(transform.position.y - 1f));
    }
}