Pengembangan Game di Rust: Bevy, Macroquad, dan Lainnya

Banyak orang belajar Rust karena ingin membuat game. Itu alasan yang bagus sekali! Game butuh kecepatan, pemakaian memori yang hati-hati, dan kode yang tidak crash di tengah pertarungan melawan boss. Semua itu persis hal-hal yang dikuasai Rust.

Halaman ini memberimu gambaran yang jujur: apa saja yang sudah dibuat orang dengan Rust, engine atau library mana yang sebaiknya dipilih, dan dua ide yang dipakai hampir semua game, yaitu game loop dan ECS. Setelah itu kamu akan melihat program pertama di Bevy dan di Macroquad.

Contoh mana yang jalan di mana? Game loop, dunia ECS mungil, dan latihan di halaman ini ditulis dengan Rust biasa, jadi ada tombol “Coba sendiri” untuk menjalankannya di Rust Playground. Bevy dan Macroquad membuka jendela, jadi contoh-contohnya untuk dijalankan di komputermu sendiri dengan cargo run. Contoh Macroquad sudah di-compile (juga untuk web) saat halaman ini ditulis; contoh Bevy mengikuti contoh resmi Bevy.

Kondisi pengembangan game di Rust, apa adanya

Situs komunitas Are We Game Yet? (bahasa Inggris) memantau ekosistem game Rust. Jawabannya atas pertanyaannya sendiri adalah: “Almost. We have the blocks, bring your own glue.” Artinya kira-kira: hampir. Balok-baloknya sudah ada, lemnya bawa sendiri. Itu ringkasan yang adil.

Yang sudah bagus sekarang:

• Game sungguhan sudah dirilis. Tiny Glade, game santai membangun kastel di Steam, dan Veloren, RPG voxel open-source, sama-sama tercatat di Are We Game Yet sebagai game Rust.
• Engine yang kuat. Bevy punya komunitas yang besar dan aktif, dengan rilis baru setiap beberapa bulan.
• Banyak “balok bangunan”. Are We Game Yet mencantumkan crate untuk fisika, audio, input, networking, UI, dan lainnya.
• Game-mu bisa jalan di web. Rust bisa di-compile ke WebAssembly, jadi banyak game Rust juga bisa dimainkan di browser.

Yang masih sulit:

• Belum ada “Unity-nya Rust”. Kebanyakan engine Rust berbasis kode (code-first). Editor visual memang ada (Fyrox punya satu, dan Godot bisa memakai Rust), tapi masih lebih muda dibanding tool komersial besar.
• Banyak yang berubah. Bevy masih sebelum versi 1.0, dan setiap rilis membawa perubahan yang merusak kode lama. Tutorial dari tahun lalu mungkin sudah tidak bisa di-compile.
• Waktu compile. Engine besar butuh beberapa menit untuk build pertama. Kamu akan belajar triknya di bawah.

Kalau targetmu merilis game 3D komersial tahun depan bersama tim artist, Unity, Unreal, atau Godot lebih aman. Kalau kamu ingin belajar, membuat game 2D, ikut game jam, membuat tool atau simulasi, atau memang suka Rust, ini tempat yang sangat menyenangkan. 🦀

Engine atau library mana?

Ada dua jenis tool. Engine memberimu struktur lengkap: bagaimana objek game, scene, dan aset bekerja. Library (atau framework) memberimu jendela, fungsi menggambar, suara, dan input, lalu sisanya kamu atur sendiri.

