Chapter 5: Physics and Collisions

5.1 Unity Physics Engine Overview

The Unity Physics Engine serves as a fundamental part of game development, providing realistic simulations of physical interactions. It allows objects in a virtual world to respond to gravity, collisions, forces, and other physical phenomena. The Unity engine implements a form of the NVIDIA PhysX engine, which is responsible for simulating real-world physics for 3D and 2D objects. This section delves into how the Physics Engine operates, the difference between 2D and 3D physics, and how it integrates with various Unity components.

At its core, the Physics Engine is responsible for determining how objects move, rotate, and interact based on the parameters provided by developers. Unity offers two separate physics engines: one for 2D physics and another for 3D physics. These engines handle rigidbody dynamics, force applications, collisions, and constraints in their respective dimensions.

3D Physics in Unity is powered by the PhysX engine, which simulates 3D environments, handling the complex interactions of objects in three-dimensional space. PhysX handles multiple core functionalities such as rigidbody motion, collision detection, and the application of forces.

On the other hand, 2D Physics in Unity uses Box2D, a different physics engine designed specifically for 2D environments. While the general principles remain similar, the calculations for forces, gravity, and collision detection are simplified to fit 2D planes.

The Physics Engine interacts closely with several key components in Unity, including:

Rigidbodies: These define how objects react to forces.
Colliders: These provide the geometric boundaries for detecting collisions.
Joints: These link objects in physical relationships (e.g., hinge or spring behavior).
Triggers: Special colliders that detect object interactions without causing a physical response.

An important aspect of the Unity Physics Engine is its layer-based collision system. Each object can be assigned a physics layer, and developers can specify which layers interact through a collision matrix. This allows for the fine-tuning of interactions, optimizing performance by ignoring unnecessary collisions between objects.

Physics Settings in Unity also provide essential configurations, such as gravity direction, collision tolerance, and solver iterations. By adjusting these settings, developers can control the granularity and precision of the simulation.

5.2 Working with Colliders

Colliders in Unity are components that define the physical shape of an object for the purposes of collision detection. They act as invisible boundaries that determine when two objects come into contact or overlap. Without a collider, objects pass through each other without interacting. Unity offers various types of colliders, each tailored to specific shapes and use cases, ranging from primitive shapes to complex mesh colliders.

The most commonly used colliders in Unity are:

Box Collider: A simple rectangular prism or cube shape used for cubic objects such as crates, platforms, and walls.
Sphere Collider: A spherical boundary ideal for objects like balls or spherical objects in general.
Capsule Collider: A combination of two hemispheres and a cylinder, commonly used for characters or elongated objects.
Mesh Collider: This collider takes the shape of a mesh model, allowing for highly detailed and custom-shaped objects to have precise collision boundaries.

Each of these colliders can be configured with various properties:

IsTrigger: When enabled, the collider acts as a trigger, meaning it does not physically respond to other colliders, but still detects interactions. Triggers are used to initiate events like picking up objects or opening doors when a player enters a certain area.
Material: Unity's PhysicMaterial allows developers to configure how a collider behaves in terms of friction and bounciness. By assigning materials to colliders, you can simulate real-world physical properties such as slippery surfaces or rubber-like elasticity.

Working with colliders often involves balancing performance and precision. For simple objects, primitive colliders (Box, Sphere, and Capsule) are preferred due to their lower computational cost. Complex objects, like vehicles or buildings, may require mesh colliders, but they should be used sparingly due to their performance impact.

To improve performance, developers often use compound colliders, where multiple primitive colliders are attached to a single object to simulate a more complex shape. This method provides an efficient way to simulate intricate objects without the overhead of a mesh collider.

Colliders are integral to the collision detection pipeline. Unity calculates whether two colliders overlap and determines how objects should respond based on their rigidbodies and materials. Unity offers several layers of optimization, such as broad-phase collision detection (which checks for possible collisions) and narrow-phase detection (which calculates more precise collision points).

5.3 Rigidbodies and Forces

The Rigidbody component in Unity is responsible for simulating the physical behavior of objects in a dynamic world. When an object has a Rigidbody, it responds to forces such as gravity, torque, and external forces applied through code. The Rigidbody is the bridge between the visual object in the scene and the Physics Engine's calculations.

A Rigidbody allows objects to:

Move according to physical rules: This includes being affected by gravity and interacting with other rigidbodies through collisions.
Apply forces: Developers can programmatically apply forces to move or rotate the object, providing realistic motion. This can be done using methods like AddForce(), AddTorque(), and AddExplosionForce().

There are several properties associated with the Rigidbody component:

Mass: The mass of the object determines how it reacts to forces. Heavier objects require more force to move, while lighter objects move more easily.
Drag: Drag simulates air resistance. Higher drag values will cause the object to slow down over time.
Angular Drag: This simulates rotational resistance, affecting how quickly an object stops rotating.
Use Gravity: This toggle allows developers to decide if the object should be affected by the scene's global gravity settings.
Is Kinematic: Kinematic objects do not respond to physics-based forces. They can still be moved manually, but they won’t be affected by gravity or collisions.

Unity offers several methods to apply forces to rigidbodies:

AddForce(): Applies a continuous force to the object in a specific direction. This method is often used for character movement or simulating wind.
AddTorque(): Applies rotational force to spin or rotate an object.
AddExplosionForce(): Simulates an explosive force that radiates outward from a point, useful for simulating bomb blasts or forceful impacts.

For more granular control over physics, developers can adjust the Rigidbody’s interpolation and collision detection settings:

Interpolation helps smooth the motion of an object when the game is running at lower frame rates. This is particularly useful for objects that need to move smoothly, like a player character.
Collision Detection can be set to Continuous, Discrete, or Continuous Dynamic. Continuous collision detection helps prevent fast-moving objects from passing through colliders without detecting a collision (a common issue known as tunneling).

5.4 Triggers and Collisions

Triggers and collisions are mechanisms by which Unity handles object interactions. Although both are related to colliders, they serve different purposes in the context of game design.

Collisions occur when two colliders come into contact, causing a physical response. This could be a ball bouncing off a surface, a character running into a wall, or objects crashing into each other. Unity’s Physics Engine calculates the response based on the properties of the colliders and any rigidbodies attached to the objects. When a collision occurs, Unity generates several callbacks that can be used in scripts, such as OnCollisionEnter(), OnCollisionStay(), and OnCollisionExit().

Triggers, on the other hand, detect when objects overlap without generating a physical collision response. Triggers are used for game mechanics like opening doors, collecting items, or activating events when a player enters a zone. The corresponding script callbacks are OnTriggerEnter(), OnTriggerStay(), and OnTriggerExit().

Triggers are particularly useful for setting up non-physical interactions in the game world. For example, a door might open automatically when a player steps into a specific area. While the player’s collider enters the trigger area, no physical collision occurs—only the trigger event is registered.

5.5 Implementing Character Controllers

Character Controllers in Unity are special components designed to move characters through a 3D world without relying entirely on Rigidbody physics. This is especially useful for player characters in platformers, first-person shooters, and third-person games where developers need precise control over movement and physics. While Rigidbody-based characters can offer more realistic physics-driven interactions, Character Controllers provide more predictable and precise motion, crucial for many game genres.

Unity’s CharacterController component allows developers to move characters without needing to directly manage physics interactions like collisions or forces. This component is designed for characters that need to move smoothly and predictably across a game world while interacting with physical objects. The key properties and methods of the CharacterController component include:

Height: The vertical size of the character’s capsule collider.
Radius: The width of the capsule. This defines the area around the character that can collide with other objects.
Center: The center point of the collider relative to the GameObject’s position.
Step Offset: The maximum height the character can automatically step over without being blocked.
Slope Limit: The steepest angle the character can climb.
Skin Width: The space between the character collider and the physical world. A higher value can help prevent objects from getting stuck when colliding.

The CharacterController component uses its own internal physics to manage movement. It does not respond to Rigidbody physics unless manually coded to do so. This makes it perfect for player-controlled characters, where movements like jumping, running, and climbing must follow a precise input without the unpredictable results caused by rigidbody physics.

To move the character, developers commonly use the CharacterController.Move() or CharacterController.SimpleMove() methods. These methods calculate movement based on inputs from the player or AI, and can factor in gravity and slope limits.

SimpleMove() applies movement based on user input and automatically accounts for gravity. It is generally used when you want basic movement controls with minimal complexity.
Move() provides more direct control over character movement, requiring developers to handle gravity and other forces themselves. It allows for more customization in terms of movement physics.

Character Movement

To implement responsive character movement, developers typically combine Unity's input system with the CharacterController component. Below is a basic example of how to implement movement with a CharacterController in Unity:

public class PlayerController : MonoBehaviour
{
    public float speed = 6.0f;
    public float jumpSpeed = 8.0f;
    public float gravity = 20.0f;
    private Vector3 moveDirection = Vector3.zero;
    private CharacterController controller;

    void Start()
    {
        controller = GetComponent<CharacterController>();
    }

    void Update()
    {
        if (controller.isGrounded)
        {
            moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
            moveDirection = transform.TransformDirection(moveDirection);
            moveDirection *= speed;

            if (Input.GetButton("Jump"))
            {
                moveDirection.y = jumpSpeed;
            }
        }

        moveDirection.y -= gravity * Time.deltaTime;
        controller.Move(moveDirection * Time.deltaTime);
    }
}

In this example, the character moves along the horizontal and vertical axes based on player input. When grounded, the character is allowed to jump, and gravity is applied continuously using the Move() function. This ensures smooth and responsive character motion that can interact with the environment.

