Easy Learn C#

Types of Colliders:

• Box Collider: Simple rectangular shape, good for boxes, crates, buildings
• Sphere Collider: Spherical shape, good for balls, projectiles
• Capsule Collider: Pill-shaped, good for character controllers
• Mesh Collider: Follows the exact shape of a mesh, more expensive but precise
• Wheel Collider: Specialized for vehicle wheels with suspension and friction
• Terrain Collider: For Unity terrain objects
• 2D Variants: Box, Circle, Polygon, Edge, and Composite colliders for 2D games

Rigidbody Properties:

• Mass: How heavy the object is (affects physics interactions)
• Drag/Angular Drag: How quickly the object slows down when moving/rotating
• Use Gravity: Whether the object is affected by gravity
• Is Kinematic: When enabled, the object isn't affected by physics (useful for moving platforms)
• Interpolate: Smooths position between physics updates
• Collision Detection: Controls how collision detection works at high speeds
• Constraints: Freeze position or rotation on specific axes

Collision Event Methods:

using UnityEngine;

public class CollisionExample : MonoBehaviour
{
    // COLLISION EVENTS (physical collisions with non-trigger colliders)
    
    // Called when this collider/rigidbody begins touching another collider/rigidbody
    void OnCollisionEnter(Collision collision)
    {
        Debug.Log("Collision began with: " + collision.gameObject.name);
        
        // Get information about the collision
        
        // The GameObject we collided with
        GameObject otherObject = collision.gameObject;
        
        // The contact points (where the objects are touching)
        ContactPoint contact = collision.contacts[0];
        
        // The collision normal (direction of the impact)
        Vector3 normal = contact.normal;
        
        // The point where the collision occurred
        Vector3 point = contact.point;
        
        // The relative velocity of the collision
        Vector3 relativeVelocity = collision.relativeVelocity;
        
        // The impulse force of the collision
        float impulse = collision.impulse.magnitude;
        
        // Example: Check the tag of the object we collided with
        if (otherObject.CompareTag("Enemy"))
        {
            TakeDamage(10);
            // Handle collision with enemy
        }
        else if (otherObject.CompareTag("Ground"))
        {
            // Handle landing on ground
            PlayLandingSound();
        }
        
        // Example: Apply damage based on collision force
        float damageAmount = impulse / 10f;
        if (damageAmount > 5f)
        {
            TakeDamage(Mathf.RoundToInt(damageAmount));
        }
        
        // Visual feedback at collision point
        CreateImpactEffect(point, normal);
    }
    
    // Called each frame while the collision is active
    void OnCollisionStay(Collision collision)
    {
        // This runs every frame that the objects remain in contact
        
        // Example: Slowly push back against the object
        Rigidbody rb = GetComponent();
        if (rb != null)
        {
            Vector3 pushDirection = transform.position - collision.transform.position;
            pushDirection.Normalize();
            rb.AddForce(pushDirection * 0.5f);
        }
    }
    
    // Called when this collider/rigidbody stops touching another collider/rigidbody
    void OnCollisionExit(Collision collision)
    {
        Debug.Log("Collision ended with: " + collision.gameObject.name);
        
        // Example: Play a separation sound
        PlaySeparationSound();
    }
    
    // TRIGGER EVENTS (overlaps with trigger colliders)
    
    // Called when this collider enters a trigger collider
    void OnTriggerEnter(Collider other)
    {
        Debug.Log("Trigger entered: " + other.gameObject.name);
        
        // Example: Player enters a trigger zone
        if (other.CompareTag("Player"))
        {
            // Activate a checkpoint
            ActivateCheckpoint();
        }
        else if (other.CompareTag("Pickup"))
        {
            // Collect an item
            CollectItem(other.gameObject);
        }
        else if (other.CompareTag("TrapZone"))
        {
            // Enter a dangerous area
            EnterDangerZone();
        }
    }
    
    // Called each frame while this collider is in a trigger
    void OnTriggerStay(Collider other)
    {
        // Example: Player is in a healing zone
        if (other.CompareTag("HealZone"))
        {
            // Heal the player gradually
            Heal(Time.deltaTime * 5f);
        }
        else if (other.CompareTag("DamageZone"))
        {
            // Damage the player gradually
            TakeDamage(Time.deltaTime * 10f);
        }
    }
    
    // Called when this collider exits a trigger collider
    void OnTriggerExit(Collider other)
    {
        Debug.Log("Trigger exited: " + other.gameObject.name);
        
        // Example: Player exits a trigger zone
        if (other.CompareTag("SafeZone"))
        {
            // No longer in the safe zone
            ExitSafeZone();
        }
    }
    
    // 2D COLLISION EVENTS (for 2D physics)
    
    void OnCollisionEnter2D(Collision2D collision)
    {
        // Similar to OnCollisionEnter but for 2D physics
        Debug.Log("2D collision started with: " + collision.gameObject.name);
    }
    
    void OnCollisionStay2D(Collision2D collision)
    {
        // Called each frame for active 2D collisions
    }
    
    void OnCollisionExit2D(Collision2D collision)
    {
        // Called when a 2D collision ends
    }
    
    void OnTriggerEnter2D(Collider2D other)
    {
        // Similar to OnTriggerEnter but for 2D triggers
    }
    
    void OnTriggerStay2D(Collider2D other)
    {
        // Called each frame for active 2D triggers
    }
    
    void OnTriggerExit2D(Collider2D other)
    {
        // Called when exiting a 2D trigger
    }
    
    // Example helper methods (would be implemented in real code)
    void TakeDamage(float amount)
    {
        Debug.Log("Taking damage: " + amount);
    }
    
    void PlayLandingSound()
    {
        Debug.Log("Playing landing sound");
    }
    
    void CreateImpactEffect(Vector3 position, Vector3 normal)
    {
        Debug.Log("Creating impact effect at " + position);
    }
    
    void PlaySeparationSound()
    {
        Debug.Log("Playing separation sound");
    }
    
    void ActivateCheckpoint()
    {
        Debug.Log("Checkpoint activated");
    }
    
    void CollectItem(GameObject item)
    {
        Debug.Log("Collecting item: " + item.name);
        Destroy(item);
    }
    
    void EnterDangerZone()
    {
        Debug.Log("Entered danger zone");
    }
    
    void Heal(float amount)
    {
        Debug.Log("Healing for: " + amount);
    }
    
    void ExitSafeZone()
    {
        Debug.Log("Exited safe zone");
    }
}
                            

Raycasting and Overlap Testing:

using UnityEngine;

public class ManualCollisionDetection : MonoBehaviour
{
    public float raycastDistance = 10f;
    public LayerMask raycastLayers;
    
