Índice de contenido
- ¿Qué es Flame y por qué usarlo para crear juegos en Flutter?
- El Ecosistema: ¿Qué necesitas dominar primero?
- ¿Qué tipo de videojuego 2D se adapta mejor a tu fase de aprendizaje?
- El "Enfoque Pro": Gestión de Memoria y Ciclo de Vida vs Creación descontrolada
- Tu Ruta de Maestría en Videojuegos con Flame
- Fases del libro Garantizadas:
- Recursos Gratuitos para Profundizar
- Libro Comunitario Gratis
- Repositorio Oficial del libro
- Demos en Vivo del Proyecto
- Prólogo del Motor: De Widgets a Componentes
- Resumen de Módulos del libro
- Proyectos Reales que construirás en el libro
- Preguntas Frecuentes
- Experiencia del Autor en el Mundo Real
- 1. introducción
- 2. Como ver el curso
- 1. Crear un proyecto
- 1. Introducción
- 2. Clase FlameGame: Ejemplo Sprite
- 3. Clase FlameGame: Ejemplo Canvas, círculo
- 4. Reto: Clase FlameGame: Ejemplo Canvas, rectángulo
- 5. Clase Game: Ejemplo Canvas, círculo
- 6. Clase Game/FlameGame: función update
- 7. SpriteComponent: Una sola imagen/sprite
- 8. SpriteComponent: Actualizar posición
- 9. Entradas: Teclado, FlameGame
- 10. Entradas: Teclado, Componente
- 11. Reto: Mover sprite al pulsar flechas de direcciones
- 12. SpriteComponent: Conseguir sprites para tu juego
- 13. SpriteComponent: Texturepacker
- 14. SpriteComponent: Cargar un sprite sheet
- 15. SpriteAnimationComponent: Puntos claves
- 16. SpriteAnimationComponent: Pruebas
- 17. SpriteAnimationComponent: Pruebas
- 18. SpriteAnimationComponent: Resto de animaciones
- 19. SpriteAnimationComponent: Resto de animaciones
- 20. Entradas: Tap, Componente
- 21. Reto: SpriteAnimationComponent: Cambiar animación por tap
- 22. Reto: Animaciones y entradas (teclado): animación de caminar y reposo
- 23. Flip o mirror del sprite (y ancho propiedad)
- 24. Velocidad constante
- 25. Combinación de teclas
- 26. PositionComponent: Dibujar un círculo con hitbox
- 27. Reto: PositionComponent: Mover círculo en el eje X
- 28. Detectar colisiones: ScreenHitbox
- 29. Colisiones y PositionComponent: Invertir dirección
- 30. Reto: Colisiones entre círculos
- 31. Contador para las colisiones
- 32. Colisiones en los sprites y modo debug
- 33. Publicar en github
- 1. Introducción
- 2. Versión de Flame recomendada V1.7.3
- 3. Proyecto en código base
- 4. Generar círculos de colisión/hitbox por tiempo
- 5. Limitar que el player salga de pantalla
- 6. Player: Variar animación al detectar borde
- 7. Generar contenedor (círculo de colisión) para la colisión
- 8. Player: Implementar gravedad
- 9. Remover componentes no visibles (círculos de colisión)
- 10. Player: Implementar salto
- 11. Modularizar clase player
- 12. Sprite animado de meteorito
- 13. Contador de impactos
- 14. Publicar en github
- 1. Introducción
- 2. Color de fondo: Función
- 3. Color de fondo: Clase
- 4. Imagen de fondo
- 5. Pruebas con distintos tamaños de la imagen del fondo, parte 1
- 6. Pruebas con distintos tamaños de la imagen del fondo, parte 2
- 7. Actualizar componente player con las dimensiones del mapa
- 8. Establecer la cámara que siga al componente
- 9. Actualizar componente meteor con las dimensiones del mapa
- 10. Publicar en github
- 1. Introducción
- 2. Editores, tileset y tiles
- 3. Tiled Map Editor, primeros pasos
- 4. Flame tiled y bases del juego
- 5. Cargar mapa tile
- 6. Iterar capa object y definir un PositionComponent
- 7. Detectar piso y gravedad
- 8. Publicar en github
- 1. Introducción
- 2. Detectar player en el aire
- 3. Cambios en el componente de salto y desplazamiento
- 4. Animación de salto en un loop
- 5. Desplazamiento en los tiles
- 6. Desplazamiento horizontal con el vector de velocidad
- 7. Crear varios componentes de hitbox para el player
- 8. Agregar el componente de meteorito
- 9. Posición del player
- 10. Modificar desplazamiento: X
- 11. Modificar desplazamiento: Y
- 12. Nuevo mapa y activar cámara
- 13. Overlay: Primeros pasos
- 14. Overlay: Game over
- 15. Instancia game en componentes y overlay
- 16. Instancia game en overlays y comunicación con los componentes
- 17. Funciones del overlay
- 18. Corregir contador de colisiones
- 19. Tipos de colisiones
- 20. Reset del player
- 21. Overlay: Contador de vidas
- 22. Reiniciar nivel al acabarse las vidas
- 23. Pausa
- 24. Reiniciar nivel
- 25. Actualizar posición con deltatime
- 26. Bloquear movimiento del player por tiempo
- 27. Invencibilidad
- 28. Consumibles en el mapa
- 29. Consumibles en el mapa: Definir Sprite y registrar en la aplicación
- 30. Consumibles en el mapa: Colocar en el mapa
- 31. Consumibles en el mapa: Implementar lógica para ganar una vida
- 32. Consumibles en el mapa: Recargar en el reload
- 33. Consumibles en el mapa: Sobrescribir
- 34. Consumibles en el mapa: Implementar lógica para el resto
- 35. Colocar parámetros extras a la función de reset
- 36. Publicar en github
- 1. Introducción
- 2. Variar el salto
- 3. Tamaño del mapa y movimiento del player
- 4. Imagen de fondo
- 5. Desnivel entre el posicionamiento del player y los tiles
- 6. Evitar que el player caiga a una velocidad muy elevada
- 7. Fórmulas matemáticas básicas: Presentación
- 8. Fórmulas matemáticas: hitbox player
- 9. Fórmulas matemáticas: Implementación
- 10. Fórmulas matemáticas: Detalles finales
- 11. Fórmulas matemáticas: Centros de las colisiones
- 12. Fórmulas matemáticas: Normal de la colisión
- 13. Fórmulas matemáticas: Magnitud
- 14. Producto escalar
- 15. Adaptar a pantallas pequeñas
- 16. Publicar en github
- 1. Flame 1.81 Animación Ticker
- 2. cameraComponent
- 1. Introducción
- 2. Estructura base
- 3. Animaciones de movimiento
- 4. Movimiento
- 5. Demo: Movimiento, isMoving
- 6. Cambios en el movimiento y animación
- 7. Crear mapa
- 8. Importar y usar mapa en el proyecto
- 9. Componentes para los obstáculos
- 10. Cámara
- 11. Colisiones player obstáculos, estructura y pruebas iniciales
- 12. Colisiones player obstáculos, otras pruebas
- 13. Colisiones player obstáculos, implementación final
- 14. Colisiones player obstáculos, variante
- 15. Colisiones player obstáculos, doble colisión
- 16. Límites de la pantalla para el player
- 17. Definir posición del player
- 18. Tamaño hitbox
- 19. Correr
- 20. Publicar en github
- 1. Introducción
- 2. Clase base
- 3. Clase zombie
- 4. Actualizar sprite
- 5. Colisiones entre objetos y límites para del mapa
- 6. Manejar múltiples enemigos: Listado de enemigos por mapa
- 7. Manejar múltiples enemigos: Mover al player en base a patrones
- 8. Manejar múltiples enemigos: Terminar y probar
- 9. Capa de enemigos en el mapa
- 10. Clase esqueleto
- 11. Capa de objeto para los enemigos
- 12. Publicar en github
- 1. Introducción
- 2. Sobre el proyecto
- 3. Importar sprite iniciales de plantas
- 4. Crear un componente de planta, Base
- 5. Crear un componente de planta, Peashooter
- 6. Reto, Crear un componente de planta, Cactus
- 7. FlameGame: Agregar una planta por toque
- 8. Mapa: Diseñar
- 9. Mapa: Cargar
- 10. Componente: Agregar una planta por toque, parte1
- 11. Componente: Agregar una planta por toque, parte2
- 12. Agregar una planta alineada en el SeedComponent
- 13. Escalar planta al tamaño del seed
- 14. Evitar agregar varias plantas en un mismo lugar
- 15. Crear un componente de zombie, Base
- 16. Crear un componente de zombie, Cono
- 17. Reto, Crear un componente de zombie, Puerta
- 18. Manejo del nivel
- 19. Agregar un zombie cada cierto tiempo
- 20. Crear canales
- 21. Variar animación de las plantas a modo ataque
- 22. Proyectil: Crear estructura
- 23. Proyectil: Disparar
- 24. Proyectil: Posición inicial
- 25. Vida y colisiones
- 26. La planta ataca a los zombies
- 27. Detener al zombie en contacto con las plantas
- 28. El zombie ataca a las plantas
- 29. Variar animación del zombie en el modo ataque y al estar herido
- 30. Cambiar tamaño del hitbox del zombie
- 31. No colocar planta en espacio ocupado por un zombie
- 32. Drag, Implementar el componente de cámara y world
- 33. Drag, Crear un nuevo componente para el evento Drag
- 34. Drag, Implementar el evento Drag
- 35. Drag, Desplazar la cámara
- 36. Agregar plantas y zombies al world
- 37. Escalar componentes al tamaño de la ventana: Presentación
- 38. Escalar componentes al tamaño de la ventana: Calcular factor
- 39. Escalar componentes al tamaño de la ventana: Fondo
- 40. Escalar componentes al tamaño de la ventana: Seeds
- 41. Escalar componentes al tamaño de la ventana: Plantas
- 42. Escalar componentes al tamaño de la ventana: Zombies
- 43. Detalles finales
- 44. Publicar en github
- 1. Introduccion
- 2. Overlay: Plantas
- 3. Overlay: Plantas, Seleccionar
- 4. Overlay: Plantas, Marcar planta seleccionada
- 5. Componente de soles
- 6. Desplazar soles onduladamente
- 7. Contador de soles
- 8. Overlay: Soles
- 9. Costo por plantas
- 10. Transparencia en el overlay de plantas
- 11. Generar soles en el espacio del mapa
- 12. Recarga de las plantas: Configuración base
- 13. Recarga de las plantas: Reutilizar el widget de la animación
- 14. Mostrar animación al agregar la planta en el mapa
- 15. Reto: Evitar agregar una planta cuando hay una animación en progreso
- 16. Extra: Corregir sprite sheets, zombie cono, primera parte
- 17. Extra: Corregir sprite sheets, zombie cono, segunda parte
- 18. Bloquear planta individualmente
- 19. Personalizar tiempo de bloqueo de las plantas
- 20. Reubicar widgets del borde de las plantas en el overlay
- 21. Pausa
- 22. Reset
- 23. Evento Drag, Presentación
- 24. Publicar en github
- 1. Introducción
- 2. Crear proyecto
- 3. Importar images parallax
- 4. Crear el efecto parallax: Superponer fondos
- 5. Crear el efecto parallax: Desplazar fondos, baseVelocity
- 6. Crear el efecto parallax: Desplazar fondos a diferentes velocidades, velocityMultiplierDelta
- 7. Crear una clase componente para el parallax
- 8. Player: Estructura base
- 9. Player: Definir animaciones
- 10. Player: Hitbox
- 11. Player: Desplazamiento
- 12. Player: Rotación, primeros pasos
- 13. Player: Rotación, flipVertically
- 14. Generar dulces: Fundamentos
- 15. Generar dulces: Ideas iniciales
- 16. Generar archivo ayuda food, primera parte
- 17. Generar archivo ayuda food, primera parte
- 18. Generar dulces: Sobre el componente
- 19. Generar dulces: Componente de alimento, estructura base
- 20. Generar dulces: Componente de alimento, calcular posición
- 21. Generar dulces: Componente de alimento, generar
- 22. Generar dulces: Componente de alimento, remover
- 23. Generar dulces: Componente de alimento, límites en la posición
- 24. Consumir alimentos: Hitbox
- 25. Consumir alimentos: Colisión
- 26. Consumir alimentos: Reproducir animación de masticando
- 27. Consumir alimentos: No consumir alimentos mientras mastica
- 28. Consumir alimentos: Consumir los alimentos en una posición
- 29. Estadísticas: Propiedad adicional para el puntaje
- 30. Estadísticas: Propiedades y lógica
- 31. Estadísticas: Overlay
- 32. Implementar bases para las formas de jugabilidad
- 33. Implementar bases para las formas de jugabilidad
- 34. Jugabilidad 1: Al perder un dulce
- 35. Jugabilidad 2: Conseguir un mínimo de puntos
- 36. Jugabilidad 3: Solo consumir un tipo de dulce
- 37. Jugabilidad 4: No consumir un tipo de dulce
- 38. Jugabilidad: Dulce consumido o perdido
- 39. Probar implementaciones: Estructura base
- 40. Probar implementaciones: Jugabilidad 1
- 41. Probar implementaciones: Jugabilidad 2
- 42. Cambio en las estadísticas
- 43. Probar implementaciones: Jugabilidad 3
- 44. Probar implementaciones: Jugabilidad 4
- 45. Definir múltiples niveles
- 46. Función para hacer cargar niveles del juego
- 47. Overlay: Fin de juego, implementar
- 48. Overlay: Fin de juego, mostrar
- 49. Overlay: Acciones del juego
- 50. Overlay: Seleccionar niveles
- 51. Overlay: Seleccionar la jugabilidad
- 52. Mostrar información del tipo de juego y nivel en pantalla
- 53. Mostrar información del tipo de juego y nivel en pantalla
- 54. GameOver: Implementar tipos de juego
- 55. Siguiente nivel
- 56. Publicar en Github
- 1. Introducción
- 2. Hud: Presentación
- 3. Hud: joystick, definición
- 4. Hud: joystick, movilidad
- 5. Hud: Botón para rotar al player, definición
- 6. Hud: Botón para rotar al player, rotación
- 7. Shared Preferences, prevalecer estado del juego
- 8. Eliminar las instancias de alimentos al reiniciar
- 9. Adaptar a pantallas pequeñas
- 10. Sobre el uso del GamePad
- 11. gamepads: Pruebas
- 12. Implementar el uso del GamePad
- 13. Publicar Github
- 1. Audio experimental
- 2. FlameAudio, primeros pasos
- 3. Juego 2 - Dino Jump: Sonido de Fondo
- 4. Juego 2 - Dino Jump: Sonido por acciones
- 5. Juego 2 - Dino Jump: Sonido en bucle demo 1
- 6. Juego 2 - Dino Jump: Sonido en bucle demo 2
- 7. Juego 2 - Dino Jump: Consumibles
- 8. Juego 4 - Plantas vs Zombies: Configurar proyecto
- 9. Juego 4 - Plantas vs Zombies: Zombies, sonido base
- 10. Juego 4 - Plantas vs Zombies: Zombies, variar sonido por componente
- 11. Sonidos, Reiniciar y/o Reload
- 12. Juego 4 - Plantas vs Zombies: Detectar fin del juego
- 13. Juego 4 - Plantas vs Zombies: Reproducir un solo sonido
- 14. Juego 5 - Parallax: Sonidos
- Algunas recomendaciones
Flame potencia Flutter: ya no solo podemos emplear el mismo código para móvil, escritorio y web… además podemos usarlo para crear increíbles juegos 2D multiplataforma. Flame es la pieza clave que lo hace posible. Si buscas un libro Flutter Flame completo, práctico y pensado para que entiendas el motor desde cero, aquí te cuento exactamente cómo lo enfoco y qué puedes esperar.
"Con Flame, los componentes son los equivalentes a los widgets en Flutter. Cada componente representa un elemento de tu juego (jugador, enemigo, fondo, consumible) con su propia lógica. Esa familiaridad hace que la curva de aprendizaje sea sumamente suave y divertida."
Flame es un motor de juego 2D de código abierto construido completamente sobre Dart y diseñado para integrarse de forma impecable como un plugin de Flutter. Esto te da el poder de compilar tu videojuego en Android, iOS, Windows, Mac, Linux y web usando una única base de código y en tiempo récord.
Lo que aprenderás en este libro Maestro de Flutter Flame
- Arquitectura de Render Loop: Entender a fondo cómo funciona el ciclo de vida perpetuo a 60 FPS estables de Flame.
- Manejo de Sprites y Animaciones: Cargar e integrar hojas de sprites complejas (SpriteSheets) para dotar de movimiento a los personajes.
- Colisiones e Interacción: Implementar físicas precisas, saltos, gravedad, caídas y detección lógica de colisiones en tiempo real.
- Mapas Tiled Interactivos: Importar mundos XY completos diseñados en editores de mapas externos para la exploración del jugador.
- Overlays de UI e Inmersión: Crear menús HUD, barras de vida y pantallas interactivas usando widgets nativos de Flutter sobre la escena.
- Audio y Físicas Forge2D (segunda parte del libro -libro aparte-): Añadir pistas de música envolvente y efectos sonoros interactivos para maximizar la experiencia del jugador.
¿Qué es Flame y por qué usarlo para crear juegos en Flutter?
Flame es la herramienta definitiva para los desarrolladores de Flutter que sueñan con adentrarse en la industria del desarrollo de videojuegos. Al basarse en componentes que imitan la filosofía modular de los widgets, te permite aprovechar todo tu ecosistema de diseño y lógica de Dart preexistente. No requiere configuraciones engorrosas de motores ajenos como Unity: agregas un simple paquete de dependencias y tu lienzo de Flutter cobra vida propia de forma instantánea.
El Ecosistema: ¿Qué necesitas dominar primero?
| Tecnología / Plugin | Curva de Aprendizaje | Propósito en el App |
|---|---|---|
| flame_audio | Baja | Plugin oficial utilizado para gestionar la reproducción de música de fondo y efectos sonoros por acción. |
| flame_forge2d | Media-Alta | Integración del motor de físicas Box2D (Forge2D) para colisiones avanzadas de precisión y simulación de gravedad. (Se ve en la parte dos de la serie) |
| flame_tiled | Media | Cargar y pintar de forma interactiva mapas de cuadrículas y celdas complejas exportados desde Tiled Map Editor. |
| flame_svg | Baja | Soporte integral para renderizar gráficos vectoriales escalables (SVG) de alto rendimiento en tus sprites de juego. |
¿Qué tipo de videojuego 2D se adapta mejor a tu fase de aprendizaje?
| Objetivo del Juego | Perspectiva / Técnica | ¿Por qué? |
|---|---|---|
| Juego Plataforma | Plataforma con Parallax e inputs simples | Excelente para comenzar e introducir conceptos como saltos, desplazamientos, vidas, niveles, consumibles, poderes y enemigos. |
| Exploración de mundos amplios (RPG / Plataformas) | Tilemaps XY con cámara inteligente | Permite crear escenarios expansivos cargando celdas interactivas en pantalla sin sobrecargar el hilo del procesador. |
| Plantas vs Zombies | Entidades sobre cuadrícula | Perfecto para coordinar la interacción con el mapa, eventos de toque, sincronizar carriles para enemigos, ataques automáticos… |
El "Enfoque Pro": Gestión de Memoria y Ciclo de Vida vs Creación descontrolada
Uno de los errores fatales en el desarrollo de videojuegos móviles es crear y cargar relibros gráficos dentro del bucle de actualización (`update`), lo que satura el colector de basura y produce micro-stuttering. Observa la diferencia entre un código lento y la optimización senior con caché anticipada:
class Player extends PositionComponent {
@override
void update(double dt) {
// MAL: Cargar archivos dentro del bucle
// recrea el objeto 60 veces por segundo.
final sprite = Sprite.load('player.png');
// ...
}
}class Player extends SpriteComponent with HasGameRef {
@override
Future<void> onLoad() async {
super.onLoad();
// BIEN: Se carga de forma asíncrona
// una sola vez al instanciar el componente.
sprite = await gameRef.loadSprite('player.png');
}
@override
void update(double dt) {
// update se limita solo a cálculos lógicos.
position.x += 100 * dt;
}
}En este libro, aprenderás a estructurar tus componentes para garantizar que el recolector de basura de Dart no afecte la tasa de FPS de tu videojuego en dispositivos móviles de gama baja.
Tu Ruta de Maestría en Videojuegos con Flame
Aprende de forma estructurada paso a paso a dominar la física, los sprites animados y la orquestación lógica en un motor de juegos real sin frustraciones académicas.
Fases del libro Garantizadas:
- Fase 1: Ciclo de Vida y Canvas. Instalación inicial, ciclo de vida (`onLoad`, `update`, `render`), inputs táctiles y atajos de teclado básicos.
- Fase 2: Físicas y Fondo Parallax. Desarrollo completo del clon Dino Jump incorporando físicas de saltos dinámicos, gravedad y control del background en múltiples capas.
- Fase 3: Tilemaps y Coordenadas XY. Carga y renderizado de mapas Tiled, control dinámico de cámaras en mundos infinitos y colisión estructural con el terreno.
- Fase 4: Inteligencia Enemiga y Audio. Patrones de movimiento para enemigos lógicos, reproductores de música envolvente en bucle y empaquetado final multiplataforma.
Recursos Gratuitos para Profundizar
Accede al libro digital completo y a todos los repositorios oficiales que hemos diseñado para este programa:
Libro Comunitario Gratis
También tengo recursos gratuitos para el libro y Libro en el Blog y el libro y libro comunitario/GRATIS en la web de Academia. El libro también tiene el formato en libro con el 100% del contenido del mismo, es decir, el libro es equivalente al libro.
Repositorio Oficial del libro
Consigue y modifica las plantillas oficiales y los códigos funcionales desarrollados a lo largo del libro:
Demos en Vivo del Proyecto
Haz clic en los enlaces a continuación para jugar directamente las demos compiladas en la web:
Prólogo del Motor: De Widgets a Componentes
Con Flutter estamos acostumbrados a pensar en interfaces de usuario estáticas, formularios y flujos de pantallas tradicionales. Pero con Flame, el lienzo cobra vida propia. Al cambiar la mentalidad de 'Widgets' por 'Componentes', entramos en un mundo dinámico gobernado por un Render Loop perpetuo. Aprender a manejar los ciclos de actualización gráfica de forma nativa te dará un control total sobre cada píxel, abriendo un abanico infinito de posibilidades para llevar tus aplicaciones móviles e interactivas al siguiente nivel.
A lo largo de este libro eminentemente práctico, nos sumergiremos en mini-proyectos de prueba y guías estructuradas que te darán la soltura técnica idónea para coordinar decenas de personajes simultáneos en pantalla a 60 FPS estables.
Resumen de Módulos del libro
- Módulo 1: Fundamentos y Canvas Gráfico: Bucle de renderizado, PositionComponents e inputs de teclado y tap (Capítulos 1 al 3).
- Módulo 2: Mecánicas Runner e inputs Físicos: Desarrollo de Dino Jump con saltos y backgrounds Parallax dinámicos (Capítulos 4, 5, 7 y 8).
- Módulo 3: Tilemaps y Creador de Escenarios: Integración y dibujado de mapas estructurados mediante Tiled (Capítulo 6).
- Módulo 4: Perspectiva Lógica y Enemigos XY: Rutinas de patrullaje dinámico y cámara de seguimiento en mundos XY amplios (Capítulos 9 y 10).
- Módulo 5: Proyectos Complejos e Inclusión de Audio: Construcción de Plants vs Zombies y reproductores de audio multiplataforma (Capítulos 11 y 12).
Proyectos Reales que construirás en el libro
A diferencia de los libros teóricos convencionales, aquí desarrollaremos múltiples ejemplos y clones interactivos funcionales listos para tu portafolio:
- Dino Jump: Un clon runner completo con sprites animados de dinosaurios, control de salto físico del jugador, spawns aleatorios de obstáculos y colisiones inmediatas de Game Over.
- Parallax Effect: Demostración de profundidad gráfica 2D espectacular dividiendo la escena del background en capas independientes con velocidades de scroll relativas.
- Plants vs Zombies (Simplificado): Orquestación interactiva sobre grilla estática para el desove (spawning) de plantas aliadas, rutinas de ataque y defensa contra oleadas de enemigos animados.
- World XY: Diseño y control de cámara en mundos expansivos interactivos con detección estructural y colisiones con el terreno.
Preguntas Frecuentes
- ¿Flame es adecuado para crear videojuegos en 3D?
- Flame es un motor optimizado y diseñado específicamente para el desarrollo en 2D. Si bien Flutter admite integraciones 3D a través de otros paquetes (como Three.js o incrustaciones nativas), si tu objetivo principal es crear un videojuego 3D completo de alto rendimiento móvil, es más recomendable optar por motores dedicados como Unity, Unreal Engine o Godot.
- ¿Puedo subir mis juegos hechos con Flame a la Play Store y la App Store?
- ¡Absolutamente! Flame corre encima de Flutter, lo que significa que hereda toda su potencia multiplataforma. Con un solo desarrollo puedes compilar y distribuir tu videojuego de forma 100% nativa en Android, iOS, Windows, macOS, Linux y la Web, permitiéndote monetizarlo y publicarlo en cualquier tienda de aplicaciones.
- ¿Es necesario dominar conceptos avanzados de física o matemáticas para empezar?
- No es indispensable. Flame provee herramientas integradas muy intuitivas para resolver la lógica de gravedad, rebotes e interacción, e incluso cuenta con soporte directo para Forge2D (un motor de física Box2D). Este libro te enseñará la lógica paso a paso para que comprendas el flujo del
Render Loopsin frustrarte con matemáticas complejas. - Es una formación extremadamente práctica con guías lógicas para el ciclo de vida de los PositionComponents, colisiones y sonidos.
- No es indispensable. Flame provee herramientas integradas muy intuitivas para resolver la lógica de gravedad, rebotes e interacción, e incluso cuenta con soporte directo para Forge2D (un motor de física Box2D). Este libro te enseñará la lógica paso a paso para que comprendas el flujo del
Experiencia del Autor en el Mundo Real
“He pasado años desarrollando e implementando proyectos de Flutter en producción comercial, y he aprendido que no hay mejor manera de consolidar tus bases de renderizado y lógica matemática de software que creando videojuegos. En este libro he volcado más de 12 capítulos interactivos basados en casos reales para que domines el ciclo de vida gráfico de Flame con la misma soltura con la que creas tus layouts tradicionales de Flutter.”