Game Development Complete Guide 2025: Unity vs Unreal vs Godot, ECS, Multiplayer, Optimization

// Traditional MonoBehaviour
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float jumpForce = 10f;

    private Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 movement = new Vector3(horizontal, 0, vertical) * speed * Time.deltaTime;
        transform.Translate(movement);

        if (Input.GetKeyDown(KeyCode.Space) && IsGrounded())
        {
            rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
        }
    }

    bool IsGrounded()
    {
        return Physics.Raycast(transform.position, Vector3.down, 1.1f);
    }
}

// Unity DOTS/ECS
using Unity.Entities;
using Unity.Mathematics;
using Unity.Burst;

public struct PlayerInput : IComponentData
{
    public float2 Move;
    public bool Jump;
}

public struct Velocity : IComponentData
{
    public float3 Value;
}

public struct PlayerSpeed : IComponentData
{
    public float Value;
}

[BurstCompile]
public partial struct PlayerMovementSystem : ISystem
{
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        float deltaTime = SystemAPI.Time.DeltaTime;

        foreach (var (input, velocity, speed, transform)
            in SystemAPI.Query<RefRO<PlayerInput>, RefRW<Velocity>, RefRO<PlayerSpeed>, RefRW<LocalTransform>>())
        {
            float3 movement = new float3(input.ValueRO.Move.x, 0, input.ValueRO.Move.y) * speed.ValueRO.Value;
            velocity.ValueRW.Value = movement;
            transform.ValueRW.Position += movement * deltaTime;
        }
    }
}

using Unity.Collections;
using Unity.Jobs;
using Unity.Burst;
using Unity.Mathematics;

[BurstCompile]
public struct ParallelMovementJob : IJobParallelFor
{
    public NativeArray<float3> Positions;
    [ReadOnly] public NativeArray<float3> Velocities;
    public float DeltaTime;

    public void Execute(int index)
    {
        Positions[index] += Velocities[index] * DeltaTime;
    }
}

public class JobScheduler : MonoBehaviour
{
    public void UpdatePositions()
    {
        var positions = new NativeArray<float3>(10000, Allocator.TempJob);
        var velocities = new NativeArray<float3>(10000, Allocator.TempJob);

        var job = new ParallelMovementJob
        {
            Positions = positions,
            Velocities = velocities,
            DeltaTime = Time.deltaTime
        };

        JobHandle handle = job.Schedule(positions.Length, 64);
        handle.Complete();

        positions.Dispose();
        velocities.Dispose();
    }
}

using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class AddressableLoader : MonoBehaviour
{
    [SerializeField] private AssetReferenceGameObject playerPrefab;

    async void Start()
    {
        AsyncOperationHandle<GameObject> handle = playerPrefab.InstantiateAsync();
        await handle.Task;

        if (handle.Status == AsyncOperationStatus.Succeeded)
        {
            GameObject player = handle.Result;
            Debug.Log($"Loaded: {player.name}");
        }
    }

    void OnDestroy()
    {
        Addressables.Release(playerPrefab);
    }
}

#include "MyCharacter.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/SpringArmComponent.h"

AMyCharacter::AMyCharacter()
{
    PrimaryActorTick.bCanEverTick = true;

    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
    SpringArm->SetupAttachment(RootComponent);
    SpringArm->TargetArmLength = 400.0f;
    SpringArm->bUsePawnControlRotation = true;

    Camera = CreateDefaultSubobject<UCameraComponent>(TEXT("Camera"));
    Camera->SetupAttachment(SpringArm, USpringArmComponent::SocketName);

    GetCharacterMovement()->bOrientRotationToMovement = true;
    GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f);
    GetCharacterMovement()->JumpZVelocity = 600.0f;
    GetCharacterMovement()->AirControl = 0.2f;
}

void AMyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    PlayerInputComponent->BindAxis("MoveForward", this, &AMyCharacter::MoveForward);
    PlayerInputComponent->BindAxis("MoveRight", this, &AMyCharacter::MoveRight);
    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
}

void AMyCharacter::MoveForward(float Value)
{
    if (Value != 0.0f)
    {
        const FRotator Rotation = Controller->GetControlRotation();
        const FRotator YawRotation(0, Rotation.Yaw, 0);
        const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
        AddMovementInput(Direction, Value);
    }
}

APostProcessVolume* PPV = ...;
PPV->Settings.bOverride_DynamicGlobalIlluminationMethod = true;
PPV->Settings.DynamicGlobalIlluminationMethod = EDynamicGlobalIlluminationMethod::Lumen;
PPV->Settings.bOverride_LumenSurfaceCacheResolution = true;
PPV->Settings.LumenSurfaceCacheResolution = 1.0f;

UStaticMesh* Mesh = ...;
Mesh->NaniteSettings.bEnabled = true;
Mesh->NaniteSettings.PositionPrecision = 0;
Mesh->NaniteSettings.PercentTriangles = 1.0f;

extends CharacterBody3D

const SPEED = 5.0
const JUMP_VELOCITY = 4.5

var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")

func _physics_process(delta):
    if not is_on_floor():
        velocity.y -= gravity * delta

    if Input.is_action_just_pressed("jump") and is_on_floor():
        velocity.y = JUMP_VELOCITY

    var input_dir = Input.get_vector("move_left", "move_right", "move_forward", "move_back")
    var direction = (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()

    if direction:
        velocity.x = direction.x * SPEED
        velocity.z = direction.z * SPEED
    else:
        velocity.x = move_toward(velocity.x, 0, SPEED)
        velocity.z = move_toward(velocity.z, 0, SPEED)

    move_and_slide()

extends Node

signal player_died(score)
signal score_changed(new_score)

var score = 0:
    set(value):
        score = value
        score_changed.emit(score)

func _ready():
    var player = $Player
    player.died.connect(_on_player_died)

func _on_player_died():
    player_died.emit(score)
    get_tree().reload_current_scene()

func add_score(amount: int):
    score += amount

using Godot;

public partial class PlayerController : CharacterBody3D
{
    public const float Speed = 5.0f;
    public const float JumpVelocity = 4.5f;

    public float Gravity = ProjectSettings.GetSetting("physics/3d/default_gravity").AsSingle();

    public override void _PhysicsProcess(double delta)
    {
        Vector3 velocity = Velocity;

        if (!IsOnFloor())
            velocity.Y -= Gravity * (float)delta;

        if (Input.IsActionJustPressed("jump") && IsOnFloor())
            velocity.Y = JumpVelocity;

        Vector2 inputDir = Input.GetVector("move_left", "move_right", "move_forward", "move_back");
        Vector3 direction = (Transform.Basis * new Vector3(inputDir.X, 0, inputDir.Y)).Normalized();

        if (direction != Vector3.Zero)
        {
            velocity.X = direction.X * Speed;
            velocity.Z = direction.Z * Speed;
        }
        else
        {
            velocity.X = Mathf.MoveToward(Velocity.X, 0, Speed);
            velocity.Z = Mathf.MoveToward(Velocity.Z, 0, Speed);
        }

        Velocity = velocity;
        MoveAndSlide();
    }
}

// Pseudocode: the heart of every game engine
while (gameRunning)
{
    ProcessInput();
    Update(deltaTime);
    Render();
    SyncFrameRate();
}

public class Player : MonoBehaviour
{
    void Update()
    {
        // Input, camera, UI - variable timestep
        ProcessInput();
    }

    void FixedUpdate()
    {
        // Physics, AI - fixed timestep (50Hz default in Unity)
        ApplyPhysics();
    }
}

public class BallController : MonoBehaviour
{
    private Rigidbody rb;
    public float bounciness = 0.8f;

    void Start()
    {
        rb = GetComponent<Rigidbody>();
        var material = new PhysicMaterial
        {
            bounciness = bounciness,
            dynamicFriction = 0.6f,
            staticFriction = 0.6f
        };
        GetComponent<Collider>().material = material;
    }

    void OnCollisionEnter(Collision collision)
    {
        Debug.Log($"Hit: {collision.gameObject.name} at {collision.relativeVelocity.magnitude}");
    }
}

using Unity.Netcode;
using UnityEngine;

public class NetworkPlayer : NetworkBehaviour
{
    [SerializeField] private float moveSpeed = 5f;

    private NetworkVariable<int> health = new NetworkVariable<int>(100,
        NetworkVariableReadPermission.Everyone,
        NetworkVariableWritePermission.Server);

    public override void OnNetworkSpawn()
    {
        if (IsOwner)
        {
            Camera.main.GetComponent<CameraFollow>().target = transform;
        }
        health.OnValueChanged += OnHealthChanged;
    }

    void Update()
    {
        if (!IsOwner) return;

        Vector3 input = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
        if (input.magnitude > 0.1f)
        {
            MoveServerRpc(input * moveSpeed * Time.deltaTime);
        }

        if (Input.GetKeyDown(KeyCode.Space))
        {
            ShootServerRpc();
        }
    }

    [ServerRpc]
    void MoveServerRpc(Vector3 movement)
    {
        transform.position += movement;
    }

    [ServerRpc]
    void ShootServerRpc()
    {
        var bullet = Instantiate(bulletPrefab, transform.position, transform.rotation);
        bullet.GetComponent<NetworkObject>().Spawn();
    }

    [ClientRpc]
    void TakeDamageClientRpc(int damage)
    {
        if (IsOwner)
        {
            ShowDamageUI(damage);
        }
    }

    void OnHealthChanged(int previous, int current)
    {
        UpdateHealthBar(current);
    }
}

using Mirror;
using UnityEngine;

public class MirrorPlayer : NetworkBehaviour
{
    [SyncVar(hook = nameof(OnHealthChanged))]
    public int health = 100;

    void OnHealthChanged(int oldHealth, int newHealth)
    {
        Debug.Log($"Health: {oldHealth} -> {newHealth}");
    }

    void Update()
    {
        if (!isLocalPlayer) return;

        if (Input.GetKeyDown(KeyCode.Space))
        {
            CmdShoot();
        }
    }

    [Command]
    void CmdShoot()
    {
        RpcPlayShootEffect();
    }

    [ClientRpc]
    void RpcPlayShootEffect()
    {
        Instantiate(muzzleFlash, transform.position, transform.rotation);
    }
}

// Static batching
public class StaticOptimizer : MonoBehaviour
{
    void Start()
    {
        StaticBatchingUtility.Combine(gameObject);
    }
}

// GPU Instancing
public class InstancedRenderer : MonoBehaviour
{
    public Mesh mesh;
    public Material material;
    public int count = 10000;

    private Matrix4x4[] matrices;

    void Start()
    {
        matrices = new Matrix4x4[count];
        for (int i = 0; i < count; i++)
        {
            matrices[i] = Matrix4x4.TRS(
                Random.insideUnitSphere * 100,
                Quaternion.identity,
                Vector3.one
            );
        }
    }

    void Update()
    {
        Graphics.DrawMeshInstanced(mesh, 0, material, matrices, count);
    }
}

public class LODSetup : MonoBehaviour
{
    void Start()
    {
        LODGroup group = gameObject.AddComponent<LODGroup>();
        LOD[] lods = new LOD[3];

        lods[0] = new LOD(0.6f, GetRenderers(0));
        lods[1] = new LOD(0.3f, GetRenderers(1));
        lods[2] = new LOD(0.1f, GetRenderers(2));

        group.SetLODs(lods);
        group.RecalculateBounds();
    }

    Renderer[] GetRenderers(int level)
    {
        return new Renderer[] { transform.GetChild(level).GetComponent<Renderer>() };
    }
}