Unity Game Engine Series Part 3: GameObjects & Components

1. The Transform System

1.1 Position, Rotation & Scale

The Transform component stores three fundamental properties that define an object's spatial state:

using UnityEngine;

public class TransformBasics : MonoBehaviour
{
    [SerializeField] private Transform target;
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private float rotateSpeed = 120f;

    private void Update()
    {
        // === POSITION ===
        // Move forward in the direction the object is facing
        transform.Translate(Vector3.forward * moveSpeed * Time.deltaTime);

        // Move toward a target in world space
        transform.position = Vector3.MoveTowards(
            transform.position, target.position, moveSpeed * Time.deltaTime);

        // Smoothly interpolate position (easing)
        transform.position = Vector3.Lerp(
            transform.position, target.position, 3f * Time.deltaTime);

        // === ROTATION ===
        // Rotate around Y axis (turning left/right)
        float horizontal = Input.GetAxis("Horizontal");
        transform.Rotate(0, horizontal * rotateSpeed * Time.deltaTime, 0);

        // Look at a target (instant)
        transform.LookAt(target);

        // Smoothly rotate toward target
        Vector3 direction = (target.position - transform.position).normalized;
        Quaternion targetRotation = Quaternion.LookRotation(direction);
        transform.rotation = Quaternion.Slerp(
            transform.rotation, targetRotation, 5f * Time.deltaTime);

        // === SCALE ===
        // Pulsating scale effect
        float scale = 1f + Mathf.Sin(Time.time * 3f) * 0.1f;
        transform.localScale = Vector3.one * scale;
    }
}

1.2 Local vs World Space

Analogy: Imagine you are standing on a train. Your local position is "3 meters from the front of the train car." Your world position is "47.3 degrees latitude, -122.1 degrees longitude." When the train moves, your local position stays the same, but your world position changes constantly. Parent-child transforms in Unity work the same way.

using UnityEngine;

public class SpaceConversions : MonoBehaviour
{
    [SerializeField] private Transform weaponMount; // Child of player

    private void Example()
    {
        // TransformPoint: Convert local position to world position
        // "Where in the world is the point 2 meters in front of me?"
        Vector3 worldPoint = transform.TransformPoint(Vector3.forward * 2f);

        // InverseTransformPoint: Convert world position to local position
        // "Where is the enemy relative to me?"
        Vector3 localEnemyPos = transform.InverseTransformPoint(enemyWorldPos);
        // localEnemyPos.z > 0 means enemy is in front of me
        // localEnemyPos.x > 0 means enemy is to my right

        // TransformDirection: Convert local direction to world direction
        Vector3 worldForward = transform.TransformDirection(Vector3.forward);
        // Equivalent to: transform.forward

        // Setting child position in parent's local space
        weaponMount.localPosition = new Vector3(0.5f, 0f, 0.8f); // Right hand offset
        weaponMount.localRotation = Quaternion.Euler(-10f, 0f, 0f); // Slight tilt
    }

    private Vector3 enemyWorldPos; // Placeholder for example
}

1.3 Quaternions vs Euler Angles

Rotations in Unity are stored internally as Quaternions -- a mathematical representation using four components (x, y, z, w). While Euler angles (degrees around X, Y, Z axes) are more human-readable, they suffer from a critical problem called gimbal lock:

using UnityEngine;

public class RotationExamples : MonoBehaviour
{
    [SerializeField] private Transform target;

    private void Update()
    {
        // === EULER ANGLES (human-readable, susceptible to gimbal lock) ===
        // Set rotation to 45 degrees on Y axis
        transform.eulerAngles = new Vector3(0, 45, 0);

        // Rotate by 90 degrees around Y
        transform.Rotate(0, 90f * Time.deltaTime, 0);

        // === QUATERNION METHODS (gimbal-lock free, interpolatable) ===
        // Create rotation from Euler angles
        Quaternion rot = Quaternion.Euler(0, 90, 0);

        // Smooth rotation toward target (Slerp = Spherical Linear Interpolation)
        Vector3 direction = (target.position - transform.position).normalized;
        if (direction != Vector3.zero)
        {
            Quaternion lookRotation = Quaternion.LookRotation(direction);
            transform.rotation = Quaternion.Slerp(
                transform.rotation, lookRotation, 5f * Time.deltaTime);
        }

        // Rotate from current rotation by an angle around an axis
        transform.rotation = Quaternion.RotateTowards(
            transform.rotation, target.rotation, 180f * Time.deltaTime);

        // Angle between two rotations (useful for "is the enemy facing me?")
        float angle = Quaternion.Angle(transform.rotation, target.rotation);
        if (angle < 10f)
            Debug.Log("Nearly aligned!");

        // LookAt with a specific up direction
        transform.LookAt(target, Vector3.up);
    }
}

