Introdução ao Flame com o Flutter

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:

Uma gravação de tela do jogo de quebrar tijolos concluído sendo jogado, acelerada significativamente.

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_fonts e flutter_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:

  1. Configurar o ambiente do Flutter: configure o Flutter e o Google Antigravity para sua plataforma de destino.
  2. Criar um projeto: peça para o Antigravity criar um projeto vazio do Flutter com Flame, flutter_animate, google_fonts e material_ui.
  3. Criar o jogo: configure uma câmera de resolução fixa e adicione um componente PlayArea ao mundo do jogo.
  4. Mostrar a bola: adicione um componente Ball em movimento, impulsionado pelo loop de jogo e pelos vetores de velocidade do Flame.
  5. Quicar: ative a detecção de colisão e as hitboxes para que a bola quique nas paredes.
  6. Rebater a bola: adicione um Bat controlado pelo jogador que aceite arrastar e entrada de teclado com MoveToEffect.
  7. Quebre a parede: gere uma grade de componentes Brick e aumente a velocidade da bola conforme os tijolos quebram.
  8. Vencer o jogo: gerencie os estados do jogo e mostre sobreposições de widgets retrô do Flutter com GameWidget.controlled.
  9. Manter a pontuação: sincronize a pontuação do jogador com a interface do Flutter usando ValueNotifier e anime as sobreposições com flutter_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 aos Widgets do Flutter).
  • Como detectar e responder a colisões usando hitboxes.
  • Como usar Effects para animar e remover Components.
  • 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.

Um laptop identificado como "dispositivo de desenvolvimento" conectado por um cabo a um smartphone identificado como "dispositivo de destino".

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:

  1. SDK do Flutter.
  2. 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).
  3. 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:

3. Criar um projeto

Peça para o Antigravity criar o projeto

  1. 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\.
  2. 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!

A janela do aplicativo brick_breaker com um plano de fundo completamente preto.

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:

  1. Configura o canto superior esquerdo como a âncora para o viewfinder (que, por padrão, é o centro da área como (0,0)).
  2. Adiciona PlayArea a world, que projeta todos os filhos pela transformação de visualização de CameraComponent.

Executar e testar o jogo

Faça uma reinicialização rápida (ou completa) para conferir as mudanças.

A janela do aplicativo brick_breaker com um retângulo PlayArea de cor areia centralizado na janela.

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:

A janela do aplicativo brick_breaker com uma bola azul sobre a área de jogo cor de areia, anotada com coordenadas de depuração.

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 DragCallbacks e onDragUpdate.
  • Movimento do teclado usando moveBy(double dx), que anexa um MoveToEffect do 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:

  1. Substituir removeFromParent() por add(RemoveEffect(delay: 0.35)) permite que a bola passe pela borda inferior antes de desaparecer.
  2. 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().length == 1 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:

O jogo brick_breaker com a bola, o bastão e os tijolos coloridos na área de jogo com rótulos de depuraçã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 score = ValueNotifier(0);, 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:

O jogo brick_breaker mostrando a sobreposição de boas-vindas que convida o usuário a tocar na tela para jogar

O jogo brick_breaker mostrando a sobreposição de fim de jogo em cima do bastão e dos tijolos restantes

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 (BrickBreaker e PlayArea) que se adapta e se ajusta perfeitamente a dispositivos móveis, computadores e Web.
  • Componentes de física e colisão (Ball, Bat e Brick) usando HasCollisionDetection, 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ções MoveToEffect acionadas pelo teclado e limpeza atrasada de RemoveEffect.
  • Integração da interface do Flutter usando sobreposições do GameWidget.controlled, gerenciamento de estado do ValueNotifier para atualizações de pontuação em tempo real, google_fonts e flutter_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_preferences e crie novos layouts de tijolos para os níveis seguintes.

A seguir

Confira alguns destes codelabs relacionados:

Leitura adicional