1. Introducción
Qué compilarás
Flame es un motor de juego 2D basado en Flutter. En este codelab, crearás un juego inspirado en uno de los clásicos de los videojuegos de los años 70, Breakout de Steve Wozniak. Con Google Antigravity, le darás instrucciones al agente paso a paso para que cree Components de Flame para la paleta, la pelota y los ladrillos, anime el movimiento de la paleta con Effects de Flame y, luego, integre Flame con el sistema de administración de estados de Flutter.
Cuando termines, tu juego debería verse como este GIF animado, aunque un poco más lento:

Tu juego completado cumple con los siguientes requisitos:
- Funciona en las seis plataformas que admite Flutter: Android, iOS, Linux, macOS, Windows y la Web.
- Mantiene al menos 60 FPS con el bucle de juego de Flame.
- Usa paquetes de Flutter, como
google_fontsyflutter_animate, para recrear la sensación de los juegos de arcade de los años 70 y 80.
Tu proceso de aprendizaje
En este codelab, se explica cómo compilar el juego paso a paso:
- Configura tu entorno de Flutter: Configura Flutter y Google Antigravity para tu plataforma de destino.
- Crea un proyecto: Pídele a Antigravity que cree un proyecto de Flutter vacío con Flame,
flutter_animate,google_fontsymaterial_ui. - Crea el juego: Configura una cámara de resolución fija y agrega un componente
PlayAreaal mundo del juego. - Mostrar la pelota: Agrega un componente
Ballen movimiento controlado por el bucle de juego y los vectores de velocidad de Flame. - Rebotar: Habilita la detección de colisiones y los cuadros de colisión para que la pelota rebote en las paredes.
- Batea la pelota: Agrega un
Batcontrolado por el jugador que admita la entrada de arrastre y teclado conMoveToEffect. - Derriba el muro: Genera una cuadrícula de componentes
Bricky escala la velocidad de la pelota a medida que se rompen los ladrillos. - Gana el juego: Administra los estados del juego y muestra superposiciones de widgets de Flutter retro con
GameWidget.controlled. - Lleva la puntuación: Sincroniza la puntuación del jugador con la IU de Flutter usando
ValueNotifiery anima las superposiciones conflutter_animate.
Qué aprenderás
- Cómo colaborar con Google Antigravity para compilar y personalizar un juego de Flame de forma iterativa
- Cómo funcionan los conceptos básicos de Flame, comenzando con
GameWidget - Cómo usar un bucle de juego para el movimiento independiente de la velocidad de fotogramas
- Cómo funcionan los
Componentde Flame (similares a losWidgetde Flutter) - Cómo detectar colisiones y responder a ellas con hitboxes
- Cómo usar
Effectpara animar y quitarComponent - Cómo superponer
Widgetde Flutter sobre un juego de Flame - Cómo integrar Flame con la administración de estados de Flutter
Requisitos previos
- Conocimientos básicos de Flutter y la sintaxis de Dart
2. Configura tu entorno de Flutter
Editor
En este codelab, se usa Google Antigravity como tu entorno de desarrollo centrado en la IA. En cada paso, le darás instrucciones a Antigravity para que genere o evolucione los componentes de tu juego, revisarás los conceptos clave de Flame en el código generado y, de manera opcional, explorarás variaciones de arcade inspiradas en la época.
Elige un segmento de desarrollo
Flutter produce apps para múltiples plataformas. Tu app puede ejecutarse en cualquiera de los siguientes sistemas operativos:
- iOS
- Android
- Windows
- macOS
- Linux
- web
Es una práctica común elegir un sistema operativo como segmento de desarrollo. Este es el sistema operativo que tu app ejecutará durante el desarrollo.

Por ejemplo, supongamos que usas una laptop con Windows para desarrollar tu app de Flutter. Si eliges Android como tu objetivo de desarrollo, deberás conectar un dispositivo Android a tu laptop mediante un cable USB, y tu app en desarrollo se ejecutará en el dispositivo Android conectado (o en un Android Emulator). Como alternativa, puedes elegir Windows como el destino de desarrollo, lo que ejecuta tu app en desarrollo como una app de Windows para computadoras junto con tu editor.
Elige una opción antes de continuar. Recuerda que podrás ejecutar tu app en otros sistemas operativos más adelante. Elegir un segmento de desarrollo simplifica los próximos pasos.
Instala Flutter
Podrás encontrar las instrucciones más actualizadas para instalar el SDK de Flutter en docs.flutter.dev.
Las instrucciones del sitio web de Flutter abarcan la instalación del SDK, las herramientas específicas de la plataforma y los complementos del editor. Para este codelab, instala el siguiente software:
- El SDK de Flutter
- Google Antigravity con el complemento oficial de Dart y Flutter habilitado (disponible en el Marketplace de complementos en la sección Build with Google)
- Software de compilador para el destino de desarrollo que elijas (por ejemplo, Visual Studio para segmentar a Windows o Xcode para segmentar a macOS o iOS)
En el siguiente paso, le darás instrucciones a Antigravity para que cree tu proyecto de Flutter y genere la estructura inicial del juego de Flame.
Solución de problemas
Si tienes problemas con la configuración, estas preguntas y respuestas de Stack Overflow pueden ayudarte:
- ¿Cómo encuentro la ruta de acceso al SDK de Flutter?
- ¿Qué debo hacer si no encuentro el comando de Flutter?
- ¿Cómo soluciono el problema que indica "Waiting for another flutter command to release the startup lock"?
- ¿Cómo le indico a Flutter la ubicación de mi instalación del SDK de Android?
- ¿Cómo corrijo el error de Java cuando ejecuto
flutter doctor --android-licenses? - ¿Cómo corrijo el error que indica que no se encontró la herramienta
sdkmanagerde Android? - ¿Cómo corrijo el error que indica "
cmdline-toolscomponent is missing"? - ¿Cómo ejecuto CocoaPods en Apple Silicon (M1)?
3. Crea un proyecto
Indícale a Antigravity que cree el proyecto
- Inicia Google Antigravity y abre un directorio vacío en el que quieras compilar tu juego (elige una ruta de acceso que no requiera privilegios elevados ni contenga espacios, como una carpeta en tu directorio principal o
C:\src\). - En el panel de chat del agente de Antigravity, envía la siguiente instrucción para crear el proyecto de Flutter, agregar las dependencias y conectar un juego de Flame mínimo:
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`.
Comprende el código generado
Antigravity ejecuta flutter create --empty para estructurar el proyecto, agrega flame, flutter_animate, google_fonts y material_ui a pubspec.yaml, y actualiza lib/main.dart para alojar una instancia de FlameGame dentro de GameWidget de Flutter:
void main() {
final game = FlameGame();
runApp(GameWidget(game: game));
}
Ejecuta y prueba el juego
Ejecuta la app en el destino de desarrollo que elegiste para verificar que todo funcione. Muestra una ventana nueva con un fondo negro vacío. El videojuego más simple del mundo ahora se renderiza a 60 fps.

4. Crea el juego
Evalúa el juego
Un juego que se desarrolla en dos dimensiones (2D) necesita un área de juego. En este paso, construirás un área de juego con dimensiones específicas y las usarás para ajustar el tamaño del resto de los componentes del juego.
Existen varias formas de diseñar las coordenadas en un área de juego. Según una convención, la dirección se mide desde el centro de la pantalla con el origen (0,0) en el centro, donde los valores positivos mueven los elementos hacia la derecha a lo largo del eje X y hacia arriba a lo largo del eje Y. Este estándar es común en los motores de juegos en 3D modernos.
Cuando se creó el juego Breakout original, la convención era colocar el origen en la esquina superior izquierda. La dirección positiva de x apuntaba hacia la derecha, y la dirección positiva de y apuntaba hacia abajo. Para mantener la fidelidad a la época, este juego establece el origen en la esquina superior izquierda.
Envía una instrucción a Antigravity para crear el juego y el área de juego
Envía la siguiente instrucción en Antigravity para configurar el mundo del juego y el área de juego con resolución fija:
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`.
Comprende el código generado
PlayArea y Flame Components
Donde Flutter tiene Widget, Flame tiene Component. Mientras que las apps de Flutter constan de árboles de widgets, los juegos de Flame mantienen árboles de componentes.
El árbol de widgets de Flutter es una descripción inmutable que se usa para actualizar la capa RenderObject persistente y mutable. Los componentes de Flame son persistentes y mutables, y están diseñados para usarse directamente como parte de un sistema de simulación en 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 el desorden de las importaciones a medida que agregas más componentes, lib/src/components/components.dart usa la directiva export para volver a exportar cada componente desde un solo archivo de barril.
Cámara de resolución fija y world
En lib/src/brick_breaker.dart, BrickBreaker configura el juego para que use una resolución fija 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());
}
}
El juego cambia de tamaño para llenar la ventana que lo contiene y agrega formato letterbox según sea necesario.
En onLoad, el código realiza dos acciones clave:
- Configura la esquina superior izquierda como el ancla para el
viewfinder(que, de forma predeterminada, es el centro del área como(0,0)). - Agrega
PlayAreaaworld, que proyecta todos sus elementos secundarios a través de la transformación de vista deCameraComponent.
Ejecuta y prueba el juego
Realiza un reinicio en caliente (o un reinicio completo) para ver los cambios.

En el siguiente paso, agregarás una pelota al mundo y harás que se mueva.
5. Muestra la pelota
Pídele a Antigravity que agregue el componente Ball
Para colocar una pelota en movimiento en la pantalla, se debe definir un componente Ball y agregarlo al mundo del juego. Envía la siguiente instrucción en 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.
Comprende el código generado
Constantes de configuración derivadas
Definir ballRadius = gameWidth * 0.02 en lib/src/config.dart como una constante derivada te permite modificar los valores de nivel superior de gameWidth y gameHeight para explorar cómo cambia el aspecto del juego como resultado.
Movimiento independiente de la velocidad de fotogramas en Ball
CircleComponent, como RectangleComponent, deriva de PositionComponent, por lo que su position se puede actualizar en cada fotograma de lib/src/components/ball.dart:
final Vector2 velocity;
@override
void update(double dt) {
super.update(dt);
position += velocity * dt;
}
La velocidad es un objeto Vector2 porque tiene rapidez y dirección. Flame llama a update en cada fotograma y pasa dt (el tiempo delta en segundos desde el fotograma anterior). Multiplicar por velocity * dt mantiene la velocidad de simulación constante en diferentes frecuencias de actualización de la pantalla (como 60 Hz en comparación con 120 Hz).
Normaliza la velocidad inicial
En lib/src/brick_breaker.dart, la pelota comienza en el centro (size / 2) con una velocidad descendente aleatoria:
world.add(
Ball(
radius: ballRadius,
position: size / 2,
velocity: Vector2(
(rand.nextDouble() - 0.5) * width,
height * 0.2,
).normalized()..scale(height / 4),
),
);
Llamar a normalized() produce un vector unitario (longitud 1) que apunta en la misma dirección aleatoria, y ..scale(height / 4) lo escala para que la pelota siempre comience a la misma velocidad, independientemente del ángulo.
Ejecuta y prueba el juego
Reinicia el juego en caliente. Con debugMode = true habilitado, Flame muestra cuadros delimitadores y coordenadas de color púrpura en el árbol de componentes:

Si reinicias el juego varias veces, notarás que la pelota vuela por los bordes del área de juego. Para solucionar este problema, agregarás la detección de colisiones en el siguiente paso.
6. Bounce around
Escribe instrucciones para que Antigravity agregue la detección de colisiones
La detección de colisiones permite que tu juego reconozca cuando dos componentes entran en contacto. Envía la siguiente instrucción en 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.
Comprende el código generado
Cajas de colisión y HasCollisionDetection
Agregar el mixin HasCollisionDetection a BrickBreaker hace un seguimiento de las cajas de colisiones de los componentes (RectangleHitbox en PlayArea y CircleHitbox en Ball) y activa devoluciones de llamadas de colisión en cada marca del juego.
Cómo controlar las colisiones con paredes en Ball
En lib/src/components/ball.dart, onCollisionStart refleja el vector de velocidad de la pelota cuando golpea la pared superior, izquierda o derecha, y quita la pelota cuando golpea la parte inferior:
@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');
}
}
Ejecuta y prueba el juego
Reinicia el juego en caliente. Observa cómo la pelota rebota en las paredes izquierda y derecha del PlayArea y desaparece cuando llega al borde inferior.
Ahora que la pelota rebota en las paredes, dale al jugador una paleta para que la devuelva hacia arriba.
7. Batea la pelota
Indica a Antigravity que agregue el componente Bat
Envía la siguiente instrucción en Antigravity para crear el componente Bat controlado por el jugador y controlar las colisiones entre el bate y la pelota:
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.
Comprende el código generado
Renderización personalizada, arrastre y MoveToEffect en Bat
A diferencia de PlayArea y Ball, Bat en lib/src/components/bat.dart extiende PositionComponent directamente y anula render para dibujar un rectángulo redondeado (RRect):
@override
void render(Canvas canvas) {
super.render(canvas);
canvas.drawRRect(
RRect.fromRectAndRadius(Offset.zero & size.toSize(), cornerRadius),
_paint,
);
}
Offset.zero & size.toSize() usa el operador & en Offset y Size para construir un Rect.
Para la entrada, Bat admite dos modalidades:
- Arrastrar con el mouse y con la función táctil con
DragCallbacksyonDragUpdate. - Movimiento del teclado con
moveBy(double dx), que adjunta unMoveToEffectde Flame para animar suavemente el murciélago durante 100 ms:
void moveBy(double dx) {
add(
MoveToEffect(
Vector2((position.x + dx).clamp(0, game.width), position.y),
EffectController(duration: 0.1),
),
);
}
Se retrasó la eliminación y el rebote del bate en ángulo en Ball
En lib/src/components/ball.dart, dos mejoras hacen que la interacción con la pelota se sienta mucho mejor:
- Reemplazar
removeFromParent()poradd(RemoveEffect(delay: 0.35))permite que la pelota pase el borde inferior antes de desaparecer. - Cuando colisiona con
Bat,velocity.xse ajusta según el lugar donde la pelota golpeó el bate en relación con el centro del bate:
} 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;
}
Ejecuta y prueba el juego
Reinicia el juego en caliente. Mueve la paleta arrastrándola con el mouse o el dedo, o presionando las teclas de flecha hacia la izquierda y hacia la derecha, y haz rebotar la pelota hacia la parte superior de la pantalla.
Ahora que tienes una paleta para golpear la pelota, agrega una pared de ladrillos para romper.
8. Derriba el muro
Pídele a Antigravity que agregue los ladrillos
Envía la siguiente instrucción en Antigravity para crear el componente Brick, diseñar la cuadrícula de ladrillos y acelerar la pelota a medida que se rompen los ladrillos:
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.
Comprende el código generado
Se puso en cola la eliminación de componentes y la verificación de ganadores
En lib/src/components/brick.dart, Brick.onCollisionStart quita el ladrillo y verifica si era el último ladrillo del 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 qué la verificación compara query después de llamar a removeFromParent()? Porque la eliminación de componentes en Flame es un comando en cola: el ladrillo solo se quita del árbol de componentes después de que finaliza la devolución de llamada actual, antes del siguiente ciclo del juego.
Curva de dificultad en Ball
Cuando Ball colisiona con un Brick en lib/src/components/ball.dart, refleja el eje de velocidad adecuado y multiplica el vector de velocidad por difficultyModifier (1.03), lo que aumenta gradualmente la velocidad de la pelota con cada ladrillo roto:
} 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);
}
Ejecuta y prueba el juego
Reinicia el juego en caliente para ver el muro de ladrillos completo en acción:

A continuación, agregarás superposiciones de bienvenida, fin del juego y victoria con widgets de Flutter.
9. Gana el juego
Pídele a Antigravity que agregue PlayState y superposiciones de Flutter
En este paso, introducirás una enumeración de PlayState, incorporarás el juego de Flame dentro de un widget de GameApp de Flutter con diseño y superposiciones, y configurarás los permisos de red de la plataforma para google_fonts. Envía la siguiente instrucción en 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`.
Comprende el código generado
Administra superposiciones con PlayState
En lib/src/brick_breaker.dart, el método set de playState sincroniza el estado del juego con el administrador de overlays de 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 el jugador inicie o reinicie un juego en cualquier momento presionando la pantalla (onTapDown) o la barra espaciadora o Intro.
Asigna superposiciones en GameWidget
En lib/src/widgets/game_app.dart, GameWidget.controlled construye la instancia de BrickBreaker y asigna cada nombre de PlayState a una superposición de widget de 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 clave en overlayBuilderMap debe coincidir con el nombre de la superposición que se pasa a overlays.add(...) y overlays.remove(...).
Ejecuta y prueba el juego
Detén y vuelve a ejecutar la app (ya que se actualizaron los permisos de red de la plataforma para google_fonts). Verifica que aparezca 'TAP TO PLAY' cuando se inicie, que se inicie el juego cuando presiones la barra espaciadora o la pantalla, y que se muestre 'G A M E O V E R' cuando pierdas la pelota.
10. Llevar la puntuación
Pídele a Antigravity que agregue la tarjeta de puntuación y las superposiciones animadas.
En este paso final, expondrás la puntuación del jugador de Flame a Flutter con un ValueNotifier y pulirás las superposiciones con flutter_animate. Envía la siguiente instrucción en 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.
Comprende el código generado
Cómo conectar el estado de Flame con Flutter usando ValueNotifier
En lib/src/brick_breaker.dart, BrickBreaker expone final ValueNotifier, que se restablece en startGame() y se incrementa cada vez que se alcanza un Brick.
En lib/src/widgets/score_card.dart, ScoreCard usa ValueListenableBuilder para que solo se vuelva a compilar el texto de la puntuación cuando cambie 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!,
),
);
},
);
}
Cómo animar superposiciones con flutter_animate
En lib/src/widgets/overlay_screen.dart, OverlayScreen encadena efectos de flutter_animate en widgets estándar de Text para deslizar el título y hacer que el subtítulo parpadee:
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 obtener una visión más detallada del poder de las animaciones de flutter_animate y Flutter, consulta la documentación del paquete flutter_animate y el codelab Animaciones en Flutter.
Ejecuta y prueba el juego
Reinicia el juego en caliente. Con todo listo, ahora puedes jugar tu juego de romper ladrillos en cualquiera de las seis plataformas de destino de Flutter:
|
|
11. Felicitaciones
¡Felicitaciones! Creaste un juego de arcade en 2D completo con Flutter, Flame y Google Antigravity.
Qué compilaste
- Un mundo de juego de Flame en 2D con resolución fija (
BrickBreakeryPlayArea) que se escala y se adapta de forma limpia a dispositivos móviles, computadoras de escritorio y la Web. - Componentes de física y colisión (
Ball,BatyBrick) conHasCollisionDetection, hitboxes y actualizaciones de velocidad independientes de la velocidad de fotogramas. - Controles del reproductor multimodales y efectos de Flame que combinan el arrastre táctil y con el mouse (
DragCallbacks) con animaciones deMoveToEffectcontroladas por el teclado y limpieza retrasada deRemoveEffect. - Integración de la IU de Flutter con superposiciones de
GameWidget.controlled, administración de estado deValueNotifierpara actualizaciones de puntuación en tiempo real,google_fontsyflutter_animate.
Lo que vendrá
Sigue enviando instrucciones a Antigravity para personalizar el juego. Estas son algunas ideas que puedes probar:
- Efectos de sonido de arcade retro: Pídele a Antigravity que agregue
flame_audio(o efectos de audio sintetizados) para los golpes de la paleta, los rebotes en la pared y la destrucción de los ladrillos. - Potenciadores y multibola: Genera cápsulas de potenciadores que caen de los ladrillos rotos y que ensanchan la paleta, ralentizan la bola o la dividen en tres.
- Varios niveles y puntuaciones altas: Conserva la puntuación alta del jugador con
shared_preferencesy diseña nuevos diseños de ladrillos para los niveles posteriores.
Próximos pasos
Consulta algunos de estos codelabs relacionados:
- Cómo crear un rompecabezas de palabras con Flutter
- Animaciones en Flutter
- Cómo compilar un diseño de app responsivo y animado con Material 3
- Cómo agregar compras desde la app a tu app de Flutter