2. Core Components

2.1 MeshRenderer, MeshFilter & SpriteRenderer

Renderers are what make things visible. Without a renderer, a GameObject exists in the scene but is completely invisible:

using UnityEngine;

public class RendererExamples : MonoBehaviour
{
    // === 3D MESH RENDERING ===
    [Header("3D Settings")]
    [SerializeField] private MeshRenderer meshRenderer;
    [SerializeField] private Material damageMaterial;

    // === 2D SPRITE RENDERING ===
    [Header("2D Settings")]
    [SerializeField] private SpriteRenderer spriteRenderer;
    [SerializeField] private Sprite[] walkFrames;

    public void FlashDamage()
    {
        StartCoroutine(DamageFlash());
    }

    private System.Collections.IEnumerator DamageFlash()
    {
        // Store original materials
        Material[] originals = meshRenderer.materials;

        // Replace all materials with damage material
        Material[] damageMats = new Material[originals.Length];
        for (int i = 0; i < damageMats.Length; i++)
            damageMats[i] = damageMaterial;
        meshRenderer.materials = damageMats;

        yield return new WaitForSeconds(0.1f);

        // Restore originals
        meshRenderer.materials = originals;
    }

    // 2D: Sorting order determines draw order (higher = drawn on top)
    public void SetSortingOrder(int order)
    {
        spriteRenderer.sortingOrder = order;
    }

    // 2D: Flip sprite for direction changes (no rotation needed)
    public void FaceDirection(float horizontalInput)
    {
        if (horizontalInput < 0) spriteRenderer.flipX = true;
        else if (horizontalInput > 0) spriteRenderer.flipX = false;
    }

    // Visibility check (useful for culling, AI awareness)
    public bool IsVisibleToCamera()
    {
        return meshRenderer.isVisible; // True if ANY camera can see it
    }
}

2.2 Camera: Projection, Culling & Depth

The Camera component determines what the player sees. Understanding its settings is essential for both visual quality and performance:

using UnityEngine;

public class CameraController : MonoBehaviour
{
    [Header("Follow Target")]
    [SerializeField] private Transform target;
    [SerializeField] private Vector3 offset = new Vector3(0, 8, -6);
    [SerializeField] private float smoothSpeed = 5f;

    [Header("Zoom")]
    [SerializeField] private float minFOV = 40f;
    [SerializeField] private float maxFOV = 80f;
    [SerializeField] private float zoomSpeed = 10f;

    private Camera cam;

    private void Awake()
    {
        cam = GetComponent<Camera>();
    }

    // LateUpdate ensures camera follows AFTER all objects have moved
    private void LateUpdate()
    {
        if (target == null) return;

        // Smooth follow
        Vector3 desiredPosition = target.position + offset;
        transform.position = Vector3.Lerp(
            transform.position, desiredPosition, smoothSpeed * Time.deltaTime);

        // Always look at target
        transform.LookAt(target);

        // Scroll wheel zoom
        float scroll = Input.GetAxis("Mouse ScrollWheel");
        cam.fieldOfView = Mathf.Clamp(
            cam.fieldOfView - scroll * zoomSpeed, minFOV, maxFOV);
    }

    // Useful utility: Convert screen point to world position
    public Vector3 ScreenToWorldPoint(Vector2 screenPos)
    {
        Vector3 pos = new Vector3(screenPos.x, screenPos.y, cam.nearClipPlane);
        return cam.ScreenToWorldPoint(pos);
    }