Crate	Apa itu	Cocok untuk	Yang perlu diketahui
bevy (0.20)	Engine 2D dan 3D lengkap yang dibangun di atas ECS	Proyek lebih besar, 3D, belajar cara kerja engine modern	Engine Rust paling terkenal. Ada perubahan yang merusak kode di setiap rilis; build pertama lama
macroquad (0.4)	Library 2D sederhana, terinspirasi raylib	Game pertamamu, game jam, game web	Dependency-nya sangat sedikit, build-nya cepat. Kamu memanggil fungsi menggambar di dalam loop
ggez (0.10)	Framework 2D ringan, terinspirasi LÖVE	Game 2D dengan struktur yang jelas	Kamu mengimplementasikan trait EventHandler dengan update dan draw
fyrox (1.0)	Engine 2D dan 3D dengan editor scene	Orang yang ingin editor, seperti di Godot atau Unity	Mencapai versi 1.0 pada 2026. Komunitasnya lebih kecil dari Bevy
raylib (6.0)	Binding Rust untuk library C raylib	Orang yang sudah kenal raylib dari C	Butuh CMake dan build tool C, karena ia mem-build library C-nya (lihat FFI)
godot (0.5, “gdext”)	Binding Rust untuk engine Godot 4	Memakai editor Godot dengan logika game di Rust	Kamu menulis class Rust yang dimuat Godot sebagai GDExtension

Aturan sederhananya: mulailah dengan Macroquad untuk game 2D pertamamu. Pilih Bevy kalau kamu ingin engine lengkap dan senang belajar ECS. Pilih Godot dengan gdext atau Fyrox kalau kamu ingin editor untuk menaruh objek secara visual.

Game loop

Hampir setiap game adalah satu loop besar yang berjalan terus-menerus sampai kamu keluar:

1. Baca input (keyboard, mouse, controller).
2. Update game: gerakkan objek, cek tabrakan, hitung poin.
3. Gambar tampilan baru di layar.

Satu putaran loop disebut frame. Pada 60 frame per detik (FPS), setiap frame punya waktu sekitar 16 milidetik. Tapi tidak semua frame butuh waktu yang sama. Komputermu mungkin sedang sibuk, atau satu frame mungkin perlu memuat file.

Kalau game-mu menggerakkan pemain “2 unit setiap frame”, game akan berjalan lebih cepat di komputer cepat dan lebih lambat di komputer lambat. Solusi yang populer adalah fixed timestep (langkah waktu tetap): logika game selalu maju dalam langkah yang sama besar (di sini 10 ms), dan setiap frame menjalankan langkah sebanyak yang muat dalam waktu yang sudah berlalu. Sisa waktunya menunggu di sebuah accumulator sampai frame berikutnya.

const STEP_MS: u32 = 10; // logika game selalu maju 10 ms sekali jalan
const SPEED: i32 = 2; // pemain bergerak 2 unit per update

fn main() {
    // Berapa lama setiap frame sebenarnya. Game sungguhan mengukurnya dengan jam.
    let frame_times = [16, 16, 45, 5, 16, 33];

    let mut accumulator = 0; // waktu yang sudah berlalu tapi belum disimulasikan
    let mut position = 0;

    for (frame, elapsed) in frame_times.into_iter().enumerate() {
        accumulator += elapsed;

        // Jalankan langkah tetap sebanyak yang muat dalam waktu yang ada
        let mut updates = 0;
        while accumulator >= STEP_MS {
            position += SPEED; // update(): logika game
            accumulator -= STEP_MS;
            updates += 1;
        }

        // render(): gambar sekali per frame, apa pun yang terjadi
        println!("frame {frame}: {elapsed:>2} ms, {updates} update, pemain di {position:>2}, sisa {accumulator} ms");
    }
}

Output:

frame 0: 16 ms, 1 update, pemain di  2, sisa 6 ms
frame 1: 16 ms, 2 update, pemain di  6, sisa 2 ms
frame 2: 45 ms, 4 update, pemain di 14, sisa 7 ms
frame 3:  5 ms, 1 update, pemain di 16, sisa 2 ms
frame 4: 16 ms, 1 update, pemain di 18, sisa 8 ms
frame 5: 33 ms, 4 update, pemain di 26, sisa 1 ms

▶ Coba sendiri

