Belajar Game Developer - Godot Fundamentals

#Pendahuluan

Setelah mencoba Unity di episode 3, sekarang kita bandingkan dengan Godot — engine open source yang bebas lisensi, ringan, dan sedang naik daun. Godot menawarkan perspektif segar: alih-alih GameObject + komponen, ia memakai node, scene, dan scene tree sebagai arsitektur tunggal yang konsisten. Banyak konsep yang kita pelajari di episode 2-3 ternyata identik di sini, hanya dengan nama berbeda — ini bukti bahwa fondasi kalian sudah benar.

Mengapa Godot layak dipelajari? Karena gratis total (tidak ada royalti), ukurannya kecil, editor menyatu dengan game (tidak perlu launcher terpisah), dan pengalaman 2D-nya dianggap salah satu yang terbaik. Di 2026, Godot menjadi pilihan utama banyak developer indie — tema yang akan kita bahas lagi di episode 26.

#Node, Scene, dan Scene Tree

Di Godot, node adalah blok pembangun terkecil — setiap node punya peran, data, dan lifecycle sendiri. Scene adalah kumpulan node yang disusun sebagai satu file (.tscn), biasanya dengan satu node root. Saat scene dimuat, semua node-nya masuk ke scene tree — satu hierarki global tempat seluruh game hidup.

Struktur Rimba Runner di Godot akan terlihat sangat mirip dengan hierarki Unity:

Level1 (Node2D)
├── Player (CharacterBody2D)
│   ├── Sprite2D
│   └── CollisionShape2D
├── Ground (StaticBody2D)
│   └── CollisionShape2D
└── Obstacles (Node2D)
    └── Box (StaticBody2D + CollisionShape2D)

Perbedaan konsep yang perlu dicatat: di Unity GameObject adalah objek kosong yang diisi komponen; di Godot setiap node sudah punya fungsi spesifik (Node2D, CharacterBody2D, Sprite2D) dan boleh punya child. Membangun game di Godot lebih seperti "menyusun node" daripada "menempelkan komponen".

#GDScript dan C#

Godot mendukung dua bahasa utama: GDScript (bahasa bawaan, mirip Python, dirancang khusus untuk Godot) dan C#. GDScript adalah pilihan paling populer karena ringan, terintegrasi editor, dan bebas setup. Sintaksnya ramah pemula. Bandingkan player controller yang sama dengan di episode 3:

player.gd — GDScript

extends CharacterBody2D
 
@export var speed: float = 300.0
 
func _physics_process(delta: float) -> void:
    var move := Input.get_axis("ui_left", "ui_right")
    velocity.x = move * speed
    move_and_slide()

_physics_process(delta) adalah fixed update-nya Godot, velocity bawaan dari CharacterBody2D, dan move_and_slide() yang memproses gerakan + collision sekaligus. @export membuat variabel bisa diatur dari Inspector — sama seperti public field di Unity. Perhatikan bahwa di Godot, delta dikirim sebagai argumen fungsi, bukan diakses global seperti Time.deltaTime.

Untuk project yang butuh ekosistem .NET atau performa tipe kuat, gunakan C#:

Player.cs — C# di Godot

using Godot;
 
public partial class Player : CharacterBody2D
{
    [Export]
    public float Speed { get; set; } = 300.0f;
 
    public override void _PhysicsProcess(double delta)
    {
        Vector2 velocity = Velocity;
        float move = Input.GetAxis("ui_left") - Input.GetAxis("ui_right");
        velocity.X = -move * Speed;
        Velocity = velocity;
        MoveAndSlide();
    }
}

Aturan pemilihan praktis: GDScript untuk kecepatan iterasi dan prototipe, C# saat project membutuhkan library .NET atau tim sudah nyaman dengan C#. Untuk series ini kita pakai GDScript karena paling idiomatis.

#Signals: Komunikasi Antar Node

Bagian paling khas Godot adalah signal — mekanisme event bawaan. Ketika sesuatu terjadi pada sebuah node (tabrakan, timer habis, tombol ditekan), node mengirim signal, dan node lain bisa mendengarnya. Ini pola komunikasi yang lebih longgar dan aman dibanding saling memanggil langsung.

Contoh: saat pemain menyentuh buah, kita kirim signal fruit_collected:

fruit.gd — mengirim signal

extends Area2D
 
signal fruit_collected(points: int)
 
@export var points := 10
 
func _on_body_entered(body: Node2D) -> void:
    if body.is_in_group("player"):
        fruit_collected.emit(points)
        queue_free()

Signal bisa dihubungkan lewat editor (tab Node di Inspector) atau lewat kode dengan connect. Contoh mendengarkan dari script level:

level.gd — mendengarkan signal

func _ready() -> void:
    $Fruit.fruit_collected.connect(_on_fruit)
 
func _on_fruit(points: int) -> void:
    GameState.score += points
    print("Skor: ", GameState.score)

Kekuatan signal: node pengirim tidak perlu tahu siapa yang mendengarkan. Inilah yang membuat scene Godot mudah dipakai ulang — buah yang sama bisa memberi skor, memicu particle effect, dan menjalankan animasi, tanpa saling terikat. Konsep ini adalah saudara dari event/observer pattern yang kalian temui di bahasa pemrograman mana pun.

#Membangun Game Godot Pertama

Ikuti langkah-langkah ini di Godot 4.x (editor standalone, tidak perlu launcher):

1. Buat project — New Project, pilih folder, renderer Forward+ (atau Compatibility untuk hardware lawas), isi RimbaRunner.
2. Buat scene Player — scene baru, root CharacterBody2D; tambahkan child Sprite2D (drag sprite sederhana atau aktifkan placeholder) dan CollisionShape2D (pilih shape RectangleShape2D).
3. Attach script — pilih root, klik ikon kunci/kertas, buat player.gd, isi kode di atas.
4. Buat scene Level — root Node2D, instan scene Player, tambahkan StaticBody2D untuk ground dengan CollisionShape2D.
5. Input map — Project Settings → Input Map; aksi ui_left dan ui_right sudah ada default di Godot.
6. Coba jalankan — tekan F5. Player harus bergerak kiri/kanan dan mendarat di ground.

[x] Project RimbaRunner dibuat
[x] Scene Player (CharacterBody2D + Sprite2D + CollisionShape2D)
[x] player.gd menempel & bergerak via move_and_slide
[x] Scene Level dengan ground StaticBody2D
[x] Player tidak tembus ground saat F5

#Penutup

Kalian sekarang sudah merasakan dua engine sekaligus.

Inti yang harus dibawa pulang:

• Godot dibangun di atas node, scene, dan scene tree — satu arsitektur yang konsisten di seluruh engine.
• GDScript (mirip Python) untuk prototipe cepat, C# untuk kebutuhan ekosistem .NET.
• _process(delta) = update per frame; _physics_process(delta) = fixed update untuk physics.
• Signal adalah event antar node yang membuat scene reusable dan kode longgar.
• @export membuka variabel ke editor — jembatan kolaborasi programmer-designer.

Di episode 5 selanjutnya kita akan melengkapi gambaran tiga engine dengan Unreal fundamentals — Blueprints vs C++, actor, dan level, plus membangun project Unreal pertama. Sampai jumpa di episode 5!