    // Check if a world position is visible on screen
    public bool IsWorldPointVisible(Vector3 worldPoint)
    {
        Vector3 viewportPoint = cam.WorldToViewportPoint(worldPoint);
        return viewportPoint.x >= 0 && viewportPoint.x <= 1 &&
               viewportPoint.y >= 0 && viewportPoint.y <= 1 &&
               viewportPoint.z > 0; // In front of camera
    }
}

2.3 Light Types, Shadows & Baking

3. Writing Custom Components

3.1 Reusable Script Patterns

The best Unity components are small, focused, and reusable. A component should do one thing well, be configurable through the Inspector, and make no assumptions about the GameObject it is attached to:

using UnityEngine;

// GOOD: Small, focused, reusable on any object
public class Rotator : MonoBehaviour
{
    [SerializeField] private Vector3 rotationSpeed = new Vector3(0, 90, 0);
    [SerializeField] private Space space = Space.Self;

    private void Update()
    {
        transform.Rotate(rotationSpeed * Time.deltaTime, space);
    }
}

// GOOD: Reusable health component with no assumptions about what it is on
public class Damageable : MonoBehaviour
{
    [SerializeField] private float maxHealth = 100f;
    [SerializeField] private bool destroyOnDeath = true;
    [SerializeField] private float destroyDelay = 0f;
    [SerializeField] private GameObject deathEffectPrefab;

    public float CurrentHealth { get; private set; }
    public bool IsAlive => CurrentHealth > 0;

    public event System.Action<float, float> OnDamaged;  // damage, remaining
    public event System.Action OnDeath;

    private void Awake() => CurrentHealth = maxHealth;

    public void ApplyDamage(float amount)
    {
        if (!IsAlive) return;
        CurrentHealth = Mathf.Max(0, CurrentHealth - amount);
        OnDamaged?.Invoke(amount, CurrentHealth);

        if (!IsAlive)
        {
            OnDeath?.Invoke();
            if (deathEffectPrefab != null)
                Instantiate(deathEffectPrefab, transform.position, Quaternion.identity);
            if (destroyOnDeath)
                Destroy(gameObject, destroyDelay);
        }
    }
}

// GOOD: Separate visual feedback, attached alongside Damageable
[RequireComponent(typeof(Damageable))]
public class DamageVisuals : MonoBehaviour
{
    [SerializeField] private Renderer targetRenderer;
    [SerializeField] private Color flashColor = Color.red;
    [SerializeField] private float flashDuration = 0.1f;

    private Damageable damageable;
    private Color originalColor;

    private void Awake()
    {
        damageable = GetComponent<Damageable>();
        if (targetRenderer != null)
            originalColor = targetRenderer.material.color;
    }

    private void OnEnable() => damageable.OnDamaged += HandleDamage;
    private void OnDisable() => damageable.OnDamaged -= HandleDamage;

    private void HandleDamage(float amount, float remaining)
    {
        if (targetRenderer != null)
            StartCoroutine(Flash());
    }

    private System.Collections.IEnumerator Flash()
    {
        targetRenderer.material.color = flashColor;
        yield return new WaitForSeconds(flashDuration);
        targetRenderer.material.color = originalColor;
    }
}

3.2 Dependency Injection with Interfaces

Interfaces allow your components to communicate without knowing each other's concrete types. This is the foundation of testable, modular game code:

using UnityEngine;

// === INTERFACES: Define contracts, not implementations ===
public interface IDamageable
{
    void TakeDamage(float amount);
    float CurrentHealth { get; }
    bool IsAlive { get; }
}

public interface IInteractable
{
    string InteractionPrompt { get; }
    void Interact(GameObject interactor);
}

// === IMPLEMENTATIONS: Different objects implement the same interface ===
public class BreakableObject : MonoBehaviour, IDamageable
{
    [SerializeField] private float health = 50f;
    public float CurrentHealth => health;
    public bool IsAlive => health > 0;

    public void TakeDamage(float amount)
    {
        health -= amount;
        if (!IsAlive)
        {
            // Spawn debris, play sound, destroy
            Destroy(gameObject);
        }
    }
}

public class TreasureChest : MonoBehaviour, IInteractable
{
    [SerializeField] private GameObject[] lootPrefabs;
    private bool isOpened = false;