Lihat frame 2: frame itu lambat (45 ms), jadi game menjalankan 4 update untuk mengejar ketertinggalan. Totalnya 131 ms berlalu, dan game menjalankan 13 update masing-masing 10 ms. Pemain berakhir di posisi 26, bagaimanapun waktunya terbagi ke dalam frame. Ini membuat fisika stabil dan sama di setiap komputer, yang juga penting untuk replay dan game online. Satu bahayanya: kalau sebuah frame sangat lambat, game menjalankan banyak update untuk mengejar, sehingga frame berikutnya ikut lambat. Karena itu loop sungguhan juga membatasi jumlah update per frame (jam game di Bevy, misalnya, secara default maju paling banyak 250 ms per frame).

Cara umum lainnya adalah delta time: kamu mengukur berapa detik sejak frame terakhir dan mengalikan kecepatan dengan angka itu (x += speed * dt). Cara ini lebih sederhana, dan itulah yang dilakukan contoh Bevy dan Macroquad di bawah. Banyak engine memakai keduanya: delta time untuk animasi, langkah tetap untuk fisika.

Apa itu ECS: entity, component, system

Di banyak bahasa, kamu akan membuat class Player, class Enemy yang mewarisi Character, dan seterusnya. Itu cepat jadi berantakan: bagaimana dengan musuh yang juga bisa dipungut? Kebanyakan engine game Rust memakai ECS (Entity Component System) sebagai gantinya:

• Entity hanyalah sebuah ID, seperti angka. Ia tidak punya data dan perilaku sendiri.
• Component adalah potongan data biasa yang kamu pasang ke sebuah entity: Position, Velocity, Health. Di Rust, ini adalah struct atau enum biasa.
• System adalah fungsi yang berjalan untuk setiap entity yang punya component tertentu. Contohnya, system gerakan bekerja pada semua yang punya Position sekaligus Velocity.

Sebuah pohon punya Position tapi tidak punya Velocity, jadi system gerakan melewatinya. Ingin pohonnya bergerak? Beri saja Velocity. Kamu tidak perlu mengubah class apa pun. Data dan perilaku tetap terpisah, dan ini juga cocok dengan aturan borrowing (peminjaman) Rust.

Berikut dunia ECS mungil dengan Rust biasa. Setiap tipe component tinggal di vektor-nya sendiri, dan ID entity adalah indeksnya. None berarti “entity ini tidak punya component itu” (lihat Option).

struct Position { x: i32, y: i32 }
struct Velocity { dx: i32, dy: i32 }

// Entity hanyalah ID: indeks ke setiap daftar component
type Entity = usize;

#[derive(Default)]
struct World {
    names: Vec<&'static str>,
    positions: Vec<Option<Position>>,
    velocities: Vec<Option<Velocity>>,
}

impl World {
    fn spawn(&mut self, name: &'static str, pos: Option<Position>, vel: Option<Velocity>) -> Entity {
        self.names.push(name);
        self.positions.push(pos);
        self.velocities.push(vel);
        self.names.len() - 1
    }
}

// Sebuah system: bekerja pada setiap entity yang punya Position DAN Velocity
fn movement_system(world: &mut World) {
    for (pos, vel) in world.positions.iter_mut().zip(&world.velocities) {
        if let (Some(pos), Some(vel)) = (pos, vel) {
            pos.x += vel.dx;
            pos.y += vel.dy;
        }
    }
}

// System lain: mencetak setiap entity yang punya Position
fn print_system(world: &World, tick: u32) {
    println!("tick {tick}:");
    for (id, pos) in world.positions.iter().enumerate() {
        if let Some(pos) = pos {
            println!("  #{id} {:<6} di ({}, {})", world.names[id], pos.x, pos.y);
        }
    }
}

fn main() {
    let mut world = World::default();
    world.spawn("pemain", Some(Position { x: 0, y: 0 }), Some(Velocity { dx: 1, dy: 0 }));
    world.spawn("pohon", Some(Position { x: 5, y: 2 }), None); // tanpa Velocity: tidak pernah bergerak
    world.spawn("panah", Some(Position { x: 0, y: 3 }), Some(Velocity { dx: 3, dy: -1 }));

    for tick in 1..=2 {
        movement_system(&mut world);
        print_system(&world, tick);
    }
}

