Omówienie ognia w technologii Flutter

1. Wprowadzenie

Co utworzysz

Flame to silnik gier 2D oparty na Flutterze. W tym ćwiczeniu utworzysz grę inspirowaną jednym z klasyków gier wideo z lat 70. – Breakout Steve'a Wozniaka. Za pomocą Google Antigravity będziesz krok po kroku prosić agenta o utworzenie komponentów Flame Component dla paletki, piłki i cegieł, animowanie ruchu paletki za pomocą komponentów Flame Effect oraz zintegrowanie Flame z systemem zarządzania stanem Fluttera.

Po zakończeniu gra powinna wyglądać jak ten animowany GIF, choć powinna działać nieco wolniej:

Znacznie przyspieszone nagranie ekranu przedstawiające rozgrywkę w ukończonej grze w zbijanie klocków.

Ukończona gra spełnia te wymagania:

  • Działa na wszystkich 6 platformach obsługiwanych przez Flutter: Android, iOS, Linux, macOS, Windows i sieć.
  • Utrzymuje co najmniej 60 kl./s przy użyciu pętli gry Flame.
  • Wykorzystuje pakiety Flutter, takie jak google_fonts i flutter_animate, aby odtworzyć klimat gier arkadowych z lat 70. i 80.

Twoja ścieżka szkoleniowa

To ćwiczenie przeprowadzi Cię przez proces tworzenia gry krok po kroku:

  1. Konfigurowanie środowiska Flutter – skonfiguruj Flutter i Google Antigravity na platformie docelowej.
  2. Utwórz projekt – poproś Antigravity o utworzenie pustego projektu Flutter z Flame, flutter_animate, google_fonts i material_ui.
  3. Tworzenie gry – skonfiguruj kamerę o stałej rozdzielczości i dodaj komponent PlayArea do świata gry.
  4. Wyświetlanie piłki – dodaj ruchomy komponent Ball sterowany przez pętlę gry i wektory prędkości Flame.
  5. Odbijanie się – włącz wykrywanie kolizji i pola trafień, aby piłka odbijała się od ścian.
  6. Odbijanie piłki – dodaj sterowaną przez gracza Bat, która obsługuje przeciąganie i wprowadzanie danych za pomocą klawiatury, używając MoveToEffect.
  7. Zburz mur – wygeneruj siatkę komponentów Brick i zwiększaj prędkość piłki, gdy klocki się rozpadają.
  8. Wygraj grę – zarządzaj stanami gry i wyświetlaj nakładki widżetów retro we Flutterze za pomocą GameWidget.controlled.
  9. Zapisywanie wyniku – zsynchronizuj wynik gracza z interfejsem Fluttera za pomocą ValueNotifier i animuj nakładki za pomocą flutter_animate.

Czego się nauczysz

  • jak współpracować z Google Antigravity, aby iteracyjnie tworzyć i dostosowywać grę Flame;
  • Jak działają podstawowe funkcje Flame, zaczynając od GameWidget.
  • Jak używać pętli gry do ruchu niezależnego od liczby klatek.
  • Jak działają Component we Flame (podobne do Widget we Flutterze).
  • Jak wykrywać kolizje i reagować na nie za pomocą hitboxów.
  • Jak używać Effect do animowania i usuwania Component.
  • Jak nakładać Widget Fluttera na grę Flame.
  • jak zintegrować Flame z zarządzaniem stanem we Flutterze;

Wymagania wstępne

  • Podstawowa znajomość składni Fluttera i Darta.

2. Konfigurowanie środowiska Flutter

Edytujący

W tym ćwiczeniu jako środowisko programistyczne oparte na AI wykorzystujemy Google Antigravity. W każdym kroku poprosisz Antigravity o wygenerowanie lub rozwinięcie komponentów gry, przeanalizujesz kluczowe koncepcje Flame w wygenerowanym kodzie i opcjonalnie poznasz odmiany gier arkadowych inspirowane różnymi epokami.

