Learn Rust Coding · Lekcja

Tworzenie i poruszanie encjami

Umieści Pan/Pani obiekty na ekranie.

Tworzenie i poruszanie encjami to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Commands: odroczone tworzenie

Nie można bezpośrednio modyfikować obiektu World podczas równoległego działania systemów. Zamiast tego kolejkuj zmiany strukturalne za pośrednictwem Commands.

Tworzenie, usuwanie encji i dodawanie komponentów jest rejestrowane, a następnie wykonywane na końcu etapu harmonogramu, co zapewnia bezpieczny dostęp.

fn setup(mut commands: Commands) {
    commands.spawn_empty();
}

Tworzenie za pomocą Bundle

Bundle to grupa komponentów wstawianych jednocześnie. Najprostszy bundle jest po prostu krotką komponentów.

Bevy traktuje każdy element krotki jako komponent do dołączenia, dzięki czemu jedno wywołanie spawn może nadać encji wszystkie początkowe dane.

fn setup(mut commands: Commands) {
    commands.spawn((
        Position { x: 0.0, y: 0.0 },
        Velocity { x: 1.5, y: 0.0 },
        Player,
    ));
}

Kamera, która pozwala widzieć

Bez kamery nic nie zostanie wyrenderowane. W grach 2D należy utworzyć Camera2d w systemie startowym.

Kamera sama jest encją z komponentami kamery — to kolejny przykład jednolitości ECS. Wszystko w scenie jest encją.

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

Tworzenie sprite'a

Aby coś narysować, nadaj encji komponenty Sprite i Transform. Transform przechowuje pozycję, obrót i skalę w przestrzeni świata.

Kolorowy sprite nie wymaga zasobu obrazu, co ułatwia prototypowanie ruchu przed zaimportowaniem grafiki.

commands.spawn((
    Sprite::from_color(Color::srgb(0.2, 0.7, 1.0), Vec2::new(40.0, 40.0)),
    Transform::from_xyz(0.0, 0.0, 0.0),
    Velocity { x: 80.0, y: 0.0 },
));

Transform a własna pozycja

W rzeczywistych grach Bevy zazwyczaj modyfikuje się wbudowany Transform, a nie własny komponent Position, ponieważ renderowanie odczytuje Transform bezpośrednio.

Przesunięcie ma typ Vec3. W grze 2D zmienia się x i y, a z pozostawia do ustalania kolejności rysowania.

#[derive(Component)]
struct Velocity { x: f32, y: f32 }

fn apply_velocity(mut q: Query<(&mut Transform, &Velocity)>) {
    for (mut tf, vel) in &mut q {
        tf.translation.x += vel.x;
        tf.translation.y += vel.y;
    }
}

Iterowanie po zapytaniu mutowalnym

Aby zmieniać dane komponentów, zażądaj &mut T i iteruj po &mut query. Każdy element dostarcza mutowalne referencje.

Bevy gwarantuje, że żadne dwa systemy nie będą jednocześnie posiadać konfliktującego mutowalnego dostępu, więc ta pętla jest bezpieczna nawet podczas działania innych systemów.

fn move_all(mut q: Query<&mut Transform, With<Player>>) {
    for mut tf in &mut q {
        tf.translation.x += 1.0;
    }
}

Tworzenie wielu encji

Pętle pozwalają zapełniać poziom. Wywołaj spawn wewnątrz rustowej pętli for, aby utworzyć siatkę przeszkód lub rój przeciwników.

Każda iteracja kolejkuje własne polecenie, a wszystkie polecenia są wykonywane razem na granicy etapu.

fn spawn_row(mut commands: Commands) {
    for i in 0..5 {
        commands.spawn((
            Sprite::from_color(Color::WHITE, Vec2::splat(20.0)),
            Transform::from_xyz(i as f32 * 30.0, 0.0, 0.0),
        ));
    }
}

Usuwanie encji

Usuń encję całkowicie za pomocą commands.entity(id).despawn(). Zwolni to jej komponenty i umożliwi ponowne wykorzystanie indeksu encji.

Zwykle usuwa się encję w systemie, który pobrał jej identyfikator Entity, na przykład gdy pocisk opuścił ekran.

fn cleanup(mut commands: Commands, q: Query<(Entity, &Transform)>) {
    for (e, tf) in &q {
        if tf.translation.y > 600.0 {
            commands.entity(e).despawn();
        }
    }
}

Dodawanie komponentów później

Można w czasie działania programu dołączać nowe komponenty do istniejącej encji za pomocą insert. Tak nadaje się wzmocnionemu graczowi znacznik Shield.

Usuwanie działa analogicznie za pomocą remove::<T>(). Obie operacje są zmianami strukturalnymi, więc przechodzą przez Commands.

commands.entity(player).insert(Shield { hits: 3 });
// later
commands.entity(player).remove::<Shield>();

Wartość Z ustala warstwy

W grafice 2D wartość z w przesunięciu transformacji określa kolejność rysowania. Większa wartość z oznacza renderowanie na wierzchu.

Ustaw niską wartość z dla tła, a wyższą dla gracza, aby sprite'y nigdy nie znikały za scenerią.

// background behind, player in front
commands.spawn((bg_sprite, Transform::from_xyz(0.0, 0.0, 0.0)));
commands.spawn((player_sprite, Transform::from_xyz(0.0, 0.0, 10.0)));

Łączenie elementów

Twórz encje w Startup, a poruszaj nimi w Update. System startowy tworzy kamerę i encje raz, natomiast system aktualizacji przesuwa je w każdej klatce.

Taki podział utrzymuje inicjalizację poza często wykonywaną ścieżką klatkową.

App::new()
    .add_plugins(DefaultPlugins)
    .add_systems(Startup, setup)
    .add_systems(Update, apply_velocity)
    .run();

Szybkie sprawdzenie

Zastanów się, jak są stosowane zmiany strukturalne.

Podsumowanie: tworzenie i poruszanie

Tworzysz encje za pomocą bundle'i i Commands, renderujesz je przy użyciu Sprite oraz Transform, a poruszasz nimi, modyfikując transformację w systemie Update.

Usuwanie encji i wstawianie komponentów również odbywa się za pomocą poleceń. Następnie sprawimy, że ruch będzie reagował na klawiaturę i rzeczywisty upływ czasu.

Często zadawane pytania

Czy lekcja „Tworzenie i poruszanie encjami” jest bezpłatna?

Tak — pełny tekst „Tworzenie i poruszanie encjami” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Tworzenie i poruszanie encjami”?

Umieści Pan/Pani obiekty na ekranie. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Tworzenie i poruszanie encjami”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding