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:

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_fontsiflutter_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:
- Konfigurowanie środowiska Flutter – skonfiguruj Flutter i Google Antigravity na platformie docelowej.
- Utwórz projekt – poproś Antigravity o utworzenie pustego projektu Flutter z Flame,
flutter_animate,google_fontsimaterial_ui. - Tworzenie gry – skonfiguruj kamerę o stałej rozdzielczości i dodaj komponent
PlayAreado świata gry. - Wyświetlanie piłki – dodaj ruchomy komponent
Ballsterowany przez pętlę gry i wektory prędkości Flame. - Odbijanie się – włącz wykrywanie kolizji i pola trafień, aby piłka odbijała się od ścian.
- Odbijanie piłki – dodaj sterowaną przez gracza
Bat, która obsługuje przeciąganie i wprowadzanie danych za pomocą klawiatury, używającMoveToEffect. - Zburz mur – wygeneruj siatkę komponentów
Bricki zwiększaj prędkość piłki, gdy klocki się rozpadają. - Wygraj grę – zarządzaj stanami gry i wyświetlaj nakładki widżetów retro we Flutterze za pomocą
GameWidget.controlled. - Zapisywanie wyniku – zsynchronizuj wynik gracza z interfejsem Fluttera za pomocą
ValueNotifieri 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ą
Componentwe Flame (podobne doWidgetwe Flutterze). - Jak wykrywać kolizje i reagować na nie za pomocą hitboxów.
- Jak używać
Effectdo animowania i usuwaniaComponent. - Jak nakładać
WidgetFluttera 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.

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:
- Flutter SDK
- Google Antigravity z włączoną oficjalną wtyczką Dart i Flutter (dostępną w sekcji Build with Google na rynku wtyczek).
- 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:
- Jak znaleźć ścieżkę pakietu SDK Flutter?
- Co zrobić, gdy nie można znaleźć polecenia Flutter?
- Jak rozwiązać problem „Waiting for another flutter command to release the startup lock” (Oczekiwanie na zwolnienie blokady uruchamiania przez inne polecenie flutter)?
- Jak poinformować Fluttera, gdzie jest zainstalowany pakiet Android SDK?
- Jak rozwiązać błąd Javy podczas uruchamiania
flutter doctor --android-licenses? - Jak rozwiązać problem z nieznalezieniem narzędzia Android
sdkmanager? - Jak rozwiązać problem z błędem „Brak komponentu
cmdline-tools”? - Jak uruchomić CocoaPods na Apple Silicon (M1)?
3. Utwórz projekt
Poproś Antigravity o utworzenie projektu
- 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\). - 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.

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:
- Konfiguruje lewy górny róg jako punkt zakotwiczenia dla
viewfinder(domyślnie jest to środek obszaru jako(0,0)). - Dodaje
PlayAreadoworld, co powoduje wyświetlenie wszystkich elementów podrzędnych za pomocą przekształcenia widokuCameraComponent.
Uruchamianie i testowanie gry
Aby zobaczyć zmiany, wykonaj szybkie ponowne uruchomienie (lub pełne ponowne uruchomienie).

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:

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ą
DragCallbacksionDragUpdate. - Ruch klawiatury za pomocą
moveBy(double dx), który dołącza FlameMoveToEffect, 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ą:
- Zastąpienie
removeFromParent()wartościąadd(RemoveEffect(delay: 0.35))sprawia, że piłka przekracza dolną krawędź, zanim zniknie. - W przypadku kolizji z obiektem
Batwartośćvelocity.xjest 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 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ł:

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, 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:
|
|
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 (
BrickBreakeriPlayArea), który skaluje się i wyświetla w formacie letterbox na urządzeniach mobilnych, komputerach i w internecie. - Komponenty fizyki i kolizji (
Ball,BatiBrick) wykorzystująceHasCollisionDetection, 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 animacjamiMoveToEffectsterowanymi klawiaturą i opóźnionym czyszczeniemRemoveEffect. - Integracja interfejsu Flutter za pomocą nakładek
GameWidget.controlled, zarządzanie stanemValueNotifierna potrzeby aktualizacji wyników w czasie rzeczywistym,google_fontsiflutter_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_preferencesi projektuj nowe układy klocków na kolejnych poziomach.
Co dalej?
Zapoznaj się z tymi powiązanymi ćwiczeniami:
- Tworzenie łamigłówki słownej we Flutterze
- Animacje we Flutterze
- Tworzenie animowanego układu elastycznej aplikacji za pomocą Material 3
- Dodawanie zakupów w aplikacji do aplikacji we Flutterze