Wybierz cel programistyczny

Flutter tworzy aplikacje na wiele platform. Aplikacja może działać w tych systemach operacyjnych:

  • iOS
  • Android
  • Windows
  • macOS
  • Linux
  • internet

Często wybiera się jeden system operacyjny jako cel programistyczny. Jest to system operacyjny, na którym działa aplikacja podczas jej tworzenia.

Laptop oznaczony jako „urządzenie do programowania” połączony kablem z telefonem oznaczonym jako „urządzenie docelowe”.

Załóżmy na przykład, że do tworzenia aplikacji Flutter używasz laptopa z systemem Windows. Jeśli jako cel programistyczny wybierzesz Androida, podłączasz urządzenie z Androidem do laptopa z systemem Windows za pomocą kabla USB, a aplikacja, nad którą pracujesz, działa na tym podłączonym urządzeniu z Androidem (lub w emulatorze Androida). Możesz też wybrać system Windows jako środowisko docelowe, co pozwoli Ci uruchomić tworzoną aplikację jako aplikację komputerową dla systemu Windows obok edytora.

Zanim przejdziesz dalej, dokonaj wyboru. Zawsze możesz później uruchomić aplikację w innych systemach operacyjnych. Wybór celu programistycznego ułatwi kolejny krok.

Instalowanie Fluttera

Najbardziej aktualne instrukcje instalowania pakietu Flutter SDK znajdziesz zawsze na stronie docs.flutter.dev.

Instrukcje na stronie Fluttera obejmują instalację pakietu SDK, narzędzi dla konkretnych platform i wtyczek do edytora. Na potrzeby tego ćwiczenia zainstaluj to oprogramowanie:

  1. Flutter SDK
  2. Google Antigravity z włączoną oficjalną wtyczką Dart i Flutter (dostępną w sekcji Build with Google na rynku wtyczek).
  3. Oprogramowanie kompilatora dla wybranego środowiska docelowego (np. Visual Studio dla systemu Windows lub Xcode dla systemu macOS lub iOS).

W następnym kroku poprosisz Antigravity o utworzenie projektu Flutter i szkieletu początkowej gry Flame.

Rozwiązywanie problemów

Jeśli napotkasz problemy z konfiguracją, te pytania i odpowiedzi na Stack Overflow mogą Ci pomóc:

3. Utwórz projekt

Poproś Antigravity o utworzenie projektu

  1. Uruchom Google Antigravity i otwórz pusty katalog, w którym chcesz utworzyć grę (wybierz ścieżkę, która nie wymaga podwyższonych uprawnień ani nie zawiera spacji, np. folder w katalogu domowym lub C:\src\).
  2. W panelu czatu agenta Antigravity wyślij następującego prompta, aby utworzyć projekt Flutter, dodać zależności i połączyć minimalną grę Flame:
Create a new empty Flutter project named `brick_breaker` for a Breakout-style 2D arcade game. Add the `flame`, `flutter_animate`, `google_fonts`, and `material_ui` packages, and update `lib/main.dart` (importing `package:flame/game.dart` and `package:material_ui/material_ui.dart`) to run a basic `FlameGame` inside a `GameWidget`.

Zrozumienie wygenerowanego kodu

Antigravity uruchamia flutter create --empty, aby utworzyć szkielet projektu, dodaje flame, flutter_animate, google_fonts i material_ui do pubspec.yaml oraz aktualizuje lib/main.dart, aby hostować instancję FlameGame w GameWidget aplikacji Flutter:

void main() {
  final game = FlameGame();
  runApp(GameWidget(game: game));
}

Uruchamianie i testowanie gry

Uruchom aplikację w wybranym środowisku programistycznym, aby sprawdzić, czy wszystko działa. Wyświetli się nowe okno z pustym czarnym tłem. Najprostsza gra wideo na świecie jest teraz renderowana z częstotliwością 60 kl./s.

Okno aplikacji brick_breaker z całkowicie czarnym tłem.

4. Utwórz grę

Oceń grę

Gra w 2 wymiarach (2D) wymaga obszaru rozgrywki. W tym kroku utworzysz obszar gry o określonych wymiarach i użyjesz tych wymiarów do określenia rozmiaru pozostałych komponentów gry.

Współrzędne na obszarze gry można rozmieścić na różne sposoby. Zgodnie z jedną z konwencji kierunek mierzy się od środka ekranu, gdzie znajduje się punkt początkowy (0,0). Wartości dodatnie przesuwają elementy w prawo wzdłuż osi X i w górę wzdłuż osi Y. Ten standard jest powszechny w nowoczesnych silnikach gier 3D.

Gdy powstała oryginalna gra Breakout, konwencja polegała na umieszczeniu punktu początkowego w lewym górnym rogu. Kierunek dodatni osi X wskazywał w prawo, a kierunek dodatni osi Y – w dół. Aby zachować zgodność z tą epoką, w tej grze punkt początkowy znajduje się w lewym górnym rogu.

Prompt dla Antigravity dotyczący utworzenia gry i PlayArea

Wyślij w Antigravity następującego prompta, aby skonfigurować świat gry i obszar rozgrywki o stałej rozdzielczości:

Create a `BrickBreaker` subclass of `FlameGame` in `lib/src/brick_breaker.dart` with a fixed-resolution camera (820x1600, defined in `lib/src/config.dart`) anchored at the top-left corner. Add a `PlayArea` rectangle component (`lib/src/components/play_area.dart`, re-exported in `lib/src/components/components.dart`) that fills the game's width and height with a warm arcade background color (`0xfff2e8cf`), and wire `BrickBreaker` up in `lib/main.dart`.

Zrozumienie wygenerowanego kodu

PlayArea i płomień Component

Tam, gdzie Flutter ma Widget, Flame ma Component. Aplikacje Flutter składają się z drzew widżetów, a gry Flame – z drzew komponentów.

Drzewo widżetów Fluttera to niezmienny opis używany do aktualizowania trwałej i zmiennej warstwy RenderObject. Komponenty Flame są trwałe i modyfikowalne, zaprojektowane do bezpośredniego użycia w ramach systemu symulacji w lib/src/components/play_area.dart:

class PlayArea extends RectangleComponent with HasGameReference<BrickBreaker> {
  PlayArea() : super(paint: Paint()..color = const Color(0xfff2e8cf));

  @override
  FutureOr<void> onLoad() async {
    super.onLoad();
    size = Vector2(game.width, game.height);
  }
}

Aby uniknąć bałaganu podczas importowania, gdy dodajesz więcej komponentów, lib/src/components/components.dart używa dyrektywy export do ponownego eksportowania każdego komponentu z jednego pliku zbiorczego.

Kamera o stałej rozdzielczości i world

W pliku lib/src/brick_breaker.dart BrickBreaker konfiguruje grę tak, aby używała stałej rozdzielczości 820x1600:

class BrickBreaker extends FlameGame {
  BrickBreaker()
    : super(
        camera: CameraComponent.withFixedResolution(
          width: gameWidth,
          height: gameHeight,
        ),
      );

  @override
  FutureOr<void> onLoad() async {
    super.onLoad();
    camera.viewfinder.anchor = Anchor.topLeft;
    world.add(PlayArea());
  }
}

Gra zmienia rozmiar, aby wypełnić okno, w którym się znajduje, i w razie potrzeby dodaje paski.

W pliku onLoad kod wykonuje 2 kluczowe działania:

  1. Konfiguruje lewy górny róg jako punkt zakotwiczenia dla viewfinder (domyślnie jest to środek obszaru jako (0,0)).
  2. Dodaje PlayArea do world, co powoduje wyświetlenie wszystkich elementów podrzędnych za pomocą przekształcenia widoku CameraComponent.

Uruchamianie i testowanie gry

Aby zobaczyć zmiany, wykonaj szybkie ponowne uruchomienie (lub pełne ponowne uruchomienie).

Okno aplikacji brick_breaker z prostokątem PlayArea w kolorze piaskowym pośrodku okna.

W następnym kroku dodasz do świata piłkę i wprawisz ją w ruch.

5. Wyświetl piłkę

Poproś Antigravity o dodanie komponentu Ball

Aby umieścić na ekranie poruszającą się piłkę, musisz zdefiniować komponent Ball i dodać go do świata gry. Wyślij w Antigravity tego prompta:

Add a `Ball` circle component (`lib/src/components/ball.dart`) with a radius of 2% of the game width and a velocity vector that updates the ball's position each frame (`position += velocity * dt`). Spawn the ball at the center of the play area in `BrickBreaker.onLoad()` moving downward in a randomized direction at a consistent speed (scaled to a quarter of the game height), and enable `debugMode = true` so we can see component bounds.

Zrozumienie wygenerowanego kodu

Stałe konfiguracji pochodnej

Zdefiniowanie ballRadius = gameWidth * 0.02 w lib/src/config.dart jako stałej pochodnej pozwala modyfikować gameWidth i gameHeight najwyższego poziomu, aby sprawdzić, jak zmienia się wygląd i działanie gry.

Ruch niezależny od liczby klatek w Ball

CircleComponent, podobnie jak RectangleComponent, pochodzi z PositionComponent, więc jego position można aktualizować w każdej klatce w lib/src/components/ball.dart:

  final Vector2 velocity;

  @override
  void update(double dt) {
    super.update(dt);
    position += velocity * dt;
  }

Prędkość jest obiektem Vector2, ponieważ ma zarówno wartość, jak i kierunek. Flame wywołuje funkcję update w każdej klatce, przekazując dt (czas delta w sekundach od poprzedniej klatki). Mnożenie przez velocity * dt pozwala zachować spójną szybkość symulacji przy różnych częstotliwościach odświeżania wyświetlacza (np. 60 Hz i 120 Hz).

Normalizowanie prędkości początkowej

W pliku lib/src/brick_breaker.dart piłka zaczyna się na środku (size / 2) z losową prędkością w dół:

    world.add(
      Ball(
        radius: ballRadius,
        position: size / 2,
        velocity: Vector2(
          (rand.nextDouble() - 0.5) * width,
          height * 0.2,
        ).normalized()..scale(height / 4),
      ),
    );

Wywołanie normalized() daje wektor jednostkowy (długość 1) wskazujący ten sam losowy kierunek, a ..scale(height / 4) skaluje go, dzięki czemu piłka zawsze zaczyna z tą samą prędkością niezależnie od kąta.

Uruchamianie i testowanie gry

Uruchom ponownie grę. Gdy włączona jest opcja debugMode = true, Flame wyświetla fioletowe ramki ograniczające i współrzędne w drzewie komponentów:

Okno aplikacji brick_breaker z niebieską kulką na górze obszaru gry w kolorze piasku, z adnotacjami ze współrzędnymi debugowania.

Jeśli kilka razy uruchomisz grę ponownie, zauważysz, że piłka przelatuje przez krawędzie obszaru gry. Aby to naprawić, w następnym kroku dodasz wykrywanie kolizji.

6. Odbijanie się

Poproś Antigravity o dodanie wykrywania kolizji

Wykrywanie kolizji pozwala grze rozpoznać, kiedy 2 komponenty się stykają. Wyślij w Antigravity tego prompta:

Enable collision detection on `BrickBreaker` and add hitboxes to `PlayArea` and `Ball`. In `Ball.onCollisionStart`, bounce the ball off the top, left, and right walls of `PlayArea` by reversing the appropriate velocity axis, and remove the ball when it hits the bottom edge.

Zrozumienie wygenerowanego kodu

Obszary trafienia i HasCollisionDetection

Dodanie domieszki HasCollisionDetection do BrickBreaker śledzi pola trafień komponentów (RectangleHitbox na PlayArea i CircleHitbox na Ball) i wywołuje wywołania zwrotne kolizji przy każdym cyklu gry.

Obsługa kolizji ze ścianami w grze Ball

W pliku lib/src/components/ball.dart funkcja onCollisionStart odzwierciedla wektor prędkości piłki, gdy uderza ona w górną, lewą lub prawą ścianę, i usuwa piłkę, gdy uderza ona w dolną ścianę:

  @override
  void onCollisionStart(
    Set<Vector2> intersectionPoints,
    PositionComponent other,
  ) {
    super.onCollisionStart(intersectionPoints, other);
    if (other is PlayArea) {
      if (intersectionPoints.first.y <= 0) {
        velocity.y = -velocity.y;
      } else if (intersectionPoints.first.x <= 0) {
        velocity.x = -velocity.x;
      } else if (intersectionPoints.first.x >= game.width) {
        velocity.x = -velocity.x;
      } else if (intersectionPoints.first.y >= game.height) {
        removeFromParent();
      }
    } else {
      debugPrint('collision with $other');
    }
  }

Uruchamianie i testowanie gry

Uruchom ponownie grę. Obserwuj, jak piłka odbija się od lewej i prawej ściany PlayArea i znika, gdy dotrze do dolnej krawędzi.

Teraz, gdy piłka odbija się od ścian, daj graczowi paletkę, aby mógł ją odbijać.

7. Uderz piłkę kijem

Poproś Antigravity o dodanie komponentu Bat

Wyślij w Antigravity następującego prompta, aby utworzyć komponent Bat sterowany przez gracza i obsłużyć kolizje kija z piłką:

Add a player-controlled `Bat` component (`lib/src/components/bat.dart`) positioned near the bottom of the play area (`height * 0.95`). Render it as a rounded rectangle with a `RectangleHitbox`, and let the player move it horizontally both by dragging (`DragCallbacks`) and with the left and right arrow keys (`KeyboardEvents` on `BrickBreaker` using a short `MoveToEffect`). In `Ball`, replace immediate bottom removal with a delayed `RemoveEffect(delay: 0.35)`, and when the ball hits the `Bat`, reverse its vertical velocity and deflect its horizontal velocity based on how far from the bat's center the ball struck.

Zrozumienie wygenerowanego kodu

Renderowanie niestandardowe, przeciąganie i MoveToEffect w Bat

W przeciwieństwie do PlayArea i Ball, Bat w lib/src/components/bat.dart rozszerza bezpośrednio PositionComponent i zastępuje render, aby narysować zaokrąglony prostokąt (RRect):

  @override
  void render(Canvas canvas) {
    super.render(canvas);
    canvas.drawRRect(
      RRect.fromRectAndRadius(Offset.zero & size.toSize(), cornerRadius),
      _paint,
    );
  }

Offset.zero & size.toSize() używa operatora & na Offset i Size, aby utworzyć Rect.

W przypadku danych wejściowych Bat obsługuje 2 modalności:

  • Przeciąganie myszą i dotykiem za pomocą DragCallbacks i onDragUpdate.
  • Ruch klawiatury za pomocą moveBy(double dx), który dołącza Flame MoveToEffect, aby płynnie animować nietoperza przez 100 ms:
  void moveBy(double dx) {
    add(
      MoveToEffect(
        Vector2((position.x + dx).clamp(0, game.width), position.y),
        EffectController(duration: 0.1),
      ),
    );
  }

Opóźnione usuwanie i odbijanie piłki pod kątem w grze Ball

