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.

dart
@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.

dart
/// 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.

dart
@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.

Exemplo de sprite sheet
Exemplo de sprite sheet
dart
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.

dart
/// 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.

dart
/// {@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.

dart
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!

Mais do Flutter