Output:

tick 1:
  #0 pemain di (1, 0)
  #1 pohon  di (5, 2)
  #2 panah  di (3, 2)
tick 2:
  #0 pemain di (2, 0)
  #1 pohon  di (5, 2)
  #2 panah  di (6, 1)

▶ Coba sendiri

Pohonnya tetap di (5, 2) karena tidak punya Velocity. Tidak ada yang menulis “pohon tidak bergerak”; itu otomatis mengikuti dari datanya. Library ECS sungguhan jauh lebih cepat dan lebih pintar dari ini (mereka menyimpan component supaya CPU bisa membacanya dengan cepat, dan menjalankan system secara paralel), tapi idenya sama.

Aplikasi Bevy pertamamu

Bevy adalah engine Rust yang paling terkenal, dan semua yang ada di dalamnya adalah ECS. Versi 0.20 rilis pada Oktober 2026. Bevy butuh Rust stable terbaru, jadi update dulu, lalu buat proyek:

rustup update
cargo new my_bevy_game
cd my_bevy_game
cargo add bevy

Di Linux kamu juga butuh beberapa library sistem (suara, input, grafis). Panduan setup Bevy (bahasa Inggris) mencantumkannya untuk setiap distribusi. Di Windows kamu butuh Visual Studio C++ Build Tools, dan di macOS butuh Xcode command line tools.

Program ini berdasarkan contoh resmi Bevy 2d/move_sprite. Ia menggambar kotak oranye yang meluncur ke kiri dan ke kanan. (Contoh resminya memuat sebuah gambar; di sini dipakai kotak berwarna polos, jadi kamu tidak butuh file gambar apa pun.)

use bevy::prelude::*;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins) // jendela, rendering, input, audio...
        .add_systems(Startup, setup) // berjalan sekali di awal
        .add_systems(Update, sprite_movement) // berjalan setiap frame
        .run();
}

// Sebuah component: ke arah mana entity ini bergerak
#[derive(Component)]
enum Direction {
    Left,
    Right,
}

fn setup(mut commands: Commands) {
    commands.spawn(Camera2d);

    // Spawn satu entity dengan tiga component
    commands.spawn((
        Sprite::from_color(Color::srgb(1.0, 0.5, 0.2), Vec2::new(50.0, 50.0)),
        Transform::from_xyz(0.0, 0.0, 0.0),
        Direction::Right,
    ));
}

// Sebuah system: berjalan untuk setiap entity yang punya Direction DAN Transform
fn sprite_movement(time: Res<Time>, mut sprite_position: Query<(&mut Direction, &mut Transform)>) {
    for (mut logo, mut transform) in &mut sprite_position {
        match *logo {
            Direction::Right => transform.translation.x += 150. * time.delta_secs(),
            Direction::Left => transform.translation.x -= 150. * time.delta_secs(),
        }

        if transform.translation.x > 200. {
            *logo = Direction::Left;
        } else if transform.translation.x < -200. {
            *logo = Direction::Right;
        }
    }
}

Bandingkan dengan dunia ECS mungil di atas. #[derive(Component)] mengubah enum biasa menjadi component. commands.spawn((...)) membuat entity dengan sebuah tuple berisi component. Dan Query<(&mut Direction, &mut Transform)> meminta Bevy “setiap entity yang punya keduanya”, persis seperti yang dilakukan movement_system kita dengan zip. time.delta_secs() adalah delta time dari bagian game loop, jadi kotaknya bergerak 150 piksel per detik di komputer mana pun.

Jalankan dengan cargo run. Build pertama meng-compile ratusan crate dan bisa makan waktu beberapa menit, jadi bersabarlah. Setelah itu, build ulang jauh lebih cepat.

Bikin Bevy lebih cepat di-compile (dan dijalankan)

