1. Introdução
O que você vai criar
O Flame é um mecanismo de jogo 2D baseado no Flutter. Neste codelab, você vai criar um jogo inspirado em um dos clássicos dos videogames dos anos 70, o Breakout de Steve Wozniak. Usando o Google Antigravity, você vai pedir ao agente para criar Components do Flame para o bastão, a bola e os tijolos, animar o movimento do bastão com Effects do Flame e integrar o Flame ao sistema de gerenciamento de estado do Flutter.
Quando terminar, seu jogo vai ficar parecido com este GIF animado, mas um pouco mais lento:

O jogo concluído atende aos seguintes requisitos:
- Funciona nas seis plataformas compatíveis com o Flutter: Android, iOS, Linux, macOS, Windows e Web.
- Mantém pelo menos 60 qps usando o loop de jogo do Flame.
- Usa pacotes do Flutter, como
google_fontseflutter_animate, para recriar a sensação dos jogos de fliperama dos anos 70 e 80.
Sua jornada de aprendizado
Este codelab mostra como criar o jogo passo a passo:
- Configurar o ambiente do Flutter: configure o Flutter e o Google Antigravity para sua plataforma de destino.
- Criar um projeto: peça para o Antigravity criar um projeto vazio do Flutter com Flame,
flutter_animate,google_fontsematerial_ui. - Criar o jogo: configure uma câmera de resolução fixa e adicione um componente
PlayAreaao mundo do jogo. - Mostrar a bola: adicione um componente
Ballem movimento, impulsionado pelo loop de jogo e pelos vetores de velocidade do Flame. - Quicar: ative a detecção de colisão e as hitboxes para que a bola quique nas paredes.
- Rebater a bola: adicione um
Batcontrolado pelo jogador que aceite arrastar e entrada de teclado comMoveToEffect. - Quebre a parede: gere uma grade de componentes
Bricke aumente a velocidade da bola conforme os tijolos quebram. - Vencer o jogo: gerencie os estados do jogo e mostre sobreposições de widgets retrô do Flutter com
GameWidget.controlled. - Manter a pontuação: sincronize a pontuação do jogador com a interface do Flutter usando
ValueNotifiere anime as sobreposições comflutter_animate.
O que você vai aprender
- Como colaborar com o Google Antigravity para criar e personalizar um jogo do Flame de forma iterativa.
- Noções básicas de como o Flame funciona, começando com
GameWidget. - Como usar um loop de jogo para movimento independente de frame rate.
- Como os
Components do Flame funcionam (semelhantes aosWidgets do Flutter). - Como detectar e responder a colisões usando hitboxes.
- Como usar
Effects para animar e removerComponents. - Como sobrepor
Widgets do Flutter em um jogo do Flame. - Como integrar o Flame ao gerenciamento de estado do Flutter.
Pré-requisitos
- Noções básicas sobre a sintaxe do Flutter e do Dart.
2. Configurar seu ambiente do Flutter
Editor
Este codelab usa o Google Antigravity como seu ambiente de desenvolvimento focado em IA. Em cada etapa, você vai pedir ao Antigravity para gerar ou evoluir os componentes do jogo, revisar os principais conceitos do Flame no código gerado e, se quiser, explorar variações de arcade inspiradas em uma época.
Escolher uma plataforma para desenvolvimento
O Flutter produz apps para várias plataformas. Seu app pode ser executado em qualquer um destes sistemas operacionais:
- iOS
- Android
- Windows
- macOS
- Linux
- web
É uma prática comum escolher um sistema operacional como plataforma de desenvolvimento. Esse é o sistema operacional em que o app é executado durante o desenvolvimento.

