I/O Pinball com Flutter e Firebase
Leve o desenvolvimento de jogos com Flutter para o próximo nível
Para o Google I/O, fizemos uma parceria com a equipe do Flutter para reimaginar um clássico jogo de pinball desenvolvido com Flutter e Firebase. Veja como trouxemos o I/O Pinball para a web com a ajuda do motor de jogos Flame.
Essenciais do desenvolvimento de jogos
O framework Flutter é uma ótima escolha para criar jogos guiados pela interação do usuário, como quebra-cabeças e jogos de palavras. Quando se trata de jogos que usam um game loop, o Flame, um motor de jogos 2D construído sobre o Flutter, pode ser uma ferramenta útil. O I/O Pinball usa os recursos prontos do Flame, como animações, física, detecção de colisão e muito mais, ao mesmo tempo que aproveita a infraestrutura do framework Flutter. Se você consegue criar um app com Flutter, já tem a base necessária para criar jogos com Flame.

Game loop
Em apps convencionais, as telas costumam ficar visualmente estáticas até que haja um evento ou uma interação do usuário. Em jogos, é o contrário: a UI é renderizada continuamente e o estado do jogo muda o tempo todo. O Flame fornece um widget de jogo, que gerencia internamente o game loop para que a UI seja renderizada constantemente de forma performática. A
Game contém a implementação dos componentes e da lógica do jogo, que é passada para o
GameWidget na árvore de widgets. No I/O Pinball, o game loop reage à posição e ao estado da bola na mesa e aplica os efeitos necessários quando a bola colide com um objeto ou sai de jogo.
@override
void update(double dt) {
super.update(dt);
final direction = -parent.body.linearVelocity.normalized();
angle = math.atan2(direction.x, -direction.y);
size = (_textureSize / 45) *
parent.body.fixtures.first.shape.radius;
}
Renderizando um espaço 3D com componentes 2D
Um dos desafios de criar o I/O Pinball foi descobrir como criar um efeito 3D usando apenas elementos 2D. Os componentes são ordenados para determinar como são renderizados na tela. Por exemplo, conforme a bola é lançada pela rampa, a ordem da bola aumenta, para que ela pareça estar sobre a rampa.

A bola, o lançador, as duas paletas e o Chrome Dino são elementos com corpo dinâmico, afetados pela física do mundo. A bola também muda de tamanho conforme sua posição na mesa. Quando a bola se move para o topo da mesa, ela diminui de tamanho para parecer mais distante da perspectiva do usuário. Além disso, a gravidade sobre a bola é ajustada levando em conta o ângulo da máquina de pinball, de modo que a bola caia mais rápido em uma inclinação.
/// Scales the ball's body and sprite according to its position on the board.
class BallScalingBehavior extends Component with ParentIsA<Ball> {
@override
void update(double dt) {
super.update(dt);
final boardHeight = BoardDimensions.bounds.height;
const maxShrinkValue = BoardDimensions.perspectiveShrinkFactor;
final standardizedYPosition = parent.body.position.y + (boardHeight / 2);
final scaleFactor = maxShrinkValue +
((standardizedYPosition / boardHeight) * (1 - maxShrinkValue));
parent.body.fixtures.first.shape.radius = (Ball.size.x / 2) * scaleFactor;
final ballSprite = parent.descendants().whereType<SpriteComponent>();
if (ballSprite.isNotEmpty) {
ballSprite.single.scale.setValues(
scaleFactor,
scaleFactor,
);
}
}
}
Física com Forge 2D
O I/O Pinball depende muito do forge2d
pacote mantido pela equipe do Flame. Esse pacote porta o
motor de física Box2D, de código aberto, para Dart, de modo que pode ser facilmente integrado ao Flutter. Usamos o forge2d para dar vida à física do jogo, por exemplo, a detecção de colisão entre objetos (Fixtures) na mesa.
forge2D permite ouvir quando colisões entre Fixtures acontecem. Em seguida, adicionamos o
ContactCallbacks a Fixtures para ser notificado quando o contato acontece entre dois elementos. Por exemplo, quando a bola (que tem um
Fixture com um CircleShape) entra em contato com um para-choque (que tem um Fixture
com um EllipseShape), a pontuação aumenta. Nesses callbacks, podemos definir exatamente onde o contato começa e termina, de modo que, quando dois elementos entram em contato, ocorre uma colisão.
@override
Body createBody() {
final shape = CircleShape()..radius = size.x / 2;
final bodyDef = BodyDef(
position: initialPosition,
type: BodyType.dynamic,
userData: this,
);
return world.createBody(bodyDef)
..createFixtureFromShape(shape, 1);
}
Animações com sprite sheet
Há alguns elementos na mesa de pinball, como Android, Dash, Sparky e Chrome Dino, que são animados. Para eles, usamos sprite sheets, que são incluídas no motor Flame com o
SpriteAnimationComponent. Para cada elemento, tínhamos um arquivo com a imagem em várias orientações, o número de frames no arquivo e o tempo entre os frames. Usando esses dados, o
SpriteAnimationComponent do Flame compila todas as imagens juntas em loop para que o elemento pareça animado.
final spriteSheet = gameRef.images.fromCache(
Assets.images.android.spaceship.animatronic.keyName,
);
const amountPerRow = 18;
const amountPerColumn = 4;
final textureSize = Vector2(
spriteSheet.width / amountPerRow,
spriteSheet.height / amountPerColumn,
);
size = textureSize / 10;
animation = SpriteAnimation.fromFrameData(
spriteSheet,
SpriteAnimationData.sequenced(
amount: amountPerRow * amountPerColumn,
amountPerRow: amountPerRow,
stepTime: 1 / 24,
textureSize: textureSize,
),
);
Um olhar mais de perto sobre a base de código do I/O Pinball
Placar de líderes com resultados ao vivo do Firebase
O placar de líderes do I/O Pinball mostra, em tempo real, as maiores pontuações de jogadores do mundo todo. Os usuários também podem compartilhar suas pontuações no Twitter e no Facebook. Usamos o Firebase Cloud Firestore para acompanhar as dez maiores pontuações e buscá-las para exibir no placar. Quando uma nova pontuação é gravada no placar, uma Cloud Function reordena as pontuações em ordem decrescente e remove as que não estão mais entre as dez primeiras.

