Fluxo do Jogo

O fluxo do jogo é orquestrado através de um sistema de cenas do Phaser, garantindo uma progressão lógica e uma experiência de usuário coesa.

BootScene.ts (src/scenes/flow/BootScene.ts)

  • Propósito: É a primeira cena a ser carregada quando o jogo inicia. Sua principal responsabilidade é carregar recursos essenciais e mínimos necessários para a cena de pré-carregamento, como um logotipo ou uma barra de progresso inicial.

  • Transição: Após carregar seus recursos, transiciona para a PreloadAssets.ts.


PreloadAssets.ts (src/scenes/base/preloadAssets.ts)

  • Propósito: Responsável por carregar todos os ativos do jogo (imagens, spritesheets, áudios, tilemaps, etc.) que serão utilizados nas cenas subsequentes. Exibe uma barra de progresso para o jogador, indicando o status do carregamento.

  • Transição: Uma vez que todos os ativos são carregados, transiciona para a TitleScene.ts.


TitleScene.ts (src/scenes/flow/TitleScene.ts)

  • Propósito: Apresenta a tela de título do jogo, geralmente com o logotipo do jogo e uma opção para iniciar o jogo ou acessar outras seções (como opções ou créditos).

  • Transição: Ao interagir com a tela de título (ex: pressionar uma tecla ou clicar em um botão), transiciona para a MenuScene.ts.


  • Propósito: Exibe o menu principal do jogo, oferecendo opções como iniciar um novo jogo, continuar, acessar configurações, ver créditos ou sair. É o hub central para a navegação do jogador.

  • Transição: Dependendo da escolha do jogador, pode transicionar para:

    • CharacterSelectScene.ts (se houver seleção de personagem),

    • GameScene.ts (para iniciar o jogo diretamente), ou

    • outras cenas de configuração.


CharacterSelectScene.ts (src/scenes/flow/CharacterSelectScene.ts)

  • Propósito: Permite ao jogador escolher um personagem ou skin antes de iniciar a jogabilidade principal. Pode apresentar diferentes opções visuais ou com atributos variados.

  • Transição: Após a seleção, transiciona para a GameScene.ts.


GameScene.ts (src/scenes/gameplay/GameScene.ts)

  • Propósito: A cena principal onde a jogabilidade ocorre. Gerencia o jogador, os inimigos, o sistema de ondas, colisões, pontuação, UI de jogo (HUD) e a lógica de progressão da onda.

  • Transição: Pode transicionar para:

    • PauseScene.ts (ao pausar),

    • GameOverScene.ts (ao perder),

    • NextPhaseScene.ts (ao completar uma onda/fase), ou

    • CutscenesScene.ts (em momentos específicos da narrativa).


PauseScene.ts (src/scenes/flow/PauseScene.ts)

  • Propósito: Exibida quando o jogo é pausado. Permite ao jogador retomar o jogo, acessar opções ou retornar ao menu principal.

  • Transição: Retorna para a GameScene.ts (ao retomar) ou para a MenuScene.ts.


GameOverScene.ts (src/scenes/flow/GameOverScene.ts)

  • Propósito: Exibida quando o jogador é derrotado. Mostra a pontuação final e oferece opções como tentar novamente ou retornar ao menu principal.

  • Transição: Pode transicionar para a:

    • GameScene.ts (para reiniciar), ou

    • MenuScene.ts.


NextPhaseScene.ts (src/scenes/flow/NextPhaseScene.ts)

  • Propósito: Gerencia a transição entre ondas ou atos do jogo. Pode exibir informações sobre a próxima onda, permitir upgrades ou apresentar uma breve tela de carregamento.

  • Transição: Transiciona de volta para a GameScene.ts para a próxima onda de jogabilidade.


CutscenesScene.ts (src/scenes/flow/CutscenesScene.ts)

  • Propósito: Exibe sequências animadas ou estáticas para avançar a narrativa do jogo em pontos específicos. As cutscenes são definidas no CutscenesContainer.ts.

  • Transição: Após a conclusão da cutscene, transiciona para a próxima cena lógica, que pode ser a GameScene.ts ou outra cena de fluxo.


⚙️ Interação entre Cenas e Componentes

O fluxo é mantido através de chamadas this.scene.start(), this.scene.launch(), this.scene.stop() e this.scene.resume(). O globalEventEmitter desempenha um papel crucial na comunicação entre cenas e componentes, permitindo que eventos como waveCompletedAndAdvance ou boostActivated sejam emitidos e ouvidos por diferentes partes do sistema, desacoplando a lógica e tornando o código mais modular e flexível.

Atualizado