    public string InteractionPrompt => isOpened ? "Empty" : "Open Chest";

    public void Interact(GameObject interactor)
    {
        if (isOpened) return;
        isOpened = true;

        // Spawn loot
        foreach (var prefab in lootPrefabs)
        {
            Vector3 spawnPos = transform.position + Vector3.up * 1.5f;
            Instantiate(prefab, spawnPos, Quaternion.identity);
        }
    }
}

// === CONSUMER: Works with ANY IDamageable, not specific types ===
public class ProjectileDamager : MonoBehaviour
{
    [SerializeField] private float damage = 25f;

    private void OnCollisionEnter(Collision collision)
    {
        // Works on enemies, breakable walls, explosive barrels -- anything damageable
        var damageable = collision.gameObject.GetComponent<IDamageable>();
        damageable?.TakeDamage(damage);
        Destroy(gameObject); // Destroy the projectile
    }
}

4. Scene Organization

4.1 Hierarchy & Performance

A well-organized hierarchy is not just about aesthetics -- it directly impacts performance and maintainability:

# Recommended scene hierarchy organization
Scene Root
├── --- Managers ---
│   ├── GameManager
│   ├── AudioManager
│   └── UIManager
├── --- Environment ---
│   ├── Terrain
│   ├── Static_Props (all flagged as Static)
│   │   ├── Tree_01
│   │   ├── Rock_03
│   │   └── Building_West
│   └── Dynamic_Props
│       ├── Door_01 (animated)
│       └── Elevator_01
├── --- Characters ---
│   ├── Player
│   └── Enemies
│       ├── Enemy_Goblin_01
│       └── Enemy_Goblin_02
├── --- Lighting ---
│   ├── Directional Light (Sun)
│   ├── Point Lights
│   └── Reflection Probes
├── --- Cameras ---
│   ├── Main Camera
│   └── Minimap Camera
├── --- UI ---
│   ├── HUD Canvas
│   ├── Pause Menu Canvas
│   └── Dialogue Canvas
└── --- Audio ---
    ├── BGM_Source
    └── Ambient_Source

4.2 Tags & Layers

Tags are string identifiers for GameObjects. Layers are bit-field categories used by physics and rendering systems:

using UnityEngine;

public class TagsAndLayers : MonoBehaviour
{
    // TAGS: Use CompareTag (not == "string") -- it's faster and safer
    private void OnTriggerEnter(Collider other)
    {
        // GOOD: CompareTag is 0-allocation and handles missing tags gracefully
        if (other.CompareTag("Player"))
        {
            Debug.Log("Player entered trigger!");
        }

        // BAD: String comparison allocates garbage and throws if tag doesn't exist
        // if (other.tag == "Player") { }
    }

    // LAYERS: Used for physics filtering and raycasting
    [SerializeField] private LayerMask groundLayer;
    [SerializeField] private LayerMask enemyLayer;

    private bool IsGrounded()
    {
        // Raycast only against the ground layer (ignores everything else)
        return Physics.Raycast(transform.position, Vector3.down, 1.1f, groundLayer);
    }

    private void FindEnemiesInRange(float range)
    {
        // OverlapSphere only checks objects on the enemy layer
        Collider[] enemies = Physics.OverlapSphere(transform.position, range, enemyLayer);
        Debug.Log($"Found {enemies.Length} enemies within {range}m");
    }
}

5. Advanced Patterns

5.1 Composition Over Inheritance

This is perhaps the single most important architectural principle in Unity development. Instead of deep class hierarchies, compose complex behaviors from simple, independent components:

using UnityEngine;

// ====== BAD: Deep inheritance hierarchy ======
// public class Entity : MonoBehaviour { }
// public class Character : Entity { }
// public class Enemy : Character { }
// public class FlyingEnemy : Enemy { }
// public class FlyingBossEnemy : FlyingEnemy { }
// Problem: What if you want a ground boss? Or a flying non-enemy NPC?
// You'd need to restructure the entire hierarchy.

// ====== GOOD: Composition with small, focused components ======