/// Acquires top 10 [LeaderboardEntryData]s.
Future<List<LeaderboardEntryData>> fetchTop10Leaderboard() async {
try {
final querySnapshot = await _firebaseFirestore
.collection(_leaderboardCollectionName)
.orderBy(_scoreFieldName, descending: true)
.limit(_leaderboardLimit)
.get();
final documents = querySnapshot.docs;
return documents.toLeaderboard();
} on LeaderboardDeserializationException {
rethrow;
} on Exception catch (error, stackTrace) {
throw FetchTop10LeaderboardException(error, stackTrace);
}
}
Desenvolvendo para a web
Pode ser mais fácil criar um jogo responsivo do que um app convencional. A mesa de pinball só precisa escalar para o tamanho do dispositivo. No I/O Pinball, aplicamos zoom com base no tamanho do seu dispositivo, em uma proporção fixa. Isso garante que o sistema de coordenadas seja sempre o mesmo, independentemente do tamanho da tela, o que é importante para que os componentes apareçam e interajam de forma consistente em diferentes dispositivos.
O I/O Pinball também se adapta a um navegador mobile ou desktop. No navegador mobile, os usuários podem tocar no botão de lançamento para começar a jogar, além de tocar nos lados esquerdo e direito da tela para controlar as paletas correspondentes. No navegador desktop, os usuários podem usar o teclado para lançar a bola e controlar as paletas.
Arquitetura da base de código
A base de código do pinball segue uma arquitetura em camadas, com cada funcionalidade em sua própria pasta. A lógica do jogo também é separada dos componentes visuais neste projeto. Isso garante que pudéssemos atualizar elementos visuais de forma independente da lógica do jogo, e vice-versa.
O tema do pinball varia conforme o personagem que o usuário seleciona antes de começar o jogo. A temática é controlada pela classe
CharacterThemeCubit. Dependendo da seleção do personagem, a cor da bola, o fundo e outros elementos são atualizados.

/// {@template character_theme}
/// Base class for creating character themes.
///
/// Character specific game components should have a getter specified here to
/// load their corresponding assets for the game.
/// {@endtemplate}
abstract class CharacterTheme extends Equatable {
/// {@macro character_theme}
const CharacterTheme();
/// Name of character.
String get name;
/// Asset for the ball.
AssetGenImage get ball;
/// Asset for the background.
AssetGenImage get background;
/// Icon asset.
AssetGenImage get icon;
/// Icon asset for the leaderboard.
AssetGenImage get leaderboardIcon;
/// Asset for the the idle character animation.
AssetGenImage get animation;
@override
List<Object> get props => [
name,
ball,
background,
icon,
leaderboardIcon,
animation,
];
}
O estado do jogo do I/O Pinball é gerenciado com flame_bloc, um pacote que conecta blocs com componentes do Flame. Por exemplo, usamos
flame_bloc para acompanhar o número de rodadas restantes, quaisquer bônus conquistados durante o jogo, bem como a pontuação atual. Além disso, há um widget no topo da árvore de widgets que contém a lógica da tela de carregamento, incluindo as instruções de como jogar. Também seguimos o
padrão behavior para encapsular e isolar certos elementos de uma funcionalidade do jogo com base em seus componentes. Por exemplo, os para-choques tocam um som quando são atingidos pela bola, então implementamos a classe
BumperNoiseBehavior para lidar com isso.
class BumperNoiseBehavior extends ContactBehavior {
@override
void beginContact(Object other, Contact contact) {
super.beginContact(other, contact);
readProvider<PinballPlayer>().play(PinballAudio.bumper);
}
}
A base de código também contém testes unitários, de widget e golden tests abrangentes. Em alguns momentos, testar o jogo apresentou desafios, pois componentes individuais podiam ter várias responsabilidades, o que dificultava testá-los isoladamente. Como resultado, acabamos definindo padrões para isolar e testar melhor os componentes. Também incorporamos melhorias ao pacote
flame_test.
Sandbox de componentes
Este projeto depende muito dos componentes do Flame para dar vida à experiência do pinball. A base de código inclui um sandbox de componentes, que é semelhante a uma galeria de componentes de UI. Essa é uma ferramenta útil no desenvolvimento de jogos, pois permite desenvolver os componentes do jogo isoladamente e garantir que eles tenham a aparência e o comportamento esperados antes de integrá-los ao jogo.

Próximos passos
Veja se você consegue alcançar uma pontuação alta no I/O Pinball! O código é open source neste repositório do GitHub. Fique de olho no placar de líderes e não deixe de compartilhar sua pontuação nas redes sociais!