W lib/src/components/ball.dart wprowadziliśmy 2 ulepszenia, które znacznie poprawiają interakcję z piłką:

  1. Zastąpienie removeFromParent() wartością add(RemoveEffect(delay: 0.35)) sprawia, że piłka przekracza dolną krawędź, zanim zniknie.
  2. W przypadku kolizji z obiektem Bat wartość velocity.x jest dostosowywana na podstawie miejsca, w którym piłka uderzyła w kij, względem środka kija:
    } else if (other is Bat) {
      velocity.y = -velocity.y;
      velocity.x =
          velocity.x +
          (position.x - other.position.x) / other.size.x * game.width * 0.3;
    }

Uruchamianie i testowanie gry

Uruchom ponownie grę. Przesuwaj paletkę, przeciągając ją myszą lub palcem albo naciskając klawisze strzałek w lewo i w prawo, i odbijaj piłkę w kierunku góry ekranu.

Masz już paletkę do odbijania piłki, teraz dodaj ścianę z cegieł, którą trzeba będzie rozbić.

8. Zburz ścianę

Poproś Antigravity o dodanie klocków

Wyślij w Antigravity następującego prompta, aby utworzyć komponent Brick, rozmieścić siatkę klocków i przyspieszyć piłkę, gdy klocki się rozpadają:

Create a `Brick` rectangle component (`lib/src/components/brick.dart`) with a hitbox and add a 10-column by 5-row grid of colored bricks across the top of the play area using constants in `lib/src/config.dart`. When the ball collides with a brick, remove the brick, reflect the ball's velocity off the side of the brick it hit, and multiply the ball's velocity by a `difficultyModifier` (such as `1.03`) so the game speeds up. When the last brick is destroyed, remove the ball and bat from the world.

Zrozumienie wygenerowanego kodu

Usunięcie komponentu i sprawdzenie wygranej zostały dodane do kolejki

W lib/src/components/brick.dart Brick.onCollisionStart usuwa klocek i sprawdza, czy był to ostatni klocek w świecie:

  @override
  void onCollisionStart(
    Set<Vector2> intersectionPoints,
    PositionComponent other,
  ) {
    super.onCollisionStart(intersectionPoints, other);
    removeFromParent();

    if (game.world.children.query<Brick>().length == 1) {
      game.world.removeAll(game.world.children.query<Ball>());
      game.world.removeAll(game.world.children.query<Bat>());
    }
  }

Dlaczego sprawdzanie porównuje query().length == 1 po wywołaniu removeFromParent()? Ponieważ usuwanie komponentów we Flame jest poleceniem w kolejce, klocek jest usuwany z drzewa komponentów dopiero po zakończeniu bieżącego wywołania zwrotnego, przed następnym cyklem gry.

Krzywa trudności w Ball

Gdy Ball zderza się z Brick w lib/src/components/ball.dart, odbija się od odpowiedniej osi prędkości i mnoży wektor prędkości przez difficultyModifier (1.03), stopniowo zwiększając prędkość piłki z każdą rozbitą cegłą:

    } else if (other is Brick) {
      if (position.y < other.position.y - other.size.y / 2) {
        velocity.y = -velocity.y;
      } else if (position.y > other.position.y + other.size.y / 2) {
        velocity.y = -velocity.y;
      } else if (position.x < other.position.x) {
        velocity.x = -velocity.x;
      } else if (position.x > other.position.x) {
        velocity.x = -velocity.x;
      }
      velocity.setFrom(velocity * difficultyModifier);
    }

Uruchamianie i testowanie gry

Uruchom ponownie grę, aby zobaczyć całą ścianę z cegieł:

Gra brick_breaker z piłką, paletką i kolorowymi klockami na obszarze gry z etykietami debugowania.

Następnie dodasz nakładki powitalne, nakładki końca gry i nakładki wygranej, używając widżetów Fluttera.

9. Wygraj grę

Poproś Antigravity o dodanie nakładek PlayState i Flutter

W tym kroku wprowadzisz typ wyliczeniowy PlayState, umieścisz grę Flame w stylizowanym widżecie GameApp we Flutterze z nakładkami i skonfigurujesz uprawnienia sieciowe platformy dla google_fonts. Wyślij w Antigravity tego prompta:

Add a `PlayState` enum (`welcome`, `playing`, `gameOver`, `won`) to `BrickBreaker` that synchronizes with Flame's `overlays`, turn off `debugMode`, and move spawning the ball, bat, and bricks into a `startGame()` method triggered by tapping the screen (`TapCallbacks`) or pressing Space or Enter. Transition to `gameOver` when the ball exits the bottom and `won` when the final brick breaks. Then create a Flutter wrapper `GameApp` (`lib/src/widgets/game_app.dart`, importing `package:material_ui/material_ui.dart`) using the `'Press Start 2P'` Google Font and a gradient background that displays `GameWidget` overlays for `'TAP TO PLAY'`, `'G A M E   O V E R'`, and `'Y O U   W O N ! ! !'`. Also add the required Android and macOS network permissions for `google_fonts`.

Zrozumienie wygenerowanego kodu

Zarządzanie nakładkami za pomocą PlayState

W pliku lib/src/brick_breaker.dart metoda ustawiająca playState synchronizuje stan gry z menedżerem overlays we Flame:

  late PlayState _playState;
  PlayState get playState => _playState;
  set playState(PlayState playState) {
    _playState = playState;
    switch (playState) {
      case PlayState.welcome:
      case PlayState.gameOver:
      case PlayState.won:
        overlays.add(playState.name);
      case PlayState.playing:
        overlays.remove(PlayState.welcome.name);
        overlays.remove(PlayState.gameOver.name);
        overlays.remove(PlayState.won.name);
    }
  }

Podział startGame() z onLoad() pozwala graczowi rozpocząć lub ponownie uruchomić grę w dowolnym momencie przez kliknięcie ekranu (onTapDown) lub naciśnięcie spacji albo klawisza Enter.

Nakładki mapy w GameWidget

W pliku lib/src/widgets/game_app.dart GameWidget.controlled tworzy instancję BrickBreaker i mapuje każdą nazwę PlayState na nakładkę widżetu Flutter:

child: GameWidget.controlled(
  gameFactory: BrickBreaker.new,
  overlayBuilderMap: {
    PlayState.welcome.name: (context, game) => Center(
      child: Text(
        'TAP TO PLAY',
        style: Theme.of(context).textTheme.headlineLarge,
      ),
    ),
    // ...
  },
),

Każdy klucz w overlayBuilderMap musi odpowiadać nazwie nakładki przekazanej do overlays.add(...) i overlays.remove(...).

Uruchamianie i testowanie gry

Zatrzymaj i ponownie uruchom aplikację (ponieważ uprawnienia sieciowe platformy zostały zaktualizowane dla google_fonts). Sprawdź, czy po uruchomieniu pojawia się 'TAP TO PLAY', czy kliknięcie lub naciśnięcie spacji rozpoczyna grę i czy po utracie piłki wyświetla się 'G A M E O V E R'.

10. Zapisuj wyniki

Poproś Antigravity o dodanie karty wyników i animowanych nakładek.

W tym ostatnim kroku udostępnisz wynik gracza z Flame we Flutterze za pomocą ValueNotifier i dopracujesz nakładki za pomocą flutter_animate. Wyślij w Antigravity tego prompta:

Track the player's score in `BrickBreaker` using a `ValueNotifier<int> score` that resets in `startGame()` and increments whenever a brick is broken. Using `package:material_ui/material_ui.dart`, create a `ScoreCard` widget (`lib/src/widgets/score_card.dart`) above the `GameWidget` that listens to `score`, and an `OverlayScreen` widget (`lib/src/widgets/overlay_screen.dart`) using `flutter_animate` to slide in the overlay title and pulse the subtitle in and out.

Zrozumienie wygenerowanego kodu

Łączenie stanu Flame z Flutterem za pomocą ValueNotifier

W lib/src/brick_breaker.dart BrickBreaker udostępnia final ValueNotifier score = ValueNotifier(0);, który resetuje się w startGame() i zwiększa się za każdym razem, gdy zostanie osiągnięty Brick.

W pliku lib/src/widgets/score_card.dart ScoreCard używa ValueListenableBuilder, więc tylko tekst wyniku jest przebudowywany, gdy zmienia się score.value:

  @override
  Widget build(BuildContext context) {
    return ValueListenableBuilder<int>(
      valueListenable: score,
      builder: (context, score, child) {
        return Padding(
          padding: const EdgeInsets.fromLTRB(12, 6, 12, 18),
          child: Text(
            'Score: $score'.toUpperCase(),
            style: Theme.of(context).textTheme.titleLarge!,
          ),
        );
      },
    );
  }

Animowanie nakładek za pomocą flutter_animate

W pliku lib/src/widgets/overlay_screen.dart OverlayScreen łączy efekty flutter_animate ze standardowymi widżetami Text, aby tytuł się wysuwał, a podtytuł pulsował:

Text(
  title,
  style: Theme.of(context).textTheme.headlineLarge,
).animate().slideY(duration: 750.ms, begin: -3, end: 0),
const SizedBox(height: 16),
Text(subtitle, style: Theme.of(context).textTheme.headlineSmall)
    .animate(onPlay: (controller) => controller.repeat())
    .fadeIn(duration: 1.seconds)
    .then()
    .fadeOut(duration: 1.seconds),

Aby dowiedzieć się więcej o możliwościach animacji flutter_animate i Flutter, zapoznaj się z dokumentacją pakietu flutter_animate i ćwiczeniem z programowania Animacje we Flutter.

Uruchamianie i testowanie gry

Uruchom ponownie grę. Gdy wszystko jest już gotowe, możesz grać w grę Brick Breaker na dowolnej z 6 platform docelowych Fluttera:

Gra brick_breaker z wyświetloną nakładką powitalną, która zachęca użytkownika do kliknięcia ekranu, aby rozpocząć grę

Gra brick_breaker z nakładką końca gry nad paletką i pozostałymi klockami

11. Gratulacje

Gratulacje! Udało Ci się stworzyć kompletną grę zręcznościową 2D za pomocą Fluttera, Flame i Google Antigravity.

Co udało Ci się utworzyć

  • Świat gry 2D Flame o stałej rozdzielczości (BrickBreaker i PlayArea), który skaluje się i wyświetla w formacie letterbox na urządzeniach mobilnych, komputerach i w internecie.
  • Komponenty fizyki i kolizji (Ball, Bat i Brick) wykorzystujące HasCollisionDetection, obszary trafienia i aktualizacje prędkości niezależne od liczby klatek.
  • Multimodalne elementy sterujące odtwarzaczem i efekty płomienia łączące dotyk i przeciąganie myszą (DragCallbacks) z animacjami MoveToEffect sterowanymi klawiaturą i opóźnionym czyszczeniem RemoveEffect.
  • Integracja interfejsu Flutter za pomocą nakładek GameWidget.controlled, zarządzanie stanem ValueNotifier na potrzeby aktualizacji wyników w czasie rzeczywistym, google_fonts i flutter_animate.

Co dalej

Kontynuuj promptowanie Antigravity, aby dostosować grę do siebie. Oto kilka pomysłów, które możesz wypróbować:

  • Efekty dźwiękowe w stylu retro: poproś Antigravity o dodanie flame_audio (lub syntezowanych efektów dźwiękowych) do uderzeń paletką, odbić od ściany i niszczenia cegieł.
  • Ulepszenia i wiele piłek: ze zniszczonych klocków wypadają kapsułki z ulepszeniami, które poszerzają paletkę, spowalniają piłkę lub dzielą ją na 3.
  • Wiele poziomów i rekordy: zapisuj rekordy gracza za pomocą shared_preferences i projektuj nowe układy klocków na kolejnych poziomach.

Co dalej?

Zapoznaj się z tymi powiązanymi ćwiczeniami:

Więcej informacji