    void Update()
    {
        // RAYCASTING EXAMPLES
        
        // Simple raycast
        RaycastHit hit;
        if (Physics.Raycast(transform.position, transform.forward, out hit, raycastDistance))
        {
            // Something was hit
            Debug.Log("Hit object: " + hit.collider.gameObject.name);
            Debug.Log("Hit point: " + hit.point);
            Debug.Log("Hit normal: " + hit.normal);
            Debug.Log("Distance: " + hit.distance);
            
            // You can get the material at the hit point
            if (hit.collider.sharedMaterial != null)
            {
                Debug.Log("Hit material: " + hit.collider.sharedMaterial.name);
            }
        }
        
        // Raycast with layer mask (only detect certain layers)
        if (Physics.Raycast(transform.position, transform.forward, out hit, raycastDistance, raycastLayers))
        {
            // Only objects on the specified layers will be detected
            Debug.Log("Layer-filtered raycast hit: " + hit.collider.gameObject.name);
        }
        
        // Raycast all - get all hits along the ray
        RaycastHit[] hits = Physics.RaycastAll(transform.position, transform.forward, raycastDistance, raycastLayers);
        foreach (RaycastHit hitInfo in hits)
        {
            // Process each hit
            Debug.Log("RaycastAll hit: " + hitInfo.collider.gameObject.name);
        }
        
        // PHYSICS OVERLAP TESTS
        
        // Check for colliders in a sphere
        Collider[] sphereResults = Physics.OverlapSphere(transform.position, 5f, raycastLayers);
        Debug.Log("Found " + sphereResults.Length + " colliders in sphere");
        
        // Check for colliders in a box
        Vector3 boxSize = new Vector3(2f, 2f, 2f);
        Collider[] boxResults = Physics.OverlapBox(transform.position, boxSize / 2f, transform.rotation, raycastLayers);
        Debug.Log("Found " + boxResults.Length + " colliders in box");
        
        // Check for colliders in a capsule
        Vector3 capsulePoint1 = transform.position + Vector3.up;
        Vector3 capsulePoint2 = transform.position - Vector3.up;
        float capsuleRadius = 1f;
        Collider[] capsuleResults = Physics.OverlapCapsule(capsulePoint1, capsulePoint2, capsuleRadius, raycastLayers);
        Debug.Log("Found " + capsuleResults.Length + " colliders in capsule");
        
        // LINECAST, SPHERECAST, BOXCAST
        
        // Linecast (similar to raycast but with start and end points)
        Vector3 lineEnd = transform.position + transform.forward * raycastDistance;
        if (Physics.Linecast(transform.position, lineEnd, out hit))
        {
            Debug.Log("Linecast hit: " + hit.collider.gameObject.name);
        }
        
        // SphereCast (like a raycast but with thickness)
        float sphereRadius = 0.5f;
        if (Physics.SphereCast(transform.position, sphereRadius, transform.forward, out hit, raycastDistance))
        {
            Debug.Log("SphereCast hit: " + hit.collider.gameObject.name);
        }
        
        // BoxCast (like a raycast but with a box)
        Vector3 boxHalfExtents = new Vector3(0.5f, 0.5f, 0.5f);
        if (Physics.BoxCast(transform.position, boxHalfExtents, transform.forward, out hit, transform.rotation, raycastDistance))
        {
            Debug.Log("BoxCast hit: " + hit.collider.gameObject.name);
        }
        
        // 2D VARIANTS
        
        // 2D Raycast example
        RaycastHit2D hit2D = Physics2D.Raycast(transform.position, transform.right, raycastDistance, raycastLayers);
        if (hit2D.collider != null)
        {
            Debug.Log("2D Raycast hit: " + hit2D.collider.gameObject.name);
        }
        
        // 2D Circle overlap example
        Collider2D[] circleResults = Physics2D.OverlapCircleAll(transform.position, 5f, raycastLayers);
        Debug.Log("Found " + circleResults.Length + " 2D colliders in circle");
    }
    
    // Visualize raycasts and overlap tests in the Scene view
    void OnDrawGizmos()
    {
        // Draw the main raycast
        Gizmos.color = Color.red;
        Gizmos.DrawLine(transform.position, transform.position + transform.forward * raycastDistance);
        
        // Draw a sphere for the OverlapSphere
        Gizmos.color = Color.green;
        Gizmos.DrawWireSphere(transform.position, 5f);
        
        // Draw a box for the OverlapBox
        Gizmos.color = Color.blue;
        Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
        Gizmos.DrawWireCube(Vector3.zero, new Vector3(2f, 2f, 2f));
        Gizmos.matrix = Matrix4x4.identity;
    }
}
                            

Creating and Using Physics Materials:

1. Create a Physics Material: Right-click in Project window → Create → Physics Material (or Physic Material 2D)
2. Configure Properties:
   • Dynamic Friction: Friction when objects are moving
   • Static Friction: Friction when objects are stationary
   • Bounciness: How bouncy the surface is (0 = no bounce, 1 = perfect bounce)
   • Friction Combine: How to combine friction with other materials (Average, Minimum, Maximum, Multiply)
   • Bounce Combine: How to combine bounciness with other materials
3. Apply to Collider: Drag the Physics Material to the Material property of a Collider component

Setting Up Collision Layers:

1. Define Layers: Edit → Project Settings → Tags and Layers → Layers
2. Assign Layers: Select GameObjects and set their Layer in the Inspector
3. Configure Collision Matrix: Edit → Project Settings → Physics → Layer Collision Matrix