// Movement behaviors (attach one or more)
public class GroundMovement : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float gravity = -20f;
    private CharacterController controller;

    private void Awake() => controller = GetComponent<CharacterController>();

    public void Move(Vector3 direction)
    {
        Vector3 move = direction.normalized * speed;
        move.y = gravity;
        controller.Move(move * Time.deltaTime);
    }
}

public class FlyingMovement : MonoBehaviour
{
    [SerializeField] private float speed = 8f;
    [SerializeField] private float hoverHeight = 5f;
    [SerializeField] private float hoverAmplitude = 0.5f;

    public void Move(Vector3 direction)
    {
        Vector3 move = direction.normalized * speed * Time.deltaTime;
        float hover = Mathf.Sin(Time.time * 2f) * hoverAmplitude;
        transform.position += move;
        transform.position = new Vector3(
            transform.position.x,
            hoverHeight + hover,
            transform.position.z);
    }
}

// Compose your entities freely:
// Ground Enemy: Damageable + GroundMovement + PatrolAI + MeleeAttack
// Flying Enemy: Damageable + FlyingMovement + ChaseAI + RangedAttack
// Flying Boss: Damageable(hp=5000) + FlyingMovement + BossAI + MeleeAttack + RangedAttack + ShieldAbility
// Ground NPC: GroundMovement + DialogueComponent + QuestGiver
// No inheritance needed. Maximum flexibility.

5.2 Event-Driven Communication with UnityEvent

UnityEvents are Inspector-configurable event hooks that allow designers to wire up interactions without writing code:

using UnityEngine;
using UnityEngine.Events;

public class PressurePlate : MonoBehaviour
{
    [Header("Events")]
    [SerializeField] private UnityEvent OnActivated;
    [SerializeField] private UnityEvent OnDeactivated;
    [SerializeField] private UnityEvent<float> OnWeightChanged;

    [Header("Settings")]
    [SerializeField] private float activationWeight = 1f;
    [SerializeField] private string requiredTag = "Player";

    private float currentWeight = 0f;
    private bool isActivated = false;

    private void OnTriggerEnter(Collider other)
    {
        if (!other.CompareTag(requiredTag)) return;

        var rb = other.GetComponent<Rigidbody>();
        float weight = rb != null ? rb.mass : 1f;
        currentWeight += weight;
        OnWeightChanged?.Invoke(currentWeight);

        if (!isActivated && currentWeight >= activationWeight)
        {
            isActivated = true;
            OnActivated?.Invoke();
        }
    }

    private void OnTriggerExit(Collider other)
    {
        if (!other.CompareTag(requiredTag)) return;

        var rb = other.GetComponent<Rigidbody>();
        float weight = rb != null ? rb.mass : 1f;
        currentWeight = Mathf.Max(0, currentWeight - weight);
        OnWeightChanged?.Invoke(currentWeight);

        if (isActivated && currentWeight < activationWeight)
        {
            isActivated = false;
            OnDeactivated?.Invoke();
        }
    }
}

// In the Inspector, drag a Door object onto OnActivated and select Door.Open()
// No code changes needed -- designers can wire up any combination of responses:
// Pressure plate -> opens door, plays sound, enables light, starts particle effect

5.3 Modular Design Principles

Exercises & Self-Assessment

Conclusion & Next Steps

You now have a thorough understanding of Unity's GameObject and Component architecture. Here are the key takeaways from Part 3:

• The Transform is the only mandatory component -- master local vs world space, use TransformPoint/InverseTransformPoint for coordinate conversions, and prefer Quaternion methods for rotation
• Quaternions prevent gimbal lock -- use Euler angles for Inspector values, Quaternion.Slerp/LookRotation for runtime rotation logic
• Core components (renderers, cameras, lights) have many powerful properties -- learn their settings to maximize visual quality and performance
• Custom components should be small and focused -- one responsibility per component, configurable through [SerializeField], no assumptions about the host GameObject
• Interfaces enable decoupled communication -- IDamageable, IInteractable, IPickup allow systems to interact without knowing concrete types
• Scene organization matters -- use empty GameObjects as folders, flatten deep hierarchies, and mark non-moving objects as Static for performance
• Composition over inheritance is Unity's core philosophy -- compose behaviors from independent components instead of building fragile class hierarchies