Por exemplo, vamos supor que você esteja usando um laptop Windows para desenvolver um app do Flutter. Se você escolher o Android como target de desenvolvimento, conectará um dispositivo Android ao laptop Windows com um cabo USB, e o app será executado nesse dispositivo Android (ou em um Android Emulator). Como alternativa, você pode escolher o Windows como o destino de desenvolvimento, que executa o app em desenvolvimento como um aplicativo do Windows em modo janela para computador no seu editor.
Faça sua escolha antes de continuar. Você pode executar seu app em outros sistemas operacionais depois. Escolher uma plataforma de desenvolvimento facilita a próxima etapa.
Instalar o Flutter
As instruções mais atualizadas sobre como instalar o SDK do Flutter estão sempre em docs.flutter.dev (link em inglês).
As instruções no site do Flutter abrangem a instalação do SDK, das ferramentas específicas da plataforma e dos plug-ins do editor. Para este codelab, instale os seguintes softwares:
- SDK do Flutter.
- O Google Antigravity com o plug-in oficial do Dart e do Flutter ativado (disponível no Marketplace de plug-ins na seção Build with Google).
- Software de compilador para a plataforma de desenvolvimento escolhida (por exemplo, Visual Studio para Windows ou Xcode para macOS ou iOS).
Na próxima etapa, você vai pedir para o Antigravity criar seu projeto do Flutter e estruturar o jogo inicial do Flame.
Solução de problemas
Se você tiver problemas de configuração, estas perguntas e respostas do Stack Overflow podem ajudar:
- Como encontrar o caminho do SDK do Flutter?
- O que fazer quando o comando do Flutter não é encontrado?
- Como corrigir o problema "Aguardando outro comando do Flutter para liberar o bloqueio de inicialização"?
- Como dizer ao Flutter onde está minha instalação do SDK do Android?
- Como lidar com o erro de Java ao executar
flutter doctor --android-licenses? - O que fazer quando a ferramenta
sdkmanagerdo Android não for encontrada? - Como lidar com o erro "o componente
cmdline-toolsestá ausente"? - Como executar o CocoaPods no Apple Silicon (M1)?
3. Criar um projeto
Peça para o Antigravity criar o projeto
- Inicie o Google Antigravity e abra um diretório vazio onde você quer criar o jogo. Escolha um caminho que não exija privilégios elevados nem contenha espaços, como uma pasta no diretório inicial ou
C:\src\. - No painel de conversa do agente do Antigravity, envie o seguinte comando para criar o projeto do Flutter, adicionar as dependências e conectar um jogo básico do 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`.
Noções básicas sobre o código gerado
O Antigravity executa flutter create --empty para estruturar o projeto, adiciona flame, flutter_animate, google_fonts e material_ui a pubspec.yaml e atualiza lib/main.dart para hospedar uma instância de FlameGame dentro do GameWidget do Flutter:
void main() {
final game = FlameGame();
runApp(GameWidget(game: game));
}
Executar e testar o jogo
Execute o app no destino de desenvolvimento escolhido para verificar se tudo está funcionando. Ele mostra uma nova janela com um plano de fundo preto em branco. O videogame mais simples do mundo agora está renderizando a 60 QPS!

4. Criar o jogo
Avalie o jogo
Um jogo em duas dimensões (2D) precisa de uma área de jogo. Nesta etapa, você vai criar uma área de jogo com dimensões específicas e usar essas dimensões para dimensionar o restante dos componentes do jogo.
Há várias maneiras de organizar as coordenadas em uma área de jogo. Por convenção, você mede a direção do centro da tela com a origem (0,0) no centro, em que os valores positivos movem os itens para a direita ao longo do eixo x e para cima ao longo do eixo y. Esse padrão é comum em mecanismos de jogos 3D modernos.
Quando o jogo Breakout original foi criado, a convenção era colocar a origem no canto superior esquerdo. A direção x positiva apontava para a direita, e a direção y positiva apontava para baixo. Para manter a fidelidade à época, este jogo define a origem no canto superior esquerdo.
Peça ao Antigravity para criar o jogo e a PlayArea
Envie o seguinte comando no Antigravity para configurar o mundo do jogo e a área de jogo com resolução fixa:
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`.
Noções básicas sobre o código gerado
PlayArea e Components de chama
Onde o Flutter tem Widgets, o Flame tem Components. Enquanto os apps do Flutter consistem em árvores de widgets, os jogos do Flame mantêm árvores de componentes.
A árvore de widgets do Flutter é uma descrição imutável usada para atualizar a camada RenderObject persistente e mutável. Os componentes do Flame são persistentes e mutáveis, projetados para serem usados diretamente como parte de um sistema de simulação no 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);
}
}
Para controlar a confusão de importação ao adicionar mais componentes, o lib/src/components/components.dart usa a diretiva export para reexportar cada componente de um único arquivo de barril.
Câmera de resolução fixa e o world
Em lib/src/brick_breaker.dart, BrickBreaker configura o jogo para usar uma resolução fixa de 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());
}
}
O jogo é redimensionado para preencher a janela que o contém e adiciona letterboxing conforme necessário.
Em onLoad, o código realiza duas ações principais:
- Configura o canto superior esquerdo como a âncora para o
viewfinder(que, por padrão, é o centro da área como(0,0)). - Adiciona
PlayAreaaworld, que projeta todos os filhos pela transformação de visualização deCameraComponent.
Executar e testar o jogo
Faça uma reinicialização rápida (ou completa) para conferir as mudanças.

Na próxima etapa, você vai adicionar uma bola ao mundo e fazê-la se mover.
5. Mostrar a bola
Peça para o Antigravity adicionar o componente Ball
Para colocar uma bola em movimento na tela, é preciso definir um componente Ball e adicioná-lo ao mundo do jogo. Envie o seguinte comando no Antigravity:
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.
Noções básicas sobre o código gerado
Constantes de configuração derivadas
Definir ballRadius = gameWidth * 0.02 em lib/src/config.dart como uma constante derivada permite modificar os valores de nível superior de gameWidth e gameHeight para conferir como a aparência do jogo muda.
Movimento independente da taxa de frames em Ball
CircleComponent, como RectangleComponent, deriva de PositionComponent, então o position pode ser atualizado em cada frame em lib/src/components/ball.dart:
final Vector2 velocity;
@override
void update(double dt) {
super.update(dt);
position += velocity * dt;
}
A velocidade é um objeto Vector2 porque tem rapidez e direção. O Flame chama update em cada frame, transmitindo dt (o tempo delta em segundos desde o frame anterior). Multiplicar velocity * dt mantém a velocidade da simulação consistente em diferentes taxas de atualização de tela (como 60 Hz e 120 Hz).
Como normalizar a velocidade inicial
Em lib/src/brick_breaker.dart, a bola começa no centro (size / 2) com uma velocidade descendente aleatória:
world.add(
Ball(
radius: ballRadius,
position: size / 2,
velocity: Vector2(
(rand.nextDouble() - 0.5) * width,
height * 0.2,
).normalized()..scale(height / 4),
),
);
Chamar normalized() produz um vetor unitário (comprimento 1) apontando na mesma direção aleatória, e ..scale(height / 4) o dimensiona para que a bola sempre comece na mesma velocidade, independentemente do ângulo.
Executar e testar o jogo
Faça uma recarga dinâmica do jogo. Com o debugMode = true ativado, o Flame mostra caixas delimitadoras roxas e coordenadas na árvore de componentes:

Se você reiniciar o jogo algumas vezes, vai notar que a bola atravessa as bordas da área de jogo. Para corrigir isso, você vai adicionar a detecção de colisão na próxima etapa.
6. Pular
Peça para o Antigravity adicionar a detecção de colisão
A detecção de colisão permite que o jogo reconheça quando dois componentes entram em contato. Envie o seguinte comando no Antigravity:
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.
Noções básicas sobre o código gerado
Hitboxes e HasCollisionDetection
Adicionar o mixin HasCollisionDetection a BrickBreaker rastreia as hitboxes dos componentes (RectangleHitbox em PlayArea e CircleHitbox em Ball) e aciona callbacks de colisão em cada marcação do jogo.
Como lidar com colisões de parede em Ball
Em lib/src/components/ball.dart, onCollisionStart reflete o vetor de velocidade da bola quando ela atinge a parede de cima, da esquerda ou da direita e remove a bola quando ela atinge a parte de baixo:
@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');
}
}
Executar e testar o jogo
Faça uma recarga dinâmica do jogo. Observe a bola quicar nas paredes esquerda e direita do PlayArea e desaparecer quando chegar à borda inferior.
Agora que a bola quica nas paredes, dê ao jogador uma raquete para rebater a bola de volta para cima.
7. Acerte a bola com o taco
Peça para o Antigravity adicionar o componente Bat
Envie o seguinte comando no Antigravity para criar o componente Bat controlado pelo jogador e lidar com as colisões da bola com o taco:
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.
Noções básicas sobre o código gerado
Renderização personalizada, arrastar e MoveToEffect em Bat
Ao contrário de PlayArea e Ball, Bat em lib/src/components/bat.dart estende PositionComponent diretamente e substitui render para desenhar um retângulo arredondado (RRect):
@override
void render(Canvas canvas) {
super.render(canvas);
canvas.drawRRect(
RRect.fromRectAndRadius(Offset.zero & size.toSize(), cornerRadius),
_paint,
);
}
Offset.zero & size.toSize() usa o operador & em Offset e Size para criar um Rect.
Para entrada, o Bat aceita duas modalidades:
- Arrastar com o mouse e toque usando
DragCallbackseonDragUpdate. - Movimento do teclado usando
moveBy(double dx), que anexa umMoveToEffectdo Flame para animar o morcego de forma suave em 100 ms:
void moveBy(double dx) {
add(
MoveToEffect(
Vector2((position.x + dx).clamp(0, game.width), position.y),
EffectController(duration: 0.1),
),
);
}
Remoção atrasada e quique angular do bastão em Ball
Em lib/src/components/ball.dart, duas melhorias tornam a interação com a bola muito melhor:
- Substituir
removeFromParent()poradd(RemoveEffect(delay: 0.35))permite que a bola passe pela borda inferior antes de desaparecer. - Ao colidir com
Bat,velocity.xé ajustado com base no local em que a bola atingiu o bastão em relação ao centro dele:
} 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;
}
Executar e testar o jogo
Faça uma recarga dinâmica do jogo. Mova o bastão arrastando-o com o mouse ou o dedo, ou pressionando as teclas de seta para a esquerda e para a direita, e faça a bola quicar de volta para o topo da tela.
Agora que você tem um bastão para rebater a bola, adicione uma parede de tijolos para quebrar!
8. Derrube a parede
Peça para o Antigravity adicionar os blocos
Envie o comando a seguir no Antigravity para criar o componente Brick, organizar a grade de tijolos e acelerar a bola conforme os tijolos são quebrados:
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.
Noções básicas sobre o código gerado
Remoção de componentes em fila e verificação de vitória
Em lib/src/components/brick.dart, Brick.onCollisionStart remove o bloco e verifica se ele era o último do mundo:
@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>());
}
}
Por que a verificação compara query depois de chamar removeFromParent()? Como a remoção de componentes no Flame é um comando em fila, o tijolo só é removido da árvore de componentes depois que o callback atual é concluído, antes do próximo tick do jogo.
Curva de dificuldade em Ball
Quando Ball colide com um Brick em lib/src/components/ball.dart, ele reflete o eixo de velocidade apropriado e multiplica o vetor de velocidade por difficultyModifier (1.03), aumentando gradualmente a velocidade da bola a cada tijolo quebrado:
} 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);
}
Executar e testar o jogo
Reinicie o jogo para ver a parede de tijolos completa em ação:

Em seguida, você vai adicionar sobreposições de boas-vindas, fim de jogo e vitória usando widgets do Flutter.
9. Vença o jogo
Peça para o Antigravity adicionar sobreposições do PlayState e do Flutter
Nesta etapa, você vai introduzir um tipo enumerado PlayState, incorporar o jogo do Flame em um widget GameApp estilizado do Flutter com sobreposições e configurar as permissões de rede da plataforma para o google_fonts. Envie o seguinte comando no Antigravity:
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`.
Noções básicas sobre o código gerado
Como gerenciar sobreposições com PlayState
Em lib/src/brick_breaker.dart, o setter playState sincroniza o estado do jogo com o gerenciador overlays do 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);
}
}
Separar startGame() de onLoad() permite que o jogador inicie ou reinicie um jogo a qualquer momento tocando na tela (onTapDown) ou pressionando Espaço ou Enter.
Mapeando coberturas regionais em GameWidget
Em lib/src/widgets/game_app.dart, GameWidget.controlled cria a instância BrickBreaker e mapeia cada nome de PlayState para uma sobreposição de widget do 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,
),
),
// ...
},
),
Cada chave em overlayBuilderMap precisa corresponder ao nome da sobreposição transmitido para overlays.add(...) e overlays.remove(...).
Executar e testar o jogo
Interrompa e execute o app novamente (já que as permissões de rede da plataforma foram atualizadas para google_fonts). Verifique se 'TAP TO PLAY' aparece na inicialização, se tocar ou pressionar a barra de espaço inicia o jogo e se perder a bola mostra 'G A M E O V E R'.
10. Registrar progresso
Peça para o Antigravity adicionar o placar e as sobreposições animadas
Nesta etapa final, você vai expor a pontuação do jogador do Flame para o Flutter usando um ValueNotifier e vai polir as sobreposições com o flutter_animate. Envie o seguinte comando no Antigravity:
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.
Noções básicas sobre o código gerado
Como conectar o estado do Flame ao Flutter com ValueNotifier
Em lib/src/brick_breaker.dart, BrickBreaker expõe final ValueNotifier, que é redefinido em startGame() e incrementado sempre que um Brick é atingido.
Em lib/src/widgets/score_card.dart, ScoreCard usa ValueListenableBuilder para que apenas o texto da pontuação seja recriado quando score.value mudar:
@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!,
),
);
},
);
}
Como animar sobreposições com flutter_animate
Em lib/src/widgets/overlay_screen.dart, OverlayScreen encadeia efeitos de flutter_animate em widgets padrão de Text para deslizar o título e pulsar o subtítulo:
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),
Para saber mais sobre o poder das animações do flutter_animate e do Flutter, confira a documentação do pacote flutter_animate e o codelab Animações no Flutter.
Executar e testar o jogo
Faça uma recarga dinâmica do jogo. Com tudo pronto, agora você pode jogar o Brick Breaker em qualquer uma das seis plataformas de destino do Flutter:
|
|
11. Parabéns
Parabéns! Você criou um jogo de arcade 2D completo com o Flutter, o Flame e o Google Antigravity.
O que você criou
- Um mundo de jogo 2D do Flame com resolução fixa (
BrickBreakerePlayArea) que se adapta e se ajusta perfeitamente a dispositivos móveis, computadores e Web. - Componentes de física e colisão (
Ball,BateBrick) usandoHasCollisionDetection, hitboxes e atualizações de velocidade independentes da taxa de frames. - Controles do player multimodais e efeitos de chama que combinam toque e arrasto do mouse (
DragCallbacks) com animaçõesMoveToEffectacionadas pelo teclado e limpeza atrasada deRemoveEffect. - Integração da interface do Flutter usando sobreposições do
GameWidget.controlled, gerenciamento de estado doValueNotifierpara atualizações de pontuação em tempo real,google_fontseflutter_animate.
O que fazer depois disso
Continue incentivando a Antigravity a personalizar o jogo! Confira algumas ideias:
- Efeitos sonoros de fliperama retrô: peça para o Antigravity adicionar
flame_audio(ou efeitos de áudio sintetizados) para batidas de raquete, quiques na parede e destruição de blocos. - Power-ups e multibola: gere cápsulas de power-up que caem dos tijolos quebrados e aumentam o bastão, desaceleram a bola ou a dividem em três.
- Vários níveis e maiores pontuações: persista a maior pontuação do jogador usando
shared_preferencese crie novos layouts de tijolos para os níveis seguintes.
A seguir
Confira alguns destes codelabs relacionados:
- Criar um quebra-cabeça de palavras com o Flutter
- Animações no Flutter
- Criar o layout de um app responsivo animado com o Material Design 3
- Adicionar compras no app ao seu app do Flutter