Panduan setup Bevy menyarankan dua hal. Pertama, tambahkan ini ke Cargo.toml. Ini mengoptimalkan Bevy dan dependency lainnya, tapi kode milikmu sendiri tetap cepat di-compile:

[dependencies]
bevy = "0.20"

# Aktifkan sedikit optimasi di profile dev.
[profile.dev]
opt-level = 1

# Aktifkan banyak optimasi di profile dev untuk dependency.
[profile.dev.package."*"]
opt-level = 3

Tanpa ini, build debug sebuah game bisa sangat lambat: frame rate rendah dan waktu loading lama. Dependency hanya di-compile sekali, jadi kamu hanya membayar biaya optimasinya di build pertama. (Profile dijelaskan di halaman Performa Rust.)

Kedua, selama masa pengembangan, nyalakan feature dynamic_linking. Bevy lalu di-build sebagai shared library terpisah, jadi Cargo tidak perlu me-link seluruh Bevy ke programmu lagi setiap kali ada perubahan:

cargo run --features bevy/dynamic_linking

Dua peringatan dari panduan Bevy: di Windows, dynamic_linking hanya bekerja bersama pengaturan opt-level di atas. Dan jangan rilis game-mu dengan feature ini: game-mu akan butuh file library tambahan di sebelahnya. Build versi rilis tanpa feature ini. Panduan itu juga menunjukkan cara memakai linker yang lebih cepat (lld atau mold), yang sangat membantu di Linux.

Jendela Macroquad

Macroquad terasa sangat berbeda. Tidak ada ECS dan tidak ada app builder: kamu menulis game loop sendiri, dan menggambar dengan fungsi sederhana seperti draw_circle. Dependency-nya sangat sedikit, jadi build dari nol hanya butuh hitungan detik, bukan menit.

cargo new move_the_ball
cd move_the_ball
cargo add macroquad

[dependencies]
macroquad = "0.4"

Game kecil ini menampilkan bola yang bisa kamu gerakkan dengan tombol panah:

use macroquad::prelude::*;

#[macroquad::main("Move the Ball")]
async fn main() {
    let mut player = vec2(screen_width() / 2.0, screen_height() / 2.0);
    let speed = 250.0; // piksel per detik

    loop {
        // 1. Input: tombol panah menggerakkan pemain
        let dt = get_frame_time(); // detik sejak frame terakhir
        if is_key_down(KeyCode::Right) {
            player.x += speed * dt;
        }
        if is_key_down(KeyCode::Left) {
            player.x -= speed * dt;
        }
        if is_key_down(KeyCode::Down) {
            player.y += speed * dt;
        }
        if is_key_down(KeyCode::Up) {
            player.y -= speed * dt;
        }
        if is_key_pressed(KeyCode::Escape) {
            break;
        }

        // 2. Jaga pemain tetap di dalam layar
        player.x = player.x.clamp(0.0, screen_width());
        player.y = player.y.clamp(0.0, screen_height());

        // 3. Gambar semuanya untuk frame ini
        clear_background(DARKBLUE);
        draw_circle(player.x, player.y, 20.0, ORANGE);
        draw_text("Arrow keys to move, Esc to quit", 20.0, 30.0, 28.0, WHITE);

        next_frame().await
    }
}

Kamu bisa melihat tiga langkah game loop: input, update, gambar. #[macroquad::main("Move the Ball")] membuka jendela dengan judul itu. main bersifat async, tapi kamu tidak butuh Tokio atau harus paham async: next_frame().await cukup berarti “tampilkan frame ini dan tunggu frame berikutnya”. Di Linux, README Macroquad mencantumkan beberapa paket sistem yang perlu diinstal dulu (pkg-config libx11-dev libxi-dev libgl1-mesa-dev libasound2-dev di Ubuntu).

Game di web (WebAssembly)

Macroquad dan Bevy sama-sama bisa mem-build game-mu untuk browser sebagai WebAssembly. Kalau Wasm masih baru buatmu, baca Rust dan WebAssembly dulu. Kamu selalu mulai dengan menambahkan target Wasm:

rustup target add wasm32-unknown-unknown

Macroquad membuat ini sangat mudah. Satu perintah menghasilkan file .wasm:

cargo build --release --target wasm32-unknown-unknown

File-nya ada di target/wasm32-unknown-unknown/release/move_the_ball.wasm (untuk contoh di atas ukurannya sekitar 600 KB). README Macroquad memberikan index.html pendek yang memuatnya dengan sebuah file JavaScript kecil, mq_js_bundle.js. Taruh kedua file di satu folder dan sajikan dengan web server lokal apa saja, misalnya basic-http-server . (instal dengan cargo install basic-http-server). Mengklik dua kali file HTML-nya biasanya tidak berhasil, karena browser memblokir pemuatan file .wasm langsung dari disk.

Bevy memakai wasm-bindgen untuk membuat kode perekat JavaScript. Langkah-langkah ini diadaptasi dari README contoh Bevy (untuk proyek my_bevy_game di atas):

cargo install wasm-bindgen-cli
cargo build --release --target wasm32-unknown-unknown
wasm-bindgen --out-dir web --target web target/wasm32-unknown-unknown/release/my_bevy_game.wasm

Perintah ini menulis file .js dan _bg.wasm ke folder web; sebuah halaman HTML kecil meng-import file .js itu dan menjalankan game-nya. Panduan setup Bevy juga menyarankan profile wasm-release dengan opt-level = "s" supaya ukuran download lebih kecil. Build web adalah cara yang bagus untuk membagikan karya game jam: orang bisa langsung main dengan satu klik, tanpa perlu menginstal apa pun.

Kesalahan umum

Bergerak sejauh jumlah tetap setiap frame. x += 5.0 di setiap frame berarti game berjalan dua kali lebih cepat di 120 FPS dibanding di 60 FPS. Kalikan dengan delta time (x += speed * dt) atau pakai fixed timestep.

Mengikuti tutorial Bevy yang lama. Bevy mengubah API-nya di setiap rilis, jadi tulisan blog untuk 0.12 sering tidak bisa di-compile dengan 0.20. Cek versi yang dipakai sebuah tutorial, dan utamakan contoh resmi untuk versimu. Setiap rilis juga punya panduan migrasi di situs Bevy.

Build debug yang lambat. Kalau game Bevy-mu berjalan hanya beberapa frame per detik, kemungkinan kamu lupa pengaturan opt-level di Cargo.toml.

Mulai terlalu besar. RPG open-world adalah proyek pertama yang sulit di bahasa apa pun. Mulailah dengan Pong, Snake, Breakout, atau Flappy Bird. Selesaikan, lalu buat yang berikutnya sedikit lebih besar.

Latihan

1. State game dengan enum

Setiap game punya beberapa layar: menu, permainannya sendiri, layar pause, “game over”. Buat enum GameState dengan Menu, Playing, Paused, dan GameOver, serta enum Input dengan Enter, Escape, dan PlayerDied. Tulis fn next_state(state: GameState, input: Input) -> GameState: Enter memulai game dari menu, Escape mem-pause dan melanjutkan game, mati mengakhiri game, dan Enter di layar “game over” kembali ke menu. Input lain tidak mengubah apa pun. Beri fungsi itu daftar input yang sudah ditentukan dan cetak setiap perubahannya. Petunjuk: lakukan match pada tuple (state, input), dan akhiri dengan (same, _) => same.

Lihat solusi

#[derive(Debug, Clone, Copy)]
enum GameState {
    Menu,
    Playing,
    Paused,
    GameOver,
}

#[derive(Debug, Clone, Copy)]
enum Input {
    Enter,
    Escape,
    PlayerDied,
}