Handling Collisions and Slope Interaction

Although CharacterController components don't rely on rigidbody physics, they still respond to collisions with other objects. The collisionFlags property provides information about the collision state, such as whether the character is colliding with the ground or a wall. This can be useful when determining how the character should react to slopes, steps, or obstacles.

To handle slopes effectively, the slope limit and step offset properties play a crucial role. The slope limit prevents characters from climbing slopes that are too steep, simulating a realistic limit to the player's ability to walk on inclined surfaces. The step offset helps characters move smoothly over small obstacles like steps or uneven terrain.

Advanced Character Controllers

For more complex movement systems, developers can extend the CharacterController component with features like:

Root Motion: Using animations to drive movement, ensuring that character motions (like walking or running) are perfectly synced with the movement speed and direction.
State Machines: Implementing a state-driven movement system, where different states (running, jumping, crouching) manage different movement behaviors.
Custom Gravity: Applying custom gravity settings to simulate low-gravity environments, such as in space-themed games.

Unity also provides a ThirdPersonController in its standard assets, which can be customized to suit different character movement needs. This controller offers out-of-the-box functionality for third-person games, with features like camera control, animations, and obstacle detection.

5.6 Creating Interactive Environments

Creating interactive environments in Unity involves leveraging the physics engine, colliders, triggers, and scripts to ensure that objects in the game world respond to player actions. Interactive environments enhance gameplay immersion by allowing players to manipulate the environment or have it react dynamically to their presence. This section explores how to build these environments, focusing on key concepts like interactive objects, environmental hazards, destructible objects, and more.

Dynamic Objects and Rigidbodies

Interactive environments often feature objects that can be moved, manipulated, or destroyed by the player. These objects are typically assigned Rigidbody components, allowing them to respond to physics-based interactions such as being pushed, picked up, or thrown. For example, in a puzzle game, crates might need to be moved by the player to solve puzzles, or in an action game, enemies can be knocked back by explosive forces.

To implement dynamic objects, developers must ensure that the Rigidbody component is correctly configured. The object’s mass, drag, and collision settings can greatly affect how it responds to player interaction. Furthermore, constraints can be applied to lock certain aspects of motion (e.g., preventing rotation on specific axes) to ensure the object behaves as expected in the game world.

Using Triggers for Interaction

Triggers are another vital tool for building interactive environments. A trigger is a type of collider that does not block objects but instead generates events when something passes through it. Triggers are often used to create interactive zones within a game world. For example:

Pickups: Items that can be collected when the player enters their trigger zone (e.g., coins, health packs).
Doors: Automatically open when the player approaches, controlled by a trigger zone.
Event Zones: Trigger specific actions, such as spawning enemies or starting cutscenes, when the player crosses into an area.

An example of using a trigger to open a door when the player enters a certain area:

public class DoorController : MonoBehaviour
{
    public Animator doorAnimator;

    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            doorAnimator.SetTrigger("OpenDoor");
        }
    }
}

In this example, the door's animator component is activated when the player enters the trigger zone, causing the door to open.

Interactive Destructible Objects

Destructible objects add another layer of interactivity to environments. These objects can break apart or explode when hit by a player or an enemy attack. Unity provides several methods for implementing destructible objects, including:

Pre-broken models: A model that is made up of smaller pieces that can be separated on impact. For instance, a vase could be modeled as a whole object but breaks into several fragments when hit.
Procedural destruction: Using Unity’s physics and particle systems to create debris, dust, or particles when an object is destroyed.
Explosion forces: Applying forces to nearby objects when something explodes to simulate a realistic reaction in the surrounding environment.

To create destructible objects, developers typically use a combination of mesh colliders, particle effects, and force application. For example, when an object is destroyed, its rigidbody can be deactivated, and smaller fragments or particles are instantiated to simulate the object breaking apart.

Physics-Based Puzzles and Interaction

Interactive environments also open the door for physics-based puzzles, where players must manipulate objects to progress. Examples include:

Gravity puzzles: Requiring players to drop or move objects to trigger switches.
Lever mechanisms: Pulling a lever to open a door or activate a machine.
Explosive objects: Using the physics engine to simulate explosions that clear pathways or knock down obstacles.

For example, a game might involve pushing a block onto a pressure plate to unlock a door. This can be achieved by setting up the block with a Rigidbody, colliders, and a script that checks when the block is on the plate.

Environmental Hazards

Interactive environments aren’t limited to beneficial interactions. Hazards such as spikes, fire, or falling debris can be implemented to challenge the player. These hazards can be built using a combination of triggers and physics components. For example:

Falling rocks: Using a Rigidbody to make objects fall when the player steps on a pressure-sensitive trigger.
Spikes: Triggering damage or death when the player’s collider enters the hazard area.