Unity开发问题：获取OnCollision事件触发源、指定Collider触发玩家跳跃及全局碰撞检测实现

Hey there! Let's break down your Unity questions one by one, since you're working on a player controller with specific collision-based jump requirements. I've got you covered:

When using OnCollisionEnter, OnCollisionStay, or OnCollisionExit, the Collision parameter passed to these methods gives you full access to both objects involved in the collision:

• Use collision.gameObject to get the other GameObject that collided with your script's object.
• Use collision.collider to get the specific Collider component on that other object.
• To check if the collision involves your own specified Collider (like the Floor Collider child), you can compare it to a reference:

  // In your PlayerController script
  public Collider groundCollider; // Assign your Floor Collider in the Inspector
  
  void OnCollisionEnter(Collision collision)
  {
      // Verify if the collision includes your target Floor Collider
      bool isGroundColliderInvolved = collision.collider == groundCollider 
          || collision.otherCollider == groundCollider;
  }
  

Given your hierarchy (Capsule → Floor Collider), a critical detail to note: collision events only trigger on the GameObject that has both the Collider and the script attached. Since your Floor Collider is a child of the Capsule, your PlayerController script (on the Capsule) won't automatically receive collision events from the child. Here's a clean solution:

Step 1: Add a helper script to your Floor Collider #

Create GroundColliderChecker and attach it directly to your Floor Collider:

using UnityEngine;

public class GroundColliderChecker : MonoBehaviour
{
    private PlayerController playerController;

    void Awake()
    {
        // Fetch the parent PlayerController script
        playerController = GetComponentInParent<PlayerController>();
    }

    void OnCollisionEnter(Collision collision)
    {
        // Notify the player controller we've made contact with a surface
        playerController.SetCanJump(true);
        // Optional: Pass collision data if you need to validate the other object
        // playerController.OnGroundCollisionEnter(collision);
    }

    void OnCollisionExit(Collision collision)
    {
        // Notify the player controller we've left the surface
        playerController.SetCanJump(false);
    }
}

Step 2: Update your PlayerController script #

Modify the controller to track jump permission and handle input:

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    private bool canJump = false;
    public Rigidbody playerRigidbody; // Assign your Capsule's Rigidbody

    public void SetCanJump(bool value)
    {
        canJump = value;
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space) && canJump)
        {
            // Execute jump logic (adjust force to fit your game)
            playerRigidbody.AddForce(Vector3.up * 7f, ForceMode.Impulse);
            canJump = false; // Prevent double-jumping until landing again
        }
    }
}

This ensures jumps are only allowed when your specific Floor Collider is in contact with any object. If you want to restrict jumps to only ground surfaces, add an extra check like collision.gameObject.CompareTag("Ground") in the helper script.

Yes, OnCollision events only trigger under these conditions:

1. The GameObject has a non-trigger Collider component (triggers use OnTrigger events instead).
2. The GameObject has a script with OnCollision methods attached.
3. Unity's collision requirements are met: At least one of the two colliding GameObjects must have a non-kinematic Rigidbody (kinematic Rigidbodies only trigger collisions with non-kinematic ones, or other kinematic Rigidbodies if enabled in Physics settings).

To handle collisions for other objects, you have two reliable options:

• Attach scripts directly: Add a small collision handler script to any GameObject you need to monitor, and have it communicate with your PlayerController via events, direct references, or a singleton pattern.
• Use collision messaging: Enable SendMessageUpwards on the Collider component (in the Inspector) to pass events up to parent objects, but explicit script communication is more maintainable.

If you need to monitor all collisions in the scene (not just those involving your player), Unity offers efficient ways to do this:

Option 1: Subscribe to Physics Contact Events (Unity 2020.1+) #

Use the global Physics.contactEvent to listen for every collision. This avoids attaching scripts to every object and is lightweight:

using UnityEngine;

public class GlobalCollisionListener : MonoBehaviour
{
    void OnEnable()
    {
        // Subscribe to the global collision event
        Physics.contactEvent += HandleGlobalCollision;
    }

    void OnDisable()
    {
        // Unsubscribe to prevent memory leaks
        Physics.contactEvent -= HandleGlobalCollision;
    }

    void HandleGlobalCollision(ContactPair pair)
    {
        // Get both colliding objects
        GameObject objA = pair.colliderObjectA;
        GameObject objB = pair.colliderObjectB;

        // Filter to only collisions you care about (e.g., player-related)
        if (objA.CompareTag("Player") || objB.CompareTag("Player"))
        {
            // Your custom logic here (e.g., log the collision, play a sound)
            Debug.Log($"Player collided with: {objA == gameObject ? objB.name : objA.name}");
        }
    }
}

Option 2: Overlap/Raycast Checks #

For simpler global monitoring (like ground contact checks), use Physics.OverlapSphere or Physics.Raycast in a global manager script run every frame. This works in older Unity versions but is less efficient than contact events.

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