fn next_state(state: GameState, input: Input) -> GameState {
    match (state, input) {
        (GameState::Menu, Input::Enter) => GameState::Playing,
        (GameState::Playing, Input::Escape) => GameState::Paused,
        (GameState::Paused, Input::Escape) => GameState::Playing,
        (GameState::Playing, Input::PlayerDied) => GameState::GameOver,
        (GameState::GameOver, Input::Enter) => GameState::Menu,
        // Selain itu: abaikan input dan tetap di state yang sama
        (same, _) => same,
    }
}

fn main() {
    use Input::*; // supaya kita bisa menulis Enter, bukan Input::Enter
    let inputs = [Escape, Enter, Escape, PlayerDied, Escape, PlayerDied, Enter];

    let mut state = GameState::Menu;
    for input in inputs {
        let new_state = next_state(state, input);
        println!("{state:?} + {input:?} -> {new_state:?}");
        state = new_state;
    }
}

Output:

Menu + Escape -> Menu
Menu + Enter -> Playing
Playing + Escape -> Paused
Paused + PlayerDied -> Paused
Paused + Escape -> Playing
Playing + PlayerDied -> GameOver
GameOver + Enter -> Menu

▶ Coba sendiri

Dengan match pada tuple, semua perubahan yang diizinkan tercantum di satu tempat, dan arm terakhir membuat semua input lain tidak berpengaruh. Pemain yang sedang pause tidak bisa mati, karena (Paused, PlayerDied) jatuh ke (same, _). Bevy punya ide yang sama secara bawaan, namanya States.

Ringkasan

• Rust adalah pilihan nyata untuk game: “hampir sampai”, dengan engine yang kuat (Bevy), library sederhana (Macroquad, ggez), pilihan berbasis editor (Fyrox, Godot dengan gdext), dan banyak balok bangunan.
• Setiap game menjalankan loop: input, update, gambar. Pakai delta time atau fixed timestep supaya kecepatan game tidak bergantung pada frame rate.
• ECS membagi game menjadi entity (ID), component (data biasa), dan system (fungsi yang berjalan pada entity dengan component tertentu).
• Bevy sepenuhnya memakai ECS. Tambahkan pengaturan profile opt-level, dan pakai dynamic_linking hanya selama pengembangan.
• Macroquad adalah awal tercepat untuk 2D: kamu menulis loop sendiri dan menggambar dengan fungsi sederhana.
• Keduanya bisa mem-build untuk browser dengan target wasm32-unknown-unknown.

Kuis singkat

Kuis singkat

1. Di ECS, apa itu entity?

Class yang punya data dan method Hanya sebuah ID tempat component dipasang Fungsi yang berjalan setiap frame

2. Kenapa fixed timestep membuat game berperilaku sama di setiap komputer?

Karena setiap frame jadi butuh tepat 10 ms Karena frame yang lambat dimatikan Karena logika game selalu maju dalam langkah yang sama besar, bagaimanapun waktunya terbagi ke dalam frame

3. Pengaturan Bevy mana yang TIDAK boleh ikut saat kamu merilis game yang sudah jadi?

Feature dynamic_linking opt-level = 3 untuk dependency DefaultPlugins

4. Kamu ingin membuat game 2D kecil pertamamu dengan waktu build yang sangat singkat. Crate mana yang disarankan halaman ini?

Fyrox raylib Bevy Macroquad

Skor: 0 / 4

Bacaan lebih lanjut

• Are We Game Yet? (bahasa Inggris): gambaran komunitas tentang engine game Rust, library untuk fisika, audio, dan networking, serta game yang dibuat dengan Rust.
• Bevy Quick Start: Setup (bahasa Inggris): panduan resmi untuk menginstal Bevy, pengaturan compile cepat, serta profile rilis dan Wasm.
• Game development in Rust with Macroquad (bahasa Inggris): buku online gratis yang membangun game space shooter lengkap langkah demi langkah dengan Macroquad.
• The godot-rust book (bahasa Inggris): cara menulis logika game Godot 4 dengan Rust memakai gdext.
• Game Loop — Game Programming Patterns (bahasa Inggris): penjelasan yang ramah dan detail tentang game loop, delta time, dan fixed timestep.