CRYENGINE FlappyBoid Syllabus 5.5D em Português

CRYENGINE Flappy Boid Course 5.
5D
Livro de exercícios do aluno
Definindo uma câmera padrão 12

Índice
Escondendo a mira da arma do FPS 13
CRYENGINE Flappy Boid Course 5.5D 1 Visualizando Física e Sistemas AI 13
Índice 1 Entendendo os tipos de dados do gráfico de fluxo 13
Configuração do curso 3 02: Configurando a lógica inicial 16
Configuração do curso para estudo autônomo 3 Fazendo a câmera seguir o player 16

Instalando o CRYENGINE e o GameSDK 3 Adicionando uma textura à esfera 16
Instalando os ativos do curso 3 03: Adicionando os Obstáculos da Tubulação 18
Requisitos de sala de aula para professores 3 Considerações sobre design de jogos 18

Configuração de sala de aula para professores 4 Adicionando os Tubos 18
Objetivos de Aprendizagem do Curso 4 Ajustando a iluminação usando o editor de ambiente 18
Convenções do livro de exercícios do curso 4 Adicionando o tubo superior 19
Introdução 5 Adicionando um Trigger de Pontuação 19
Perquisites 5 04: Adicionando o texto "Game Over" 22
01: Construindo os Ativos, Visualização e Funcionalidade Básica 6 Vinculação vs. Agrupamento 22
Brainstorm ideias de design “Flappy Boid” 6 Editando Entidades Agrupadas 22
Vendo a configuração padrão do GameSDK 6 05: Adicionando um fundo de céu em movimento 23
Adicionando uma Entidade de Player Simples 6 Adicionando uma caixa de plano de fundo 23
Adicionando um objeto RigidBodyEx Player 6 Adicionando uma textura do céu 23
Propriedades e Estratégias Físicas 7 Escalando a textura de fundo 23
Usando um ponto de marcação AI para gerar scripts de gráfico de fluxo 7 Animando a textura do céu 23
Visão geral do gráfico de fluxo 8 Removendo sombras através de shaders 24
Primeiro Mecânico de Jogo: a Ação de Salto 9 Escalando e posicionando a caixa de plano de fundo 24
Respondendo à ação de salto 9 Usando iluminação global 25
Modificando a funcionalidade do SDK do jogo 11 Otimizando Entidades do Designer por meio da Exportação CGF 25
Escondendo o jogador de tiro e o HUD 11 06: Mover os canos 27
Impedindo o jogador de tiro de andar 12 Movendo o primeiro tubo 27

Adicionando uma Câmera 12 Repor a posição do tubo 28
CRYENGINE Flappy Boid Course Ver. 5.5D -1- Configuração do curso

Movendo os Outros Tubos 30 Criando um Material de Vidro para as Estrelas 63
Considerações ambientais 30 Convertendo Modelos de Designer para o Formato CGF 63
Criando uma Câmera de Depuração 30 Considerando problemas de Shader 64
07: Mantendo Pontuação 32 Adicionando uma cúpula de céu animado 64
Adicionando uma variável de pontuação 32 Adicionando sombras de nuvens em movimento 64
Incrementando a pontuação 32 Configurando as estrelas de pontuação 64
Exibindo a pontuação na tela 32 Adicionando efeitos de partículas 67
Adicionando Texto "Pontuação" 33 Eliminando forças físicas de efeitos de partículas 67
08: Jogador "Morte" 35 Randomização de efeitos de partículas 67
Acompanhamento de "morte" usando um token de jogo 35 11: Adicionando Áudio 70
Detectando Colisões 35 Design de som 70

Terminando o jogo 35 Ativando a Depuração de Áudio 70
Congelando a câmera na morte do jogador 36 Adicionando sons ambientais 71
Configurando um jogo sobre a câmera 38 Criando uma biblioteca de áudio 71
Parando o movimento da tubulação na morte 39 Adicionando disparadores de áudio ao seu jogo 72
Desabilitando o salto após a morte 39 Adicionando um som de colisão 73
09: aprimoramentos 42 Prevenindo vários sons de colisão 74
Escondendo terreno 42 Desabilitando o salto em colisão 76
Adicionando uma Configuração Global de Dificuldade 43 Adicionando Game Over Sounds 76
Adicionando Velocidade de Tubo Horizontal Dinâmico 44 Adicionando um som de "Flap" 77
Adicionando movimento de tubo vertical aleatório 45 Adicionando sons de pontuação 78
Ajustando a velocidade do tubo para a distância real de deslocamento 47 Adicionando sons aos efeitos de partículas 78
Randomizing Z of Pipe Start Point 49 12: Exportando um jogo para uma construção independente 80
Adicionando Death Triggers Para Restringir o Jogador 51 Ocultar informações de exibição na compilação 80
Fazendo o nível recarregar automaticamente após a morte 52 Portando um nível para outro computador ou compilação 80
Minimizando a distorção da lente usando o FOV da câmera 55 Desafios para aprimoramentos adicionais 80
Explorando Câmeras 55 O Design Final 80
Finalização opcional: movimento da câmera 56 Indo além 85
Final opcional: respingo e pia 56
Randomizing Pipe Materials 58
Desativando o efeito de morte do FPS no Game Start 60
10: Adicionando alvos de pontuação animados 62
Modelando as Estrelas 62

Configuração do curso 4 Pesquise o recurso do curso "Flappy Boid" e adicione -o ao seu carrinho.
5 Confira e baixe os dois ativos do mercado.
Configuração do curso para estudo autônomo 6 No Iniciador, clique em Biblioteca > Meus Ativos . Encontre o Flappy Boid
de ativos. Clique na seta ao lado e escolha Revelar no Explorer .
Se você está planejando trabalhar neste curso independente de qualquer sala de aula Clique duas vezes para abrir a pasta FlappyAssets dentro dela. Selecione
instrução, você supostamente baixou este curso do tudo nesta pasta e copie- os (Ctrl-C).
CRYENGINE marketplace e descompactou todos os ativos do curso, incluindo
7 No Iniciador, clique em Biblioteca > Meus Ativos . Clique na seta
este arquivo PDF. O ZIP irá descompactar uma pasta chamada
ao lado do seu recurso GameSDK e escolha Revelar no Explorer . Você vai
FlappyBoidCourse [version #] contendo o seguinte:
estar em uma pasta chamada gamesdk_5.5 . Abra a pasta GameSDK dentro
• Este livro : FlappyBoid [versão da versão e carta de revisão] .pdf esta. Ctrl-V ( colar ) os ativos Flappy (áudio, materiais, objetos etc.
pastas) para aqui.
• Uma pasta ScreenCaptures com imagens de alta resolução deste
8 Observe a localização desta pasta gamesdk_5.5 .
livro de curso para ajudá-lo a ver como a lógica do jogo é construída
9 No Iniciador, clique em Biblioteca > Meus Projetos . Clique no
• A pasta FlappyFinished , contendo o nível do jogo finalizado , que
Botão de importação . (GameSDK é um projeto completo, não apenas um ativo, então
você pode copiar para sua pasta GameSDK \ levels e fazer referência para ver
ele precisa ser importado como um projeto.) Navegue até o gamesdk_5.5
exatamente como tudo é construído pasta que você já abriu, então para a pasta GameSDK dentro disso.
• Uma pasta FlappyAssets contendo ativos do jogo que precisam ser movidos para Clique em OK para importar seu projeto GameSDK para o Launcher.
sua pasta do projeto CRYENGINE. Antes que você possa fazer isso, você deve
instale o CRYENGINE Launcher, CRYENGINE e o GameSDK Instalando os Ativos e o Nível do Curso
ativo do mercado, como segue:
Por fim, copie o conteúdo da pasta FlappyFinished do curso para o
pasta cryengine_5.5 \ GameSDK \ levels que você já tem aberto.
Instalando o CRYENGINE e o GameSDK
A pasta FlappyFinished contém o jogo final que você irá criar
Este curso requer o CRYENGINE 5.5 com o GameSDK 5.5 . Se você é dentro deste curso, estritamente para fins de referência. Enquanto você pode estudar e
tendo este curso como uma classe ensinada pela Crytek, a equipe pode ter pré-instalado consulte se você tiver perguntas não respondidas, a única maneira de aprender o mecanismo
software e recursos do curso em cada computador do aluno. No entanto, os passos para fazer é realmente construir o jogo passo a passo.
isso no seu computador também é descrito aqui:
Finalmente, clique no projeto GameSDK do Launcher para abri-lo. Uma vez
1. Baixe e instale o CryEngine Lançador livre de aqui por o Editor está aberto, crie um novo nível chamado “FlappyBoid” através de Arquivo >
clicando no botão Download . Note que você precisará criar um New . (Sugerimos manter seus níveis na pasta de níveis.) Aceite o padrão
conta gratuita, se você não tiver um. Se você precisar de ajuda adicional configurações de terreno . A menos que você esteja usando este programa para ensinar uma aula, você pode
Com este passo, consulte o nosso guia de instalação rápida .
pule para o primeiro capítulo do curso.
2. Inicie o Iniciador e entre na sua conta CRYENGINE.
Requisitos de sala de aula para professores
3. No Iniciador, clique em Marketplace > Marketplace . Procurar por
"GameSDK" e adicione o ativo ao seu carrinho.

Este curso requer PCs que atendam ao hardware mínimo do CRYENGINE 5.5 4. Projetar e construir um nível
requisitos com o CRYENGINE 5.5, Game SDK 5.5 e o curso Flappy 5. Use o Editor de Ambiente e as Configurações de Nível para controlar a luz solar,
ativos instalados, conforme detalhado acima. hora do dia, latitude e longitude, nuvens, vento, sombras, global
As capturas de tela Flappy são cópias eletrônicas de alta resolução da tela iluminação e parâmetros oceânicos
tiros publicados neste livro de curso, com a vantagem de que os alunos podem ampliar 6. Use o Level Explorer para gerenciar, congelar, ocultar, renomear, vincular e
neles para ajudar a esclarecer gráficos de fluxo complexos. atribuir entidades a camadas
Para os instrutores Crytek, US Inglês ou Alemão teclado , conforme especificado 7. Controle a posição, movimento, escala e rotação de entidades através de
Gráfico de Fluxo
Um projetor HD conectado ao computador do instrutor. (1920x1080)
8. Posicione e modifique com precisão objetos usando ferramentas de alinhamento e alinhamento
Um grande quadro branco (ou placa de giz) com marcadores multi-coloridas e borracha.
9. Adicione, mova e controle câmeras e suas propriedades; controlar o
Luz no branco / placa de giz, mas não na tela de projeção. visão do jogador
10. Use a física para movimentos realistas; seletivamente desativar física em

Configuração de sala de aula para professores entidades específicas
1. Certifique-se de avisar os alunos com antecedência para levar fones de ouvido , 11. Detectar e reagir a colisões entre entidades
uma caneta ou lápis e marca- texto para fazer anotações no livro de exercícios do curso, 12. Use e acione efeitos de partículas
e um pen drive para que eles possam levar para casa o jogo finalizado. 13. Script e controle de eventos de áudio e ambiente
2. Siga os passos acima para instalar o CRYENGINE Launcher, 14. Mecânica do jogo de script e pontuação usando o Flow Graph
CRYENGINE, GameSDK e os ativos do curso.
15. Use ativos e funcionalidades do GameSDK gratuito (Software
3. Recomendamos que você tenha alunos configurados cVar sys_asserts = 0 e Kit de desenvolvimento)
log_verbosity -1 ou 0 para reduzir alertas em todos os sistemas e para reduzir o
16. Modifique e desative seletivamente a funcionalidade GameSDK
número de perguntas que eles podem produzir.
4. TESTE e certifique-se de que 5.5 esteja funcionando bem em todos os sistemas. 17. Exporte um jogo finalizado para um executável independente e teste-o
18. Use as Variáveis do Console para controlar o Editor e testar ambientes

5. Teste o projetor e os alto-falantes.
6. Distribua as pastas de trabalho pré-impressas do aluno.

Convenções do livro de exercícios do curso
Objetivos de Aprendizagem do Curso Para ajudar você a entender o texto desta pasta de trabalho, usamos as seguintes
convenções de formatação :
Após a conclusão deste curso, os alunos saberão como:
Conceitos importantes são destacados em negrito ou referem-se a algo que você pode fazer
1. Navegue pela interface, editor e conjunto de ferramentas do CRYENGINE
ou clique em : um botão, entidade, item de menu, etc.
2. Trabalhar com entidades, incluindo corpos rígidos, câmeras, pontos de tags AI,
Itens aninhados em menus ou paletas de ferramentas são separados com o cursor circunflexo direito
pincéis e objetos Designer
caractere , por exemplo: Ferramentas > Editor de Nível > Criar Objeto .
3. Criar e editar materiais e texturas

Este curso pressupõe zero conhecimento prévio de CRYENGINE. Te leva Introdução
de uma introdução à interface até terminar um jogo de trabalho. Você
pode trabalhar através do curso completamente por conta própria, ou em um CRYENGINE Bem-vindo ao curso do CRYENGINE Flappy Boid!
classe com o benefício de um instrutor. Vamos aprender os conceitos básicos da CRYENGINE construindo um “boit flappy” -
O jogo terminou e ativos necessários pode ser baixado gratuitamente da carga de jogo de estilo. Enquanto nós sabemos que todos vocês estão ansiosos para aprender como construir o próximo
o CRYENGINE Marketplace. Crysis com enormes níveis foto-realistas, explosões, helicópteros, legiões de
guerreiros e todas essas coisas divertidas, você tem que andar antes de poder correr. este
O curso é dividido em vários capítulos, cada um começando com um
curso introdutório irá cobrir uma grande quantidade de terreno em poucos dias, eo
título como este:
conceitos e ferramentas que você aprenderá servirão de base para cada jogo que você
já construiu em CRYENGINE.
Flappy 02: Configurando a Lógica Inicial
Pré-requisitos
Cada passo importante dentro de um capítulo começa com um cabeçalho neste formato:
Se você não tem experiência com o CRYENGINE, por favor, dedique alguns minutos para
Título do Tópico
leia nosso Designer Quick Start antes de começar este curso. Ele irá apresentar-lhe
Os conceitos e objetivos são explicados primeiro, seguidos pelo passo a passo às noções básicas da interface do Editor, navegação, as ferramentas e criação de um nível -
instruções para alcançá-los. Além disso, cada um dos principais capítulos em tópicos que você precisará entender antes de começar este curso.
este livro foi incluído neste projeto CRYENGINE como um nível separado Caso contrário, este curso pressupõe zero conhecimento prévio do desenvolvimento do jogo ou
que inclui o trabalho finalizado até o final desse capítulo. Por exemplo, o motores de jogo. Você precisará estar confortável navegando pelo Windows
O nível Flappy01 mostrará como seu jogo deve ficar depois de terminar o sistema operacional, File Explorer e usando o mouse. Monitores duplos são
passos no Capítulo I. útil no desenvolvimento de jogos (muitos desenvolvedores usam três monitores)
Dicas sobre o melhor práticas parecem número de ferramentas utilizadas, mas certamente não é necessário.
esta:
Dica Pro :
Fluxogramas podem rapidamente ficar muito
grande, mantendo-os limpos e
bem organizado é primordial. UMA

técnica simples é minimizar
cada nó clicando na seta em
canto superior direito.

01: Construindo os Ativos, Visualização e Funcionalidade Básica Além do jogador ver um visível
"Pássaro" aparentemente se movendo através
obstáculos, ele precisa responder ao salto
Brainstorm ideias de design “Flappy Boid” Dica Pro: Massa vs. Densidade
ação, movendo-se para cima. Por isso
movimento para parecer realista, precisa ser Enquanto você pode usar massa ou
Dê uma olhada neste vídeo do jogo finalizado em ação. Como você densidade para definir um objeto de
uma entidade “materializada” que responderá
projetá-lo em um ambiente 3D? Qual é o mais simples, mais eficiente e elegante Peso, densidade é melhor usado para
para a física do mundo real . Um fisicamente
caminho para ser construído? objetos que devem flutuar . Você
objeto de alguma massa com precisão nunca deve definir ambos para positivo
O que precisa realmente se mover ? responder à força da gravidade que é valores; o motor simplesmente
priorizar Mass. Se você especificar apenas
Como muitos tubos que precisamos? já presente dentro do motor, que
densidade, massa será computada como
simula forças do mundo real . densidade vezes o proxy da física
Tire algum tempo para delinear seu Documento de Design de Jogo no papel. Mesmo se o
volume . Veja esta documentação.
design de jogo deste curso não prova exatamente o mesmo, pensando Adicionando um RigidBodyEx Player
sobre os desafios e como resolvê-los é uma parte necessária do jogo
desenvolvimento. Quando estiver pronto, abra seu novo jogo FlappyBoid do Objeto
Lançador.
1 No Editor, use a ferramenta Criar Objeto para adicionar um Legacy > Physics >
Entidade RigidBodyEx ao seu nível. (Você pode clicar duas vezes no
Vendo a configuração padrão do GameSDK Entidade RigidBodyEx na ferramenta Criar objeto e, em seguida, clique no
terreno para criá-lo ou arrastar o objeto para o terreno.) Por padrão,
Antes de começarmos a desenhar o nosso jogo, é útil saber o que
a menos que você tenha outra entidade sobre a qual você pode passar com o seu
GameSDK deu a você. GameSDK é baseado no Crysis, um jogo de tiro em primeira pessoa
mouse, ele vai encaixar no terreno a 32m Z. (a altura padrão do terreno)
jogos. Pressione Ctrl-G agora para entrar no modo de jogo. Você vai ver imediatamente
suas mãos com uma arma na sua frente. Você pode se movimentar com o padrão 2 Use a janela Propriedades> Geral para renomear sua entidade
3ª. "FlappyBoid"
Teclas WASD, atire na arma (clique com o botão esquerdo do mouse em um PC) e mude para a
vista da pessoa, pressionando F1, entre outras coisas. 3 Posicione sua entidade ( Properties > Transform ) em 500, 500, 100 . 100
Z será o ponto central vertical do nosso jogo aéreo.
É importante entender que o GameSDK oferece toda essa funcionalidade
e muito mais por padrão, porque uma das primeiras tarefas que temos para 4 Role para baixo na janela Propriedades e certifique-se de que Físico é
realizar é esconder e desativar este personagem de tiro em primeira pessoa, dado que verificado e Descansar está desmarcado . Defina a massa da ave para 10 . o
nosso jogo Flappy Boid é totalmente diferente. Pressione ESC para sair do modo de jogo massa versus a quantidade de força ascendente que vamos aplicar
e retorne ao Editor. determinar toda a "sensação" do nosso jogo. (Nós não estaremos mudando o
força de gravidade padrão que puxa o pássaro para baixo.) Observe que o
Adicionando uma Entidade de Player Simples a massa padrão de -1 diz ao mecanismo para fazer um objeto “dormir” -
Imóvel pelas forças da física, como a gravidade.
Enquanto estamos finalmente indo para criar uma entidade de jogador semelhante a um pássaro com movimento A geometria padrão para um RigidBodyEx é uma esfera . Dadas as complexidades
asas, vamos começar com uma esfera geométrica simples como o nosso jogador para de animação, isso é útil neste curso introdutório, como podemos nos concentrar
Mantenha as coisas simples. na lógica do jogo por agora, e substitua a esfera por um pássaro animado depois.
CRYENGINE Flappy Boid Course Ver. 5.5D -6- 01: Construindo os Ativos, Visualização e Funcionalidade Básica
Propriedades e Estratégias Físicas começa a reagir às forças da física. Não se esqueça de atribuir uma massa para
qualquer coisa que você queira se comportar de maneira realista; o valor padrão -1 não é massa.
Algumas notas sobre algumas propriedades-chave do tipo de entidade RigidBodyEx:
RigidBodyEx é uma “entidade legada” - é específica do GameSDK. Tem tantos

Usando um ponto de marcação AI para gerar scripts de gráfico de fluxo
propriedades que você poderia considerá-lo como um tipo de "super" entidade, com mais
Toda a nossa lógica de jogo neste jogo será realizada usando
propriedades que você precisará para muitos tipos de entidade, como uma tabela ou uma rocha.
Gráfico de Fluxo . O Flow Graph é uma ferramenta de script visual baseada em nó que você obterá
Essas entidades herdadas estão em processo de serem substituídas pela nova Entidade para conhecer bem! Isso nos permite programar nossa mecânica de jogo, comportamento, etc.
Sistema de componentes. Se você observar o tipo de objeto Componente no Create
Enquanto você pode ter módulos do Flow Graph que não estão ligados a nada,
Ferramenta de objetos, você notará componentes mais simples que o RigidBodyEx
Neste caso, a melhor abordagem é anexar a nossa lógica de controle do jogador a algo
porque eles são destinados a propósitos mais específicos do que o RigidBodyEx.
tangível e visível no nível que é dedicado a esse propósito
Como designer de jogos 3D foto-realistas, você precisa ser muito estratégico
Vamos abrigar toda a nossa funcionalidade principal do Flow Graph em uma entidade simples
as características que você atribui às suas entidades de jogo e as demandas que eles colocam
chamado de um ponto de tag AI . Os Pontos do Tag AI são visíveis para você, o designer, mas
no poder de computação. Permitir a física é um dos aspectos mais exigentes
invisível para o jogador.
desta estratégia.
1. Na ferramenta Criar objeto , escolha AI > Ponto de tag e arraste o
Ao adicionar entidades a um nível, considere o seguinte:
meia esfera procurando objeto no nível. Sugerimos posicioná- lo
• Será permitido ao jogador entrar fisicamente em contato com essa entidade? razoavelmente perto do seu objeto FlappyBoid na mesma altura: 100m .
Lembre-se, é invisível para o jogador, então qualquer lugar é bom contanto que
• Outras entidades colidirão com isso? (Entidades não-físicas irão
não torna difícil ver outros objetos, e não é tão longe do
permitir que outras pessoas passem por elas de maneira irreal.)
área de jogo que ver e selecionar é difícil.
• A entidade precisará ser modificada durante o jogo, para mostrar OBSERVAÇÃO : Se você não vir seu AI TagPoint, verifique se os Helpers estão ativados
danificar? on: clique no botão H no canto superior direito da janela de exibição Perspective .
Entidades próximas à câmera terão uma caixa acima delas e entidades invisíveis
• A entidade irá se mudar? O que vai forçá-lo a se mover?
para o jogador terá contornos ou formulários no Editor.
• A entidade precisa ser afetada por forças físicas como a gravidade,
2 Defina Propriedades > Geral > Nome do objeto TagPoint como
vento, chuva, oceano, etc?
" FG_Main ." (Estamos usando o "FG" para abreviar o Flow Graph.)
Uma estratégia básica para otimizar o desempenho do jogo é apenas fisicalizar entidades seus objetos nomes significativos que descrevem sua função real em
quando e se eles precisam ser afetados pela física. Por exemplo, se você quiser o jogo ajuda você a acompanhar a longa e complexa hierarquia de
jogador para ser capaz de pegar uma pedra e jogá-lo, não há necessidade de a rocha objetos que compõem qualquer jogo.
ter a física ativada até o momento em que o jogador tenta buscá-la, se é que alguma vez . No 3 No objeto Propriedades > Fluxo Graph , clique em Abrir e chamar seu
Nesse momento de contato, o objeto pode ser fisicalizado, mas se o jogador nunca novo fluxograma "Flappy".
toca, a rocha não desperdiçará recursos do sistema.
4 A ferramenta Flow Graph aparecerá se você ainda não a tiver aberto.
Com relação à entidade RigidBodyEx, a propriedade Physicalize ativa NOTA: se o módulo Entidades > Flappy > FG_Main não aparecer,
física na entidade, e a propriedade Resting determina quando o objeto feche a ferramenta Flow Graph e reabra- a para forçar a árvore de nós a
Atualizar: Ferramentas > Fluxograma .
Existem nós que executam funções matemáticas que afetam o
aparência ou posição ou movimento de entidades, reproduzir sons, fazer chover e
que faz praticamente tudo que o CRYENGINE pode fazer. Uma boa maneira de
entender o que um nó faz para passar o mouse sobre suas entradas e saídas
e leia as dicas de ferramentas que aparecem.
Você pode editar os valores das portas na janela Propriedades ou simplesmente dobrar
clique em uma porta para editar seu valor:
2 Clique duas vezes na porta de entrada Message do seu DisplayMessage

nó e digite "Olá, mundo!" ou o que te diverte. Este nó
faz exatamente o que diz - exibe uma mensagem na tela, mas nada
vai acontecer até que receba um sinal da entrada Show . Essa é a
gatilho que faz esse nó agir. Nem todos os nós precisam ser
desencadeada, como você verá; alguns estão sempre trabalhando em segundo plano.
Visão geral do gráfico de fluxo 3 Vamos fazer a nossa mensagem aparecer quando o jogo começar : encontre o jogo
pasta em Nós e arraste o nó Iniciar para o gráfico à esquerda do
Vamos dar uma olhada na ferramenta Flow Graph por um momento: você notará que ela
seu nó DisplayMessage.
seu próprio menu, barra de ferramentas e paletas de ferramentas à esquerda e à direita. Alguns dos
4 Vamos começar o nosso primeiro bit de lógica: arraste a porta de saída do
os gráficos que você criar aumentarão bastante e serão complexos, por isso é útil
Jogo: Inicie o nó na porta de entrada Mostrar da DisplayMessage
maximize sua janela do Flow Graph.
nó. Uma linha de conexão e uma seta aparecerão indicando o caminho
Os nós estão listados à esquerda sob uma longa lista de categorias . Os tipos e o sinal fluirá. Em linguagem simples, quando o jogo começa, um
locais para gráficos são listados na janela Gráficos . Você notará que seu mensagem será exibida.
FG_Main AITagPoint entidade abriga uma pasta chamada Flappy e seu primeiro
5 Por fim, vamos configurar a aparência da nossa mensagem : selecione o seu
gráfico , FG_main.
Nó DisplayMessage . Faça o tamanho da fonte 10, o PosX (horizontal
O primeiro exercício consagrado pelo tempo para qualquer nova linguagem de programação é posição) 960, PosY (posio vertical) 400, e o clique Centrado
exibir uma mensagem simples "hello, world". Vamos fazer isso para nos apresentar como propriedade para ativar a centralização de texto em torno da posição PosX.
Trabalhos do Fluxo Gráfico: 6 Antes de testarmos nossa primeira lógica de jogo, queremos entrar no
hábito de salvar o nosso jogo de cada vez antes de testar - Ctrl-S . É sempre
1. Na janela Nodes , localize a categoria Debug . Clique no sinal + para
abra-o e arraste o nó DisplayMessage para o seu gráfico. uma boa prática para salvar seu nível com Ctrl-S antes de mudar para
modo de jogo. Entrando no modo de jogo permite a física e AI
Por padrão, seu nó recém-adicionado é selecionado (indicado por uma borda azul ),
sistemas, que adicionam uma grande complexidade que é mais provável
e suas propriedades são exibidas na janela Propriedades à direita. Abaixo disso é
trave o motor do que o editor.
informações básicas sobre o próprio nó. Os nós têm portas de entrada à esquerda
7 Certifique-se de que sua câmera não esteja mais do que dois metros acima
e portas de saída à direita. Eles recebem sinais das entradas ou você
terreno (ou então seu personagem vai cair na superfície e morrer!) e
pode atribuir valores diretamente a essas entradas e enviar sinais para as saídas.
pressione Ctrl-G para pular para o modo de jogo. Você vai ver o atirador
personagem, mas também deve ver uma grande mensagem “Hello, world!” no apenas outra entidade. O jogo não é
tela. atribuir qualquer comportamento padrão ao nosso
esfera, nem pensa nisso como Dica Pro :
Mais algumas dicas rápidas: use a roda de rolagem do mouse para ampliar e
Embora a tecla de barra de espaço no
em um gráfico. Movimente-se com o botão direito do mouse. (O gráfico é virtualmente jogador. Temos que programar o seu
Plataforma PC faz o jogador
infinita) Agora que terminamos de testar, arraste o mouse em torno de ambos os nós para funcionalidade manualmente. saltar para o ar, não há
barra de espaços em plataformas de console; Está
selecione- os e pressione delete para removê-los.
Respondendo ao salto um botão diferente por completo. assim
em vez de ouvir o
Primeiro Mecânico de Jogo: a Ação de Salto Açao chave da barra de espaço especificamente, queremos
para responder à ação "pular"
O controle do jogador neste jogo é muito simples: cada vez que o "salto" ação Estamos prontos para ligar para o nosso motor de física (acionado pelo console específico
é acionado ( barra de espaço em uma plataforma de PC), nosso pássaro precisa pular para cima para realmente realizar o salto! botão ).
contra a força descendente constante da gravidade:
1 Nos nós do Flow Graph
1 Adicione um nó Entrada > ActionMaps > ActionListener ao gráfico. janela, arraste o
2 Adicione um ator : nó LocalPlayer ao gráfico. LocalPlayer é o Física : Nó ActionImpulse no lado direito do seu gráfico.
Entidade de jogador embutida no jogo. Cada entidade tem um único, interno 2 Selecione sua entidade FlappyBoid na Perspectiva Perspectiva.
ID numérica (um inteiro).
3 Clique com o botão direito no seu nó ActionImpulse e escolha Atribuir
3 Vamos dizer ao ActionListener qual entidade ouvir: arraste o ID da entidade Entidade Selecionada para forçar o nó a afetar a entidade da esfera.
porta de saída do nó LocalPlayer para a porta de entrada Escolher Entidade
4 Conecte a saída pressionada do nó ActionListener ao
do nó ActionListener . A entrada "Escolher Entidade" agora está marcada
Ativar entrada do nó ActionImpulse . Isso significa que o "salto"
“<Entidade de Entrada>.”
ação (tecla de barra de espaço na plataforma do PC) agora
4 Clique no seu nó ActionListener para ativá -lo. ação que estamos prestes a atribuir.
5 Na janela Propriedades do Flux Graph , clique na caixa de valor para 5 Selecione o nó ActionImpulse e defina o eixo Z de seu Impulse
o direito de Ação . O botão .. será exibido. Clique nele e escolha parâmetro para 80 assim que a ação de salto vai empurrar o pássaro para cima. Dentro
o jogador > pula ação. Clique OK . termos de quão grande esta força deve ser, é apenas uma questão de
6 Vamos permitir que esta ação de escuta comece quando o jogo começar: experimentação, e também é uma decisão criativa significativa que tem um
clique com o botão direito na tela do Flow Graph e escolha Add Start Node . grande efeito na "sensação" do seu jogo. Quanto menor a força, mais
Como o nó Game: Start é usado com tanta freqüência, este é apenas um atalho muitas vezes o jogador terá que tocar na tecla de salto, e quanto mais controle
para adicioná-lo rapidamente. eles têm. O maior a força, os menos frequentemente as principais necessidades salto para
ser pressionado - mas o mais forte e menos controlado a reação será.
7 Arraste o nó Saída do jogo : Iniciar para a entrada Ativar do
Nó ActionListener . 6 Um aprimoramento opcional para a ilusão de movimento para frente seria
para girar a nossa bola no sentido horário, (embora isso não faria sentido para um
O jogador padrão (o personagem de tiro em primeira pessoa) recebe o "salto"
pássaro). Para fazer isso, adicione um impulso angular de -.3 no eixo Y.
comando. O ID da entidade do jogador é agora o que o nó ActionListener é
escutando. Agora só temos que responder a esse sinal fazendo nosso "pássaro" Vamos nos colocar em uma posição onde podemos ver se o nosso "pássaro" está respondendo
Pule. Note que a nossa entidade de aves NÃO é o jogador padrão; para o motor, é para o salto. No menu principal, escolha Nível > Ir para posição e digite
coordenadas de 515, 500, 34 e uma rotação Z de 90⁰. Você deveria estar sentado em alguma diversão atirando na esfera e fazendo-a rolar para longe se você quiser.
nível dos olhos no terreno com a sombra do jogador à sua frente.
Antes de prosseguirmos, vamos criar uma documentação rápida em nosso
Vamos testar! Salve primeiro e depois Ctrl-G para alternar para o modo de jogo. Fluxograma para facilitar a compreensão de outros desenvolvedores - agora
nos mencionamos enquanto tentamos depurar jogos complexos mais tarde! Completo
Até agora, a configuração de tiro em primeira pessoa ainda está controlando onde o nosso jogador está
documentação é uma prática recomendada essencial ao desenvolver jogos ou qualquer
inicialmente gerada (onde quer que a câmera esteja quando começamos o jogo,
Programas.
mas forçado pela gravidade até o terreno, se já não estiver nele), e a visão que nós
veja, que é sempre da cabeça do jogador, olhando para as mãos (ou Clique com o botão direito do mouse no seu gráfico e adicione uma caixa de comentários chamada “CONFIGURAÇÃO
rd INICIAL”.
Redimensione -o de modo a envolver os nós que criamos até agora.
ligeiramente atrás dele, se você usar F1 para mudar para 3 perspectiva pessoa).
Se você rapidamente usar o botão direito do mouse para olhar para cima , você verá nosso pássaro Clique com o botão direito do mouse e adicione um simples comentário chamado "mover Flappy para cima".
esfera caindo para o terreno. Depois que ele cai no chão, pressione a barra de espaço Posicione-o sobre o nó ActionImpulse .
chave. Você, o jogador, vai pular - mas também o seu "pássaro"! Você pode ter
Através dessas anotações simples, começamos a criar uma auto-documentação
CRYENGINE Flappy Boid Course Ver. 5.5D - 10 - 01: Construindo os Ativos, Visualização e Funcionalidade Básica
jogos! 525 X, 500 Y, 32 Z. Nosso jogo será construído a 100m no ar (68m
acima do terreno), então nunca vamos ver este jogador.
Como sempre, consulte a captura de tela em seus materiais Flappy ou imprima aqui para
veja como deve ficar o seu Gráfico de Fluxo. Você pode achar mais fácil Por que 32 no eixo Z? 32m é a altura padrão do terreno, então fica
entender olhando para uma foto do que lendo as etapas escritas. (O um pouco acima do oceano a 16m (permitindo-lhe esculpir vales acima do
O gráfico de fluxo de configuração inicial concluído para este capítulo é impresso no final do linha d'água, por exemplo). Se colocarmos nosso jogador no ar com nossos outros
capítulo.) entidades, a primeira coisa que vai acontecer no início do jogo é que a gravidade vai enviá-lo
caindo no chão, onde ele vai "morrer", agitando a câmera no
Modificando a funcionalidade do SDK do jogo processo. Colocá-lo a 32m garante que aguarda em silêncio!
2. Apenas para manter as coisas claras, renomeie seu objeto Spawn Point
Você deve ter notado que o CRYENGINE
"SpawnPoint_Player"
O iniciador solicita que você escolha um modelo .
Dica Pro : Nós vamos usar o nosso SpawnPoint_Player como um ponto de referência no espaço 3D onde nós
Entre eles estão os jogos de tiro em primeira pessoa (ou seja,
Existem várias maneiras de adicionar
GameSDK), scroller lateral, rolando bola, terceiro pode forçar o atirador na primeira pessoa a aparecer no início do jogo, com segurança fora de vista:
nós para o Fluxograma: a partir do
pessoa, isométrica, etc. Janela de nós; clicando com o botão direito e 3. Verifique se o seu SpawnPoint_Player está selecionado e, em seguida , clique com o botão direito em
escolhendo Adicionar ; e pressionando o botão
A única diferença entre esses modelos é a área do gráfico da sua ferramenta Flow Graph e escolha Adicionar selecionados
Tecla Q e digitando o nome do nó.
Entidade . Um nó denominado entity: SpawnPoint é exibido. Isso ilustra um
a funcionalidade fornecida com o modelo O último caminho é mais rápido, mas você
já deve saber o que você está importante conceito de Fluxograma: você pode adicionar entidades como nós diretamente
que controla a posição padrão e
procurando, tornando-se um perito para um gráfico! As entradas e saídas dos nós da entidade se sobrepõem a outras
perspectiva do jogador. O motor em si
ferramenta. Nós do Flux Graph, mas às vezes essa é a escolha certa.
continua o mesmo.
4. Vamos forçar o jogador a desovar (comece a sua existência) no
Nosso jogo foi criado usando o CRYENGINE
SpawnPoint_Player toda vez que o jogo começa : arraste a partir do
Game SDK , que contém ativos e funcionalidades do CRYSIS 2, um primeiro
Saída do Jogo: Comece nó para o spawn de entrada de Spawn
jogo de tiro em pessoa . Enquanto nós precisamos de alguns jogos do SDK
Nó de ponto.
funcionalidade, nós realmente precisamos eliminar o atirador de primeira pessoa HUD
5. Vamos começar a ouvir a tecla de salto (ouvida pelo jogador) assim que
(heads-up display, como computação gráfica sobre munição e saúde
como o jogador gerou: arraste a saída Spawn do SpawnPoint
sobreposta dentro de um capacete) e câmera em nosso jogo.
nó para a entrada Ativar do nó ActionListener .
Nós vamos fazer isso através da criação de um ponto de desova onde podemos esconder o padrão
Antes de testarmos o que construímos, torne a sua posição na câmera algo diferente
jogador, porque vamos controlar a visão do jogador com uma câmera que
do que onde está o ponto de desova.
é dissociado da entidade do jogador. Um ponto de desova é simplesmente um lugar onde
você pode inicialmente posicionar seu player quando um nível é carregado. No caso de querermos usar isso como nosso ponto de partida de teste novamente, vamos salvar este
localização para que possamos voltar facilmente: no menu , escolha Exibir>
Escondendo o jogador de tiro e o HUD Localização> Lembrar Localização> Lembrar Localização 1 . Note que estes
locais salvos existem apenas dentro do Editor , não dentro do jogo
1. Na ferramenta Criar objeto , escolha Entidades herdadas > Outros e meio Ambiente. Para voltar aqui no futuro, pressione Ctrl-F1 . Você pode salvar
clique duas vezes em SpawnPoint . Coloque seu ponto de origem man-in-a-box em locais para todas as 12 teclas de função.
Salve e teste. Você notará que ainda vemos as mãos e a arma do FPS 1. Na ferramenta Criar objeto , clique em Misc > Câmera .
jogador, mas aviso onde são : o jogador começa exatamente onde nós colocamos a nossa 2. Clique no Perspective Viewport para adicionar sua nova câmera. Posicione
Spawn Point! É isso que nossa lógica do Fluxograma realizou. Nós temos em 482, 523 , 100 .
controlou com sucesso a posição do jogador no jogo.
3. Defina sua rotação Z para 180, de forma que esteja apontada para FlappyBoid.
Note que com o template GameSDK, você também pode pressionar F1 para alternar
4. Renomeie o objeto da câmera “ FlappyCam ”.
entre a perspectiva da primeira e da terceira pessoa.
Se você está curioso sobre o que esta câmera está vendo, você pode clicar no
Observe também que quando você ESC sai do modo de jogo, todas as suas entidades são Botão da câmera no canto superior esquerdo da janela de visualização e clique em
exatamente onde você os deixou. na Entidade da Câmera> FlappyCam . Você agora vê o que sua FlappyCam vê!
Tenha em mente que você ainda controla o tamanho e a forma da sua viewport, que
Impedindo o jogador de tiro de andar afeta o seu campo de visão, enquanto a janela do jogador será finalmente
fixo. Assim, esta não é uma visão exata. Experimente F11 - visualização em tela cheia.
1. Em seguida, vamos parar o jogador não utilizado de andar por aí. Adicione uma entrada
> ActionMaps> ActionFilter node para seu fluxograma. Você poderia usar as viewports 2D para ajustar a posição da câmera enquanto
vendo o resultado, mas por enquanto vamos voltar para a câmera padrão por
2 Clique para certificar-se de que o nó ActionFilter esteja selecionado.
clicando em Câmera> Padrão .
3 Na janela Propriedades do Flux Graph , você verá o nó selecionado
Entradas na parte superior e abaixo dela, Filtro destacado em azul. Clique em
Definindo uma câmera padrão
o botão .. à direita do botão azul Filter.
4 Na lista de ActionFilters que aparecem, escolha no_move e Precisamos dizer ao jogo para definir
Clique OK. FlappyCam como a visão do jogador quando
o jogo lança:
5 Conecte a porta de saída do Spawn da entidade : nó SpawnPoint ao
Ative a porta de entrada do modo ActionMaps. 1 No Fluxograma, adicione uma câmera
Vamos testar para ver o que isso conseguiu. Vamos também ativar o Fluxograma > Visualizar o nó na tela.
depuração para que possamos ver o que o Flow Graph está fazendo: escolha Depurar> 2 Na janela de perspectiva,
Ative a Depuração (ou clique no ícone do bug). Salve e pressione Ctrl-G para entrar clique no seu FlappyCam para
modo de jogo. Você notará que, embora você, enquanto o jogador ainda pode olhar ao redor, selecione -o.
o jogador não pode se mover. (WASD não move mais o player.) No Flow 3 Clique com o botão direito no seu
Nós do gráfico, você verá as ações sendo executadas em amarelo . Câmera : Exibir gráfico de fluxo
Agora só precisamos criar uma câmera apontada para o nosso "pássaro" para substituir o nó e escolha Atribuir
Entidade Selecionada para atribuir o
perspectiva de tiro em primeira pessoa não utilizada.
FlappyCam para este nó.
Adicionando uma Câmera 4 Arraste da porta de saída de

o jogo: inicie o nó para o
Estamos essencialmente construindo um jogo de estilo side scroller com um fixo, restrito Ativar porta de entrada do seu
Câmera. Vamos adicionar essa câmera: Câmera: Visualizar nó. Seu
A câmera agora está ativada como a visão do jogador no início do jogo. Entendendo os tipos de dados do gráfico de fluxo
Vamos testar! Ctrl-S para salvar e Ctrl-G para entrar no modo de jogo.
Você deve ter notado que as entradas e saídas dos nós do Flux Graph têm um
Voila, vemos imediatamente a visão do FlappyCam do seu player variedade de cores . Essas cores indicam o tipo de dados , da seguinte maneira:
O terreno!
Verde qualquer tipo de dados
Em seguida, vamos remover as miras que ainda estão atrasadas do FPS
Vermelho inteiro
funcionalidade. As miras fazem parte do HUD (Heads Up Display). Está
a visibilidade é controlada por meio de uma variável do console (normalmente chamada de cVar). Azul Booleano (verdadeiro / falso ou 0/1)
Branco número de ponto flutuante

Escondendo a mira da arma do FPS
Ciano corda
1 Na janela Nodes do Flow Graph, arraste um Debug : ConsoleVariable
nó no seu gráfico. Amarelo Vec3 (coordenada tridimensional)
2 Na janela Propriedades do Flux Graph , defina o C Var (Console Um dos aspectos do Flow Graph que facilita o uso de um
Variável) para hud_hide e o valor para 1 (verdadeiro).
3 Ligue a saída da porta do Jogo: Comece nó ao conjunto de entrada

porta do nó de depuração .
Visualizando Física e Sistemas AI
Uma última dica de desenvolvimento de jogos : os sistemas de física e IA são complexos e

exigente em recursos de computador. Se eles estivessem sempre habilitados enquanto você
estavam usando o Editor, qualquer entidade que você adicionasse ao sandbox imediatamente
comece a ser afetado por todas as forças físicas que estão ativadas por padrão: gravidade,
a linguagem de programação é que ela lida com conversões de tipo de dados sem problemas;
vento, ondas do oceano, etc. Assim, ambos os sistemas são mantidos fora quando você está projetando
você geralmente não precisa se preocupar com a conversão e os tipos de dados correspondentes.
no editor.
Qualquer sinal pode acionar um nó de entrada .
Sempre que você quiser ver como a física e a IA afetarão suas entidades
sem realmente mudar para o modo de jogo, você pode pressionar Ctrl-P para ativar No entanto, há momentos em que você pode precisar levar o tipo de dados
ambos os sistemas. Ao lado desse botão na barra de ferramentas, você também tem botões para consideração. Um exemplo comum é o tipo Vec3 (amarelo), que na verdade
através do jogo um quadro de cada vez, e para parar a física e AI consiste em três números de ponto flutuante: X, Y e Z, que coletivamente
simulação. Uma vantagem dessas ferramentas é que você ainda pode ver entidades que descreve a posição 3D. Se você precisar extrair um desses valores, precisará
são invisíveis no modo de reprodução - muito útil para depuração. use um nó FromVec3 , que divide os dados do Vec3 em três valores separados,
como mostrado aqui. Nós vamos fazer exatamente isso mais tarde no curso.
02: Configurando a lógica inicial quando absolutamente necessário. Ping na CPU com centenas de
solicitações complexas para respostas instantâneas arriscam
o computador e criar um desempenho lento. Dentro
Fazendo a câmera seguir o player
hora do computador, há uma grande diferença entre o NOW e
Já que estamos planejando apenas permitir que nosso pássaro pule e caia (não 1/100 de segundo a partir de agora!
mover nos eixos X ou Y), presumivelmente poderíamos apenas definir nossa câmera inicial Lembre-se, nós queremos que o FlappyCam siga o FlappyBoid em um número suficiente
posição para ver o pássaro e tubos suficientes que o jogador pode evitá-los, e distância para poder vê- lo (bem como o primeiro par de tubo que se aproxima
ser feito com isso. No entanto, há um problema em potencial: e se o jogador pular
obstáculos). Enquanto nós poderíamos alimentar o Pos (posição) do FlappyBoid diretamente
tão alto ou desce tão baixo que eles vão para fora de vista de nossa câmera? para o movimento de FlappyCam : nó MoveEntityTo , que posicionará o
Uma abordagem opcional é forçar nossa câmera a seguir nosso player enquanto ele se move câmera exatamente onde o pássaro em si é - e não seremos capazes de ver o pássaro!
para cima e para baixo. Até certo ponto, isso é uma questão de preferência pessoal, Em vez disso, precisamos compensar a posição da câmera a partir da posição da ave:
embora cada abordagem introduza suas próprias complexidades. 6. Adicione uma Vec3 : SubVec3 nó. Este nó simplesmente nos permite passar o
Por agora, vamos fazer a câmera siga o jogador simplesmente compensar o entrada posicional de A compensada pelos valores que colocamos em B.
Posição da câmara FlappyCam em relação à posição actual do 7. Defina os valores B do nó SubVec3 (o deslocamento) como 10, -20,0. Isso vai
Entidade FlappyBoid: coloque a câmera um pouco para trás e para a direita do pássaro para que haja
espaço para ver os obstáculos de tubulação que iremos adicionar mais tarde.
1 Abaixo da seção INITIAL SETUP do seu Flow Graph, vamos adicionar um
Entidade : EntityPos (posição) nó. Atribuir a entidade FlappyBoid para 8. Arraste a saída Pos do nó EntityPos para a entrada A do
este nó. Isto irá consultar posição 3D atual do FlappyBoid cada Nó SubVec3 . Arraste o nó Out of the SubVec3 para o destino
quadro do jogo. e Iniciar entradas do nó MoveEntityTo.
2 Adicione um nó Movimento : MoveEntityTo . Isso nos permite aproveitar Vamos testar ! Ctrl-S, Ctrl-G. Você pode sentir que a câmera segue o pássaro também
controle sobre a posição de uma entidade e movê-lo para lá de um determinado fielmente, que a câmera sacode muito rapidamente. Tente ajustar o valor (resposta
período de tempo ou a uma velocidade fixa . Observe que o MoveEntityTo é somente tempo) do MoveEntityTo para 0,5 segundos. Teste e você pode sentir que o
apropriado para entidades que não estão sendo afetadas pela física - ou seja, o movimento da câmera é mais natural e suave.
que não têm massa (-1). Caso contrário, as forças da física vão "lutar"
Coloque uma caixa de comentários em torno desta seção do seu Flux Graph e chame-a
com a força bruta do MoveEntityTo.
algo como Camera Follows Player .
3 Atribua a entidade FlappyCam ao nó Movement : MoveEntityTo .
4 Certifique-se de que o Coord Sys (sistema de coordenadas) do

Movimento : o nó MoveEntityTo está definido como Pai . É importante lembrar aqui que este jogo acontece em
5 Altere o parâmetro Value Type para time e defina seu Value para 0,01 . o céu - nós vamos estar escondendo o terreno, então haverá
Isso efetivamente fará com que a câmera se reposicione tão rapidamente nenhum ponto visual de referência para indicar que alguma coisa está se movendo
em relação ao jogador que parecerá ser instantâneo. exceto as bordas da visão da câmera.
Por que não um tempo zero para o nosso MoveEntityTo ? Considerando a

Adicionando uma textura à esfera
demandas massivas de jogos 3D em tempo real em CPUs, você quer
ter cuidado ao pedir respostas instantâneas, exceto
CRYENGINE Flappy Boid Course Ver. 5.5D - 16 - 02: Configurando a lógica inicial
O único problema é que agora temos uma esfera simples sem textura , então
mesmo que a esfera esteja girando, não poderemos ver ! Vamos adicionar um
textura da superfície para tornar a fiação visível.
1. Clique na sua esfera FlappyBoid para selecioná- la.

2 Na janela Propriedades , clique no ícone da pasta à direita do
Propriedade material .
3 Encontre uma textura interessante e claramente visível em um dos materiais

pastas. Nós usamos wood_beams_a_red do GameSDK>
materiais> genéricos> pasta de madeira em nossas capturas de tela.
CRYENGINE Flappy Boid Course Ver. 5.5D - 17 - 02: Configurando a lógica inicial
03: Adicionando os Obstáculos da Tubulação transformações aplicadas a ele - como você viu quando praticamos a adição de pedregulhos
para o nosso terreno (parte deles foi colocado "underground")
Considerações sobre design de jogos Vamos dar uma olhada na parte do tubo que está se escondendo sob a superfície do
terreno.
Nosso pássaro está voando e voando, mas isso não será muito um jogo até que
1 Primeiro, certifique-se de que as colisões entre a câmera e o terreno estão desativadas (clique no botão
ave alguns obstáculos para navegar. Esquivá-los resultará em pontos ; colidindo
Menu da câmera no canto superior esquerdo da janela de exibição Perspective
com eles significa morte instantânea !
desmarque- o).
Outro aspecto a considerar é que este é um tipo de jogo de “rolagem infinita” - como
2 Clique e arraste o botão do meio do mouse para baixo até voar abaixo
Enquanto o jogador vive, continua a marcar incessantemente pontos; Não há fim O terreno. Você pode querer diminuir o zoom para ver toda a extensão do tubo
para este jogo. No entanto, como a maioria dos jogos, nós no oceano.
quero que os desafios se intensifiquem. Então, mais tarde, nós vamos
3 Neste ponto, podemos também esconder o terreno , já que este é um "aéreo"
adicionar aceleração à velocidade dos tubos como
Dica Pro : jogo que não requer um plano de terra. Clique no display azul
a pontuação do jogador aumenta.
Se um objeto alguma vez desaparecer botão no canto superior direito da janela de exibição Perspective , role para
vista, uma maneira fácil de encontrar é Tipos de renderização e desmarque o terreno .
Adicionando os Tubos selecione seu Viewport Perspectivo
e pressione a tecla G para mover o 4 Se você inclinar sua câmera e olhar para baixo, você verá agora o oceano que
Usaremos outra entidade do Corpo Rígido para o câmera para ele. (Ou Nível > Ir para estava escondido em seu terreno. Vamos nos livrar disso: no terreno
tubos. Nós não temos necessidade de deformar a forma de Seleção no menu.) Editor , clique em Editar > Remover Oceano no menu. (Você também pode
os canos, corpos tão rígidos vão funcionar bem. escolha deixá-lo lá se você gosta da aparência.)
1. Use a ferramenta Criar objeto e 5 Use a ferramenta Propriedades para renomear seu pipe pipe1_bottom .
Clique duas vezes Entidades do Legacy > Física > RigidBodyEx . 6 Vamos mover nosso cachimbo para o ar onde precisamos: definir sua posição para
2. Clique no seu nível para adicionar sua entidade RigidBodyEx. Ele aparecerá como um 485, 500, 96 .
esfera no terreno. Nós temos a forma da nossa entidade de pipe, mas ainda precisamos de uma textura de superfície :
3. Vamos substituir a esfera padrão por uma entidade de pipe que já 7. Com o pipe ainda selecionado, clique no ícone da pasta ao lado de Propriedades
modelado para você. Na janela Propriedades > Propriedades da Lua , clique em > Geral > Material e selecione uma textura que você gosta. Nós usamos
o ícone da pasta à direita da propriedade Model . Navegue até GameSDK> material> genérico> concreto> roof_tar_paper_01
GameSDK > objetos > adereços > flappy_boid e clique em um cano que você nas nossas capturas de tela.
como dos vários fornecidos.
Você perceberá que é muito difícil avaliar como sua textura
Você verá o que parece um anel grosso no terreno. Na verdade, este é o parece por causa da iluminação padrão : o sol está diretamente em cima . Nós podemos
“Labio” de um cano grande, mas tudo exceto o labelo está oculto sob o controlar que usando o Editor de Ambiente:
terreno.
É importante entender que quando você adiciona entidades ao seu nível, Ajustando a iluminação usando o editor de ambiente
modelador pré-definiu o pivô - o ponto central para a entidade e qualquer
No menu principal, escolha Ferramentas > Editor de Ambiente .
CRYENGINE Flappy Boid Course Ver. 5.5D - 18 - 03: Adicionando os Obstáculos da Tubulação
Expanda essa paleta de ferramentas para ver a linha do tempo. Você notou que por 2. Gire 180º de modo que a cabeça fique voltada para o tubo inferior. Certifique-se de encaixar
Por padrão, um novo jogo começa no meio - dia no equador do planeta Terra. que para ângulo é ativado e definido para 90 ⁰ . Clique e arraste o arco branco ou vermelho
significa que o sol está diretamente acima da cabeça - normalmente não é ideal a partir de uma iluminação para girar 180º. Mova -o para 485, 500, 104. Isso deixa uma vertical de 8m
ponto de vista. Existem três fatores principais que afetarão nossa iluminação: intervalo entre o tubo para o seu jogador para navegar.
1. Hora do dia , representada pela linha do tempo no canto superior direito 3. Renomeie seu pipe1_top top pipe .
(atualmente 12:00) 4. Verifique se o seu tubo superior está exatamente em 485, 500, 104 . Você pode usar o snap
2. direção do Sol (canto inferior esquerdo) para gridar ou editar as Propriedades> Transformar para posicionar o tubo no
posição exata.
3. Latitude , representados pelo Norte Pole..Equator..South Pole deslizante
inferior esquerda
Adicionando um Trigger de Pontuação
Primeiro, tente arrastar o cursor da hora do dia . Enquanto você verá algumas mudanças,
quando estamos no equador, o sol viaja no seu caminho mais alto Agora que temos nosso primeiro conjunto de obstáculos de tubulação, precisamos detectar quando o
o céu - diretamente acima do meio-dia. jogador colide com eles - ou quando passa limpa através do intervalo entre
os tubos, e deve ser premiado com um ponto.
Restaure a hora do dia exatamente ao meio-dia , digitando 12h na caixa Atual .
Vamos lidar primeiro com a pontuação: como podemos detectar quando a ave passa
Vamos ajustar nossa latitude (posição norte-sul em relação ao equador) para obter
a lacuna entre um par de tubos? Não há nada lá para sentir uma colisão, por
o sol viajando através de um caminho mais baixo no céu . Ajuste o norte
exemplo. (Lembre-se também que os canos e, portanto, as lacunas entre eles
Pole..Equator..Slide do polo sul até que a luz esteja vindo da frente direita
esteja sempre em movimento!)
a cerca de um ângulo de 45 graus. (Lembre-se, nossa esfera acabará se tornando um
pássaro de frente para a direita, então provavelmente queremos ver Para conseguir isso, usaremos uma entidade chamada de Gatilho de Proximidade - um
cara.) caixa invisível que pode detectar quando outra entidade cruza seus limites
Nós usamos uma direção do sol de 240⁰ e uma latitude de 165⁰ Não precisa ter a mesma forma dos canos; ele simplesmente precisa ser tão amplo quanto
às 12:00 no nosso exemplo. o diâmetro dos tubos no eixo Y ( perpendicular à direção do
jogo) e pelo menos tão alto quanto o fosso para que o pássaro é certo para tocá-lo como é
Adicionando o tubo superior atravessa a lacuna.
A imagem aqui mostra esses gatilhos de proximidade: 1x5x10m - uma forma fina como
Vamos adicionar outro tubo acima deste com as duas cabeças voltadas uma para a outra.
larga como o diâmetro dos tubos. O pássaro vai colidir com o tubo antes dele
A lacuna entre os tubos superior e inferior será a lacuna através da qual o
colide com o gatilho de pontuação, para que possamos estender com segurança o comprimento do nosso
jogador deve navegar sem colidir . Assim, quanto menor a lacuna, mais difícil
pontuação desencadeia a 10m para se sobrepor com os tubos um pouco.
o jogo. Vamos tentar 8m:
A sobreposição não deve ser um problema, pois o jogador colidiria com o
1. Certifique-se de que o pipe1_ bottom esteja selecionado . Queremos arrastar uma cópia do
fora do tubo antes de acertar o gatilho de pontuação dentro dele. Mesmo se passa
para cima. Pressione Ctrl-D para duplicar . Sua cópia aparecerá e você
pode arrastá-lo para cima oito metros (Z = 104). DICA : para posicionamento preciso, através da pontuação disparar em um ângulo vertical e, em seguida, rozes a parte superior ou inferior
verifique se a paleta Propriedades > Transformar está visível e observe de um dos canos, não há problema em marcar antes da morte. Vamos
as coordenadas XYZ conforme você arrasta a duplicata. Em alguns casos, pode crie-os:
será mais fácil usar a ferramenta Mover depois de ter feito a duplicação.
1 Usando a ferramenta Criar objeto , arraste as entidades herdadas > Triggers > 8. Copie e cole o nome da sua entidade FlappyBoid no
ProximityTrigger em qualquer lugar na janela de exibição Perspective. Propriedades do acionador de proximidade > Propriedades de Lua > Somente selecionadas
2 Vamos alinhar o Gatilho de Proximidade exatamente com a posição do nosso Entidade caixa por isso só irá responder a colisões com o nosso pássaro.
tubo inferior usando Snap To Pivot : 9. Renomeie o Trigger de Proximidade pipe1Score_trigger .

3 Selecione a entidade Trigger de Proximidade. 10. Certifique-se de grade de agarramento é transformado em e definido para .5m, e arrastar o
4 Pressione P ou clique no botão Snap To Pivot top right in your pipe1Score_trigger até 4m, então é exatamente centralizado na lacuna de 8m
Perspectiva de perspectiva. entre os tubos superior e inferior. (Grid de encaixe é o botão
diretamente à direita do botão Exibir no canto superior direito do
5 Você notará que o topo da janela de exibição Perspective diz "Pick Object".
a janela de exibição Perspective. Clique e segure para definir o valor.)
Clique no tubo inferior. O gatilho de proximidade está perfeitamente alinhado
e centrado sobre a cabeça do tubo. 11. No Level Explorer , arraste o pipe1Score_trigger para pipe1_
fundo para ligá- lo. Pipe1_bottom agora é o objeto pai; movendo o
Se você tiver dificuldade em selecionar o gatilho de proximidade, use o Level Explorer para
tubo também irá mover o gatilho.
congelar pipe1_bottom para que você não pode selecionar -lo: selecione a entidade pipe1_bottom e
Criamos os gatilhos de pontuação. Vamos adicionar a lógica de pontuação do Fluxograma em um
Clique na coluna Congelada mais à direita ao lado da entidade pipe1_bottom. Está
capítulo subseqüente.
o identificador escurecerá e você poderá selecionar facilmente o gatilho de proximidade.
6. Alterar as propriedades do acionador de proximidade > Propriedades de Lua> Dim DESAFIO : Considere como melhor detectar colisões
X / Y / Z para 1, 5, 8 . Certifique-se de não editar o Transform> Scale entre os canos e o pássaro. Devemos usar proximidade
propriedades por acidente! Aqueles não têm efeito sobre as dimensões de um gatilhos?
proximidade, já que não são entidades físicas.
7. Porque o nosso jogo é baseado no jogo de tiro em primeira pessoa Game SDK Existe uma maneira de evitar a adição e codificação de oito "morte"
framework, mas não estamos realmente usando a entidade de jogador, precisamos gatilhos de proximidade que coincidam com as dimensões de cada
sentido quando outras entidades que não o jogador padrão não utilizado colidem com tubo? Temos que usar gatilhos de proximidade? Nós
esse gatilho de proximidade. No painel Propriedades > Propriedades de Lua , precisa programar cada tubo para detectar uma colisão?
Desmarque Somente Player .
Você tem algum tempo para considerar a melhor abordagem; bem
abordar isso em um capítulo posterior.
04: Adicionando o texto "Game Over" Vinculação vs. Agrupamento
Faz sentido conectar todas as partes do texto “game over”. Você

Quando o jogador morre, precisamos exibir uma mensagem de "game over". Bem construído
pode vinculá-los a uma entidade como pai ou agrupá-los. Tenha em mente
o nosso fora de entidades de texto 3D fornecidos no GameSDK, mantendo-o fora de
esse agrupamento simplifica a manipulação de um grupo de entidades como uma, mas um
A visão de FlappyCam até que o jogador realmente morra.
O objeto de grupo oculta muitas das propriedades de seus membros, enquanto a vinculação
Para nos ajudar a configurar isso, torne seu terreno visível novamente e ative sua grade não.
encaixe por 0,5 metros.
1. Selecione todas as oito letras e a caixa.
1 Use a ferramenta Criar objeto para arrastar outras entidades herdadas > 2. Clique no botão Grupo na barra de ferramentas. Uma caixa delimitadora é exibida
Física > Entidade RigidBodyEx no nível. em torno dos objetos. Quaisquer transformações agora afetam todo o grupo como
2 Vamos mudar a esfera padrão para uma caixa que ficará sob o nosso "jogo" uma única entidade .
sobre ”texto. Clique no ícone da pasta à direita da propriedade Model
na ferramenta Propriedades > Propriedades de Lua . Editando Entidades Agrupadas
3 Selecione GameSDK > objetos > padrão > primitive_box .
Se em algum momento no futuro você precisar editar as entidades individuais dentro do
4 Escale sua caixa para 6x1x1m. ( Desvincule os três eixos antes de dimensionar.) grupo, você pode clicar no botão Abrir na janela Propriedades para acessar
Nomeie-o como " GameOverBox " . Dê-lhe uma densidade de 20 e uma massa de 500 . e modifique as entidades individuais sem perder seu grupo. Apenas certifique-se de
5 Duplique sua caixa e arraste-a para cima, logo acima do original. clique no botão Fechar quando terminar!
6 Vamos mudar a caixa copiada para a letra “G:” clique no ícone da pasta
à direita da propriedade Model em Propriedades > Propriedades de Lua
ferramenta. Selecione o "G" do GameSDK > objetos > adereços > misc >
3dtext . Dica Pro :
Quaisquer transformações aplicadas a um
7 O "G" está lá, mas a transformação distorceu sua forma. Repor tudo
posição inicial da entidade são
três valores em Propriedades > Transformar > Ajustar para 2 em todos os eixos.
lembrado em suas propriedades (não
8 Atribua seu “G” uma Missa de 200 . os passos dados, mas o resultado final
9 Duplique seu "G" e mova-o para a direita. Use Grid Snapping para do movimento / rotação / escala).
ajudar você.
10. Substitua o “G” por um “A” usando a mesma propriedade Model.
11. Repita este processo até ter seu texto “GAME OVER” olhando
Boa. Ajuste a largura da caixa abaixo do texto, se necessário. Usar
sua viewport 2D frontal ou esquerda para ajudá-lo a alinhar as coisas.
12. É sempre uma boa prática nomear bem suas entidades e uma grande ajuda
com depuração . Nomeie suas cartas gameOverText_G etc.
CRYENGINE Flappy Boid Course Ver. 5.5D - 22 - 04: Adicionando o texto "Game Over"
05: Adicionando um fundo de céu em movimento 2. Na ferramenta Legado do Material Editor, clique no botão Add New Item .
3. Nomeie seu material flappyBG e salve -o na sua pasta Materiais .
Desde que sabemos que nossos tubos vão se mover da direita para a esquerda enquanto o nosso pássaro 4. À esquerda Selecione seu material flappyBG .
só se move para cima e para baixo, a ilusão de que o pássaro está se movendo horizontalmente
5. Desça até Advanced > Texture Maps > Diffuse . Clique em …
seria muito reforçada por um fundo . Você não precisa mergulhar profundamente
botão e navegue até GameSDK > materiais e selecione o
em teorias de Einstein da relatividade do movimento para ver que, se o fundo
arquivo cloudtiling_diff.dds . Note que esta é uma textura que nós preparamos
está se movendo, vai sentir como o pássaro está se movendo na direção oposta. que telhas (repete) sem problemas.
Para fazer isso, criaremos uma caixa simples usando nosso whiteboxing (prototipagem 6. Clique no botão superior esquerdo no Material Editor para atribuir essa textura
modelagem) Designer ferramenta e textura- lo com uma imagem de um céu azul com para o nosso Designer Box. Se você ampliar, você verá muitas nuvens lado a lado
nuvens e faça a textura da nuvem se mover da direita para a esquerda. Enquanto a câmera através de sua caixa, mas eles são muito pequenos.
não enxerga além do limite do nosso "céu", a ilusão funcionará. NOTA : é
útil manter o Terreno visível durante esta seção. Escalando a textura de fundo
Adicionando uma caixa de plano de fundo Vamos escalar a textura da nuvem sem dimensionar a caixa:
1. Certifique-se de que sua caixa de plano de fundo ainda esteja selecionada .

1. Ligue o encaixe na grade com precisão de 1m .
2. Nos mesmos parâmetros Avançado > Difuso no Material Editor
2. Na ferramenta Designer , selecione Caixa . Clique e arraste no terreno
Ferramenta preexistente, ajustar as TileU e TileV parâmetros. Quanto menor o
logo atrás e à esquerda dos tubos para fazer uma base de 1x100m
número, quanto maior as nuvens. Tente valores de 1,5 . Note que se você não
fino, mas muito largo no eixo X ), clique e mova o mouse
coincidir com esses dois valores, o mapa de textura será distorcido .
para cima para fazer a caixa de 100m de altura . Aplique zoom conforme necessário para criar espaço
para sua grande caixa de fundo. 3. Tente um valor OffsetV de 0,2 para que a colocação seja menos óbvia.
3. Dica : você pode manter pressionada a tecla Alt e arrastar o botão do meio do mouse para
Animando a textura do céu
órbita em torno de uma entidade selecionada.
4. Você vai perceber que quando você está usando a ferramenta Designer, há um 4. Agora vamos animar a textura da nuvem através da caixa: no mesmo
Texto do designer na parte superior da sua viewport. Quando terminar de criar Mapas de Textura > seção Difusa da ferramenta Legacy do Material Editor ,
sua caixa, ESC ou clique no X para sair da ferramenta Designer. Clique no triângulo à esquerda do Oscilador para abrir seus parâmetros.
5. Nomeie sua caixa de fundo como algo como bg_box . TypeU move uma textura horizontalmente ; vamos mudar seu valor para Constant
Movendo .
6. Defina a posição da sua caixa de fundo cerca de 10 metros atrás do seu
5. Precisamos mudar a velocidade RateU para algo diferente de zero para ver
tubos e centrado em X e Z.
movimento; vamos tentar 1 . (Note que PhaseU é para piscar uma textura e
fora, que não vamos usar.)
Adicionando uma textura do céu
6. Nós também precisamos mudar a Amplitude para algo maior que 0; vamos
1. Vamos adicionar nossa textura do céu: primeiro, certifique-se de que a Caixa do Designer esteja tente 1 novamente.
selecionado . No menu principal, clique em Ferramentas > Material Editor Legacy
se ainda não estiver visível.
CRYENGINE Flappy Boid Course Ver. 5.5D - 23 - 05: Adicionando um fundo de céu em movimento
7. Enquanto esta velocidade provavelmente precisará ser ajustada a olho uma vez que estamos em
modo de jogo, visto a partir de FlappyCam, você provavelmente já pode
veja que é bem rápido. Tente reduzir RateU para 0,3 e AmplitudeU para 0,2 .
Removendo sombras através de shaders
Você pode ter notado algo que arruína a ilusão do nosso "céu" -
sombras dos canos na nossa caixa “sky”!
Podemos tentar consertar isso ajustando a direção do Sol no ambiente.

Editor. Você também pode querer mover sua caixa de fundo para mais longe
seus canos.
Dedique alguns minutos para experimentar a iluminação. As chances são que você
ainda tem sombras no seu "céu". Podemos ajudar isso movendo sua
caixa de céu de fundo mais longe dos tubos e torná-lo maior por isso ainda
preenche a visualização FlappyCam. Enquanto o Editor de Ambiente pode fornecer muitos
efeitos fotorrealistas dramáticos, incluindo nuvens volumétricas e nevoeiro, não vamos
precisa de mais alguma coisa com isso neste jogo, então vamos fechá- lo agora.
Ainda teremos problemas de sombra em nossa caixa de fundo, não importa como
ângulo do sol. No final, a melhor solução é dizer a nossa caixa de fundo para não
Renderizar sombras modificando seu shader :
1. Selecione a caixa de fundo.
2. Na ferramenta Legado do Material Editor , altere as Configurações do material >

Parâmetro Shader de Illum para ReferenceImage .
Escalando e posicionando a caixa de plano de fundo
Vamos fazer o fundo preencher a tela escalando e posicionando -a. Como

podemos ter certeza de que é o tamanho certo para preencher a visão do jogador?
Crie uma viewport secundária baseada na câmera FlappyCam e assista como

você posiciona e dimensiona a caixa de plano de fundo usando outras viewports:
vista . Tenha em mente que as viewports não são atualizadas em tempo real
1. Clique no menu azul da Câmera no canto superior esquerdo da Perspectiva
Viewport e escolha Criar Viewport > Perspectiva . você faz alterações em outra viewport de perspectiva.
3 Escale e mova o Designer Box até que ele seja grande e fino e preencha o
2. Na sua nova janela de perspectiva, clique no menu Câmera novamente
Visualização FlappyCam.
escolha Camera Entity > FlappyCam . Agora você vê o jogador
DICA : Enquanto FlappyCam está se movendo para cima e para baixo com Aqui está uma visão do layout do jogo para lhe dar uma noção das posições da entidade,
o pássaro, a caixa de fundo realmente precisa ser visto de um ângulo frontal esquerdo.
maior que a vista estática atual. Nós não podemos afinar o seu
tamanho até que nós sabemos o quão longe o pássaro pode se mover! Otimizando Entidades do Designer por meio da Exportação CGF
A ferramenta Designer foi projetada para uma prototipagem rápida e fácil do seu nível
Usando iluminação global
desenhos, não entregando um jogo acabado. A geometria que gera não é
Se você olhar para a frente e para trás da sua caixa, você pode notar que o eficiente, portanto, é caro para o computador renderizar.
a textura da nuvem em movimento parece desaparecer . A textura é aplicada em todos os lados Portanto, é uma boa prática converter as entidades do Designer em arquivos de malha padrão
então não é uma questão de rotação. (.CGF, .OBJ, etc.) e reimportá-los, substituindo os originais, para otimizar
Então, qual poderia ser o problema? design do jogo antes de enviar. Aqui estão os passos:
A resposta é que o sol não é inclinado para iluminar os dois lados do seu 1. Primeiro, salve seu nível.
caixa de fundo! Existem algumas soluções para isso. 2. Selecione o objeto da caixa de fundo da bgBox.
A solução simples é ativar a iluminação global . Você notará que há um 3. Na paleta de ferramentas do Designer , clique na paleta Transformar e, em
muito contraste na iluminação atual. Iluminação global processa refletida Botão Exportar. Role para baixo até ver o arquivo. Botão CGF e clique em
luz através de ray tracing. Você pode ativar esse recurso nas suas Configurações de Nível : isto. Salve seu arquivo como algo como FlappyBackgroundBox.cgf no
Menu principal > Ferramentas > Editor de Nível > Configurações de Nível > Iluminação total Pasta GameSDK.
V2 . Clique em Active para habilitar o GI (Global Illumination), e você 4. Exclua sua antiga entidade Designer de caixa de segundo plano.
imediatamente ver menor contraste.
5. Use a ferramenta Criar objeto para adicionar um pincel e selecione o
Embora exista um custo de desempenho para usar a Iluminação Global, ela tem um grande FlappyBackgroundBox.cgf como o tipo de pincel. Coloque, posicione e
impacto na aparência do seu jogo. Outro aspecto sobre o qual CRYENGINE transformar como desejado.
fornece controle preciso é a natureza da luz do sol em seus níveis.
06: Mover os canos Na lista de gráficos do Flux Graph em Entidades , você verá um pipeMovement
pasta e um novo gráfico chamado pipe1_bottom . Clique nele para abri-lo.
Em vez de mover o nosso jogador para a direita, o que cria inúmeros problemas DICA : Se a ferramenta Fluxograma já estava aberta quando você fez isso, você não
- ficar sem espaço de jogo jogável, precisando constantemente reposicionar veja a mudança. Feche e reabra a ferramenta Flow Graph para forçar a árvore do gráfico
canos para novos locais - vamos mover nossos canos para a esquerda, enquanto o para atualizar .
o jogador só se move para cima e para baixo . 4. Adicione um nó Movement: MoveEntityTo ao seu novo Flow Graph.
Além disso, desde a nossa câmera estreita restringe vista do jogador (de um terço 5. Atribua seu grupo pipe1_bottom a este movimento: MoveEntityTo
perspectiva de pessoa), podemos controlar quantos tubos o jogador vê em qualquer nó simplesmente clicando com o botão direito do mouse no nó MoveEntityTo e
dado momento - apenas o suficiente para se posicionar para evitar o próximo casal escolhendo Atribuir entidade de gráfico .
de tubos que se aproximam.
Você pode achar estranho que o nó Movement: MoveEntityTo agora diga
Vamos explorar essa visão restrita para esperar até que cada tubo esteja fora do “<Entidade do gráfico>” como a entidade atribuída, em vez do nome da entidade
quadro da câmera à esquerda para enviá-lo instantaneamente de volta a um ponto inicial pré-definido (pipe1_bottom). Lembre-se que este gráfico de fluxo está diretamente ligado ao
fora da câmera no lado direito. Dessa forma, conseguimos uma série aparentemente interminável pipe1_bottom conjunto de entidades vinculadas. "Entidade do gráfico" refere-se à entidade pai
de tubos sem realmente fazer mais de quatro conjuntos - jogo que só contendo o Fluxograma - isto é, a própria entidade pipe1_bottom.
termina quando o jogador morre. A vantagem disso é que, como o nome da entidade não é embutido no código
nó, podemos reutilizar esses mesmos nós nos outros tubos sem fazer qualquer
Movendo o primeiro tubo alterar. É sempre uma boa prática de desenvolvimento evitar enterrar codificados
nomes e números no que acabará por se tornar um grande design de jogos.
Primeiro, vamos pegar nosso primeiro conjunto de tubos indo da direita para a esquerda. Precisamos definir o começo
A codificação torna seu design inflexível e difícil de depurar.
e posições finais, e detectar quando um tubo atingiu o ponto final. Desde o
tubos devem presumivelmente começar a se mover no momento em que o jogo começa, nós vamos Note que precisamos que nosso ai_end esteja exatamente na mesma posição vertical que o
Acione o movimento inicial com um nó Game Start. entidade-mãe - o tubo inferior - caso contrário, os tubos se deslocarão verticalmente
sua posição inicial Z.
Antes de começarmos a mover os canos, vamos dar a eles um começo e um fim fixos
coordena usando Pontos de Tag AI: 6. Defina o Value Type do pipe1Reset_trigger como velocidade e o valor
para 5. Este número determina diretamente o quão rápido seu tubo se move, assim
1. Precisamos escolher uma posição final logo após o lado esquerdo do
quão difícil é o seu jogo.
FlappyCam view (ou seja, apenas fora de vista). Use sua ferramenta Criar Objeto
para adicionar um objeto AI Tag Point . 7. Verifique se o Coord Sys do nó MoveEntityTo está definido como World .
2. Nome ele ai_end , e definir a sua posição de 515 , 500 , 96 . 8. Precisamos informar ao Flow Graph onde mover o pipe: selecione seu ai_end
Tag Point no Editor. Clique com o botão direito no Flux Graph e escolha Adicionar
Vamos anexar o Fluxograma do movimento do tubo separadamente para cada tubo. Vamos
Entidade Selecionada . Arraste a saída Pos do nó ai_end para o
comece com o tubo # 1:
Destino entrada do MoveEntityTo nó.
3. Clique com o botão direito do mouse no grupo pipe1_bottom e escolha Criar Fluxo
Gráfico . Clique em Novo … e nomeie sua pasta como PipeMovement . Dentro
CRYENGINE Flappy Boid Course Ver. 5.5D - 27 - 06: Mover os canos

9. Finalmente, precisamos realmente iniciar o 3. Clique com o botão direito do mouse no nó BeamEntity e escolha Assign Graph
movimento. Vamos pegar o tubo movendo o Entidade . A entidade gráfica é o objeto para o qual este gráfico de fluxo é
momento em que o jogo começa: Adicionar um Jogo > anexado: pipe1_bottom. Isso facilita a cópia e colagem dessas
Inicie o nó. Arraste sua saída para o início Dica Pro : nós para os outros pipes sem precisar alterar os nomes dos pipes.
Configurando este valor de velocidade dentro de um
entrada do seu nó MoveEntityTo . 4. Em seguida, precisamos comunicar a posição dessa entidade ai_start para o
O nó do Flux Graph é uma prática
10. Antes de testarmos isso, vamos esconder o outro chamado “hard coding” - enterrar um ação do feixe: selecione a entidade ai_start no Editor. Clique com o botão direito em
três conjuntos de tubos. Use o Level Explorer valor preciso em que será seu gráfico e escolha Adicionar entidade selecionada .
provavelmente se tornará um labirinto complexo
para escondê- los. 5. Vamos dizer ao feixe para onde enviar os tubos: arraste a saída Pos do
de nós ou código, fazendo alterações
Vamos testar! Ctrl-S para salvar; Ctrl-G para entrar no jogo e depuração difícil. Em vez de, ai_start node para a entrada Position do nó BeamEntity . Faço
a melhor prática é usar um não confunda ai_start e ai_end!
modo. O primeiro tubo deve se mover para a esquerda!
variável - um token de jogo - que
Observe que depois que o MoveEntityTo é concluído, 6. Agora, para a magia real! Arraste a saída Finish do
pode ser definido na configuração inicial
física assumir novamente, e o tubo vai cair para seção do seu Fluxograma, ou Nó MoveEntityTo para a entrada Beam do nó BeamEntity. o
o terreno, mesmo que esse terreno esteja oculto. mesmo controlado através da interface do usuário por um
lógica aqui é simples: esperamos que a entidade do pipe chegue ao seu destino /
Controle deslizante "dificuldade". Resumindo:
Além disso, note que nós só tivemos que mover o fundo A saída “Finish” do MoveEntityTo é enviada um sinal quando e se o
organizar jogo importante
elementos como este, então eles são fáceis move é concluída com êxito , informando ao nó BeamEntity para enviar
tubo. Desde pipe1_top e pipe1_scoreTrigger
para encontrar e mudar! o tubo de volta para a posição inicial.
estão ligados ao tubo inferior, eles se movem em
em paralelo com a sua entidade-mãe. Note que há uma distinção importante entre o Feito e o Final
saídas do nó MoveEntityTo: se você passar o mouse sobre cada um desses
Repor a posição do tubo saídas, o texto da dica de ferramenta explicará que, embora a saída Done seja acionada se
o movimento alcança seu destino (isto é, completa o movimento) ou se o
Agora que conseguimos tirar o tubo da visão da câmera para a esquerda, o movimento é interrompido , o término só é acionado se o movimento for concluído .
precisa enviá-lo de volta para a posição inicial. Isso precisa acontecer Essa diferença se tornará especialmente significativa mais tarde, quando precisarmos
instantaneamente, então, em vez de usar um nó de movimento, usaremos um nó de viga . interromper todo o movimento do cano em andamento quando o jogador colidir com um cano.
Feixe significa movimento instantâneo ao transportador de Star Trek .
Completamos a funcionalidade, mas falta uma coisa: como nós
Usaremos outro ponto de marcação AI para definir um ponto inicial fixo no espaço 3D. loop esta funcionalidade para que o tubo repete este ciclo de movimento-feixe? A resposta
é novamente usar a saída Done do BeamEntity para acionar o
DESAFIO : Por que precisamos mesmo deste ponto do Tag AI? Entrada inicial do MoveEntityTo. No entanto, não podemos alimentar duas saídas no mesmo
Por que não apenas irradiar o tubo mais à esquerda para a posição de entrada. Precisamos de uma porta lógica que aceita múltiplas entradas, por isso , quer
o tubo mais à direita em si? Jogo: Start OU O sinal “Done” do Beam acionará o MoveEntityTo:
7. Clique com o botão direito do mouse no círculo no meio do conector entre

1. Use sua ferramenta Criar Objeto para adicionar um AI > TagPoint ao nível.
Jogo : Start e o nó Start do MoveEntityTo . (O cursor gira
Nomeie seu Tag Point ai_start . Posicione -o em 455 , 500 , 96 .
em uma pequena seta branca.) Escolha Logic : Any para inserir uma lógica
2. Para mover uma entidade em algum lugar instantaneamente, adicione um portão no meio do seu conector sem perder o seu início e fim
Entidade : nó BeamEntity para seu Flux Graph. pontos. Você notará que o conector anterior agora passa por
a entrada In1 .

8. Arraste a saída Done do nó BeamEntity todo o caminho de volta para o Uma melhoria que podemos considerar é adicionar um pequeno atraso antes dos tubos
Entrada In2 da sua lógica : qualquer porta. Conectores de looping longos como este comece a avançar no início do jogo para dar ao jogador a chance de entrar em posição. A
são o que faz um gráfico de fluxo parecer confuso, mas são inevitáveis. maneira fácil de fazer isso é clicar com o botão direito no ponto central do conector
Organize seus nós da maneira mais nítida possível. entre o seu jogo: Inicie o nó e sua lógica: qualquer portão e escolha o tempo
9. Finalmente, vamos documentar esta seção do Flux Graph adicionando um Delay . Você pode variar o valor de Atraso deste nó (as unidades são segundos) de
caixa de comentário em torno dele chamado "movimento de tubo". Este nó Time: Delay como achar melhor.
Fechamos o ciclo no nosso movimento de canos! Vamos testar: Ctrl-S; Ctrl-G .

Depois que o tubo terminar de se mover, ele deve voltar para a posição do
o tubo mais à direita e comece a se mover novamente, ad infinitum .

Movendo os Outros Tubos • luar
• estrelas
Inicialmente, posicionamos nossos quatro conjuntos de tubos como deveriam ser espaçados. Todos • Nuvens volumétricas (3D, afetadas pela luz solar)
nós temos que fazer agora é copiar a lógica do gráfico de fluxo que nós anexamos ao pipe1 e • vento
cole nos outros três tubos inferiores. • oceano
Desde o evento Game: Start é o que inicialmente desencadeia o movimento em direção ao • Brisas Aleatórias
ai_end Tag Point, todos os quatro tubos começarão a se mover no instante em que o jogo começar. • Terrain
• Física
1. Torne todos os seus tubos visíveis novamente usando o Level Explorer .
• densidade atmosférica
2. No Flux Graph, arraste uma caixa ao redor de todos os nós de movimento do tubo,
incluindo a caixa de comentários e copie- os para a área de transferência (Ctrl-C). Esses aspectos do nosso mundo virtual estão “ligados” por padrão. Então poderia um dos
3. No Editor, clique com o botão direito do mouse em pipe2_bottom e escolha Criar Fluxo estas são a causa?
Gráfico . Se você abrir Ferramentas > Editor de Níveis > Configurações de Nível e vá até o Vento
4. Clique na pasta PipeMovement existente e clique em OK. Ingresso parâmetro, você notará que é definido como 1 por padrão. Há um leve vento
Gráfico, você verá que pipe2_bottom foi adicionado como outro Fluxo soprando ao longo do eixo X, empurrando nosso pássaro firmemente para a esquerda!
Gráfico na pasta pipeMovement. Clique para abri-lo.
Vamos mudar isso para 0 . Como o movimento horizontal do nosso pássaro é apenas um visual
5. Cole os nós do Fluxograma nas Entidades > pipeMovement > ilusão; nós realmente queremos que seja estático no eixo X, caso contrário, o todo
gráfico pipe2_bottom . sistema de movimento que construímos para os nossos tubos, incluindo o início e o fim da IA
Agora você vê a beleza dos nós reutilizáveis: não precisamos dizer a esses nós para pontos teriam que se mover também para acompanhar o efeito do vento -
especificamente move pipe2 porque eles movem a entidade gráfica para a qual eles são complexidade que não precisamos!
em anexo.
Criando uma Câmera de Depuração
Siga o mesmo procedimento para os outros tubos e, em seguida, teste . Todos os quatro pares de tubos
deve mover-se da direita para a esquerda, uniformemente espaçadas, redefinindo-se para o ai_start Em casos como este, quando você está testando e tentando entender o que
posição e passando pelo jogador. acontecendo, é útil ver fora de uma visão restrita como a apresentada por
nossa FlappyCam. Por exemplo, seria útil voltar atrás e ver todos os
Considerações ambientais tubos para garantir que eles estão se movendo conforme o esperado. Para fazer isso, vamos criar um
câmera adicional:
Se você testar seu jogo por um tempo, pular para manter seu pássaro no ar e
visualizá-lo através de FlappyCam, você acabará por perceber que seu pássaro drifts 1. Navegue até uma exibição que você goste de usar o Editor. Uma das vistas
para a esquerda e, finalmente, acaba fora da tela! que pode ser útil é paralelo aos tubos (perpendicular à sua
O quê está causando isto? Nosso impulso de salto só age no eixo Z , não no X. movimento), assim você pode ver que os tubos são uniformemente espaçados , pois
mover.
Um dos princípios fundamentais do CRYENGINE é que ele reconstrói um
2. Clique no menu Câmera na janela de exibição Perspective e escolha
ambiente do mundo real de todas as formas possíveis. Isso inclui:
Criar câmera a partir da visão atual .
• luz do sol 3. Use o Level Explorer para renomear sua câmera debugCamera1.

4. Na seção de configuração inicial de suas Entidades> Flappy> FG_Main
Flow Graph, atribua seu debugCamera1 ao nó Camera : View .
( Selecione o debugCamera1 no Sandbox, clique com o botão direito no
Câmera : visualize o nó e escolha Atribuir Entidade Selecionada .)
Salve e teste . Você deve ver imediatamente a visão do seu

debugCamera1. Certifique-se de restaurar o FlappyCam como sua câmera selecionada
Fluxograma quando terminar de depurar!

07: Mantendo Pontuação 3. Mapeie a saída Enter do nó pipeScore_trigger para o Trigger
entrada do seu nó GameTokenModify para acionar a ação de modificação
cada vez que o jogador entra no gatilho de proximidade.
Precisamos armazenar a pontuação do jogador como um inteiro em uma variável que podemos
incrementa cada vez que o jogador toca em um trigger de pontuação, e também mantém a pontuação 4. Selecione seu nó GameTokenModify. Em suas propriedades , defina
exibido na tela. Entradas do Nó Selecionado > Valor do Token para o token do jogo intScore .
5. Altere as entradas do nó selecionado > Tipo de operação para Adicionar a

Adicionando uma variável de pontuação incremente a pontuação.
6. Altere as Entradas do Nó Selecionado > Tipo para inteiro.
Para começar, vamos criar um inteiro Game Token (variável) para manter o controle do
Pontuação do jogador : 7. Altere as Entradas do Nó Selecionado > Valor para 1 para incrementar seu
pontuação por 1 de cada vez.
1. No menu, escolha Ferramentas > Visualização do DataBase .
2. Clique na guia GameTokens . Exibindo a pontuação na tela

3. Em Tarefas do Token do Jogo , clique em Adicionar Novo Item . Diga
Agora precisamos criar uma maneira de exibir a pontuação do jogador na tela .
" IntScore "
No final, queremos criar um pouco de interface do usuário que pareça boa, por enquanto
4. Por padrão, seu novo token de jogo é um booleano; mudar seu tipo para vamos tomar uma abordagem de prototipagem usando um nó de depuração chamado
Inteiro . Defina o valor inicial para 0 . DisplayMessage para exibir texto simples na tela para verificar se a nossa pontuação é
5. Vamos começar recuperando o valor atual: no Fluxo do seu jogador trabalhando corretamente.
Gráfico, adicione um jogo > Iniciar e uma missão > nó GameTokenGet .
1 Arraste um nó Debug > DisplayMessage para o seu Flow Graph.
6. Selecione o nó GameTokenGet. Nas Propriedades do Gráfico de Fluxo em
2 Mapeie o Valor de Saída do seu nó GameTokenModify para o Show
Entradas do Nó Selecionado > Token , clique no botão .. e escolha o seu
entrada do seu nó DisplayMessage .
token do jogo intScore .
3 Direito - clique sobre a alça redonda no meio do conector você
7. Mapeie o nó Saída do jogo: Iniciar para a entrada do acionador do
acabou de fazer e escolher Lógica: Qualquer . Isso insere uma porta lógica que
Nó GameTokenGet . Isso recupera o valor inicial do intScore
funciona como um “OR” com 10 entradas possíveis em vez de apenas duas.
Token de Jogo, então nossa lógica de pontuação pode incrementá- lo.
Reposicione seus nós para que haja espaço entre eles, com o seu
Lógica : Qualquer porta entre o GameTokenModify e
Incrementando a pontuação Nós DisplayMessage .
Toda vez que o jogador cruza esse gatilho de proximidade, queremos incrementar 4 Mapeie o Valor de Saída do seu nó GameTokenGet para a entrada In2 de
a pontuação do jogador . Isso significa que precisamos modificar o valor do nosso jogo de pontuação sua lógica : qualquer nó. Isto significa que iniciar o jogo irá desencadear
token adicionando um ponto por colisão do acionador de pontuação: o GameTokenGet para recuperar a pontuação inicial (que é zero) e
exibi-lo com o nó DisplayMessage e, a partir daí, a qualquer momento
1. Arraste um nó Missão > GameTokenModify para o seu Flux Graph para
pontuação Token jogo é modificado , ele vai passar a pontuação através da lógica
à direita do nó pipeScore_trigger.
portão também.
2. Selecione seu pipe1Score_trigger no Editor, depois clique com o botão direito em seu
Gráfico de fluxo adicionar escolha Adicionar entidade selecionada .
CRYENGINE Flappy Boid Course Ver. 5.5D - 32 - 07: Mantendo Pontuação

5 Clique no seu nó DisplayMessage . Tente um tamanho de fonte de pelo menos 5, Você pode querer adicionar uma caixa de comentários em torno desses nós conectados e chamar
e mude a cor da fonte para seu próprio gosto - apenas certifique-se algo como "marcar".
contrasta com o fundo !.
Precisamos da pontuação para atualizar se QUALQUER um dos gatilhos de pontuação for tocado. Vamos
6. Vamos testar enquanto assistimos com o Debug ativado. Clique no adicione o resto dos gatilhos de pontuação e estenda a lógica:
Ícone de depuração na barra de ferramentas do Flow Graph para ativar a depuração .
1 A partir do Level Explorer , selecione todos os quatro pontos de sua proximidade
Pressione Ctrl-G para entrar no modo de jogo. Você deve ver um 0 na tela - sua corrente
gatilhos. Dica : use Ctrl + clique para selecionar itens não contíguos no Nível
pontuação - até que você pule alto o suficiente para tocar no pipeScore_trigger , em
Explorador.
qual ponto sua pontuação se torna 1 . Cada vez que você passa pela proximidade
gatilho, sua pontuação é incrementada em um. 2 Clique com o botão direito no seu Flux Graph e escolha Add Selected Entity .
Organize- os pelo nome na seção de pontuação do seu gráfico.
Adicionando Texto "Pontuação" 3 Arraste o nó Saída do jogo: Iniciar para as entradas Ativar de cada
de seus nós de disparo de proximidade.
Vamos esclarecer para o jogador o que esse número significa adicionando a palavra
4 Clique com o botão direito na alça no meio do conector entre o
"Pontuação" na frente dele. Adicionando pedaços de texto juntos em uma string é chamado
Nós pipeScore_trigger e GameTokenModify e escolha
concatenação: Lógica: qualquer .
1. Arraste um nó String > Concat para o seu Flow Graph. 5 Mapeie as saídas Enter de cada um dos seus nós pipe # Score_trigger para o
1. Clique no seu nó String : Concat e defina a propriedade String1 para Entradas In2 a In5 da sua lógica: qualquer nó.
"Ponto: " 6 Reorganize seus nós conforme necessário, para que seu Flux Graph seja fácil
2. Mapeie a saída Out da sua Logic: Qualquer nó para a entrada Set do seu seguir . Não se esqueça de estender sua caixa de comentários SCORING para
Nó Concat . cercar todos os nós relacionados à pontuação.
3. Mapear o para fora de sua seqüência : Concat nó à mostra e o

Entradas de mensagem do seu nó DisplayMessage . Isso define o debug
mensagem como as duas seqüências de caracteres concatenadas e as mostra na tela.

08: Jogador "Morte" 3 Dentro desta caixa de comentários, adicione um nó Game : Start .
4 Adicione um nó Entity: EntityInfo . Atribua seu FlappyBoid a ele.
Acompanhamento de "morte" usando um token de jogo 5 Arraste o nó Saída do seu jogo : Iniciar para a entrada Obter do seu
Entidade: nó EntityInfo . Isso consulta o EntityID do seu FlappyBoid
Vamos querer que várias coisas aconteçam quando o jogador colidir com um cano. entidade no início do jogo.
Todos eles podem reagir indiretamente a essas colisões (ao invés de uma série confusa
6 Agora a parte importante! Adicione um nó Physics: CollisionListener ao
conexões de fluxo de gráfico em seções diferentes) simplesmente “escutando”
à direita de seus outros nós.
o valor de um token de jogo verdadeiro / falso que é falso até que uma colisão de pipe o defina como
verdade: 7 Arraste a saída de ID do seu nó EntityInfo para a entrada Add Listener
do seu nó Physics: CollisionListener . Este é o nó que detecta
1. Abra a ferramenta DataBase no menu Ferramentas . quaisquer colisões entre entidades fisicamente O ID da entidade é único,
2. Clique na guia Tokens do Jogo . número criado automaticamente usado internamente pela CRYENGINE para rastrear
cada entidade ( não a propriedade de nome que você atribui).
3. Em Tarefas do Token do Jogo , clique em Adicionar Novo Item . Ligue para o seu jogo
Token booIsDead . Note que o tipo de variável padrão é booleano com 8 Embora a física crie uma reação natural entre o “pássaro” e
um valor padrão de falso . Embora isso seja exatamente o que queremos, o tubo (desde que ambos estejam fisicamente), podemos melhorar isso com um
irá inicializar manualmente seu valor no início do jogo - uma prática sábia. impulso físico adicional : adicione um nó Physics : ActionImpulse .
9 Atribua a entidade FlappyBoid ao nó ActionImpulse . Tente definir

Detectando Colisões o Impulso a 50, 0, -50 para empurrar o pássaro para a esquerda (longe do
tubo) e para baixo em caso de colisão.
Agora que temos nossos tubos em movimento, precisamos sentir quando nosso pássaro colide
10. Mapeie a saída IdA do nó CollisionListener para a entrada Ativar
com qualquer um dos tubos, e termine o jogo. Como sempre, precisamos nos perguntar:
do nó ActionImpulse .
Qual é a maneira mais simples de conseguir isso?
11. Por fim, adicione um nó Missão: GameTokenSet . Defina seu token para
Uma maneira de ver isso é que uma colisão é o contato entre duas entidades -
booIsDead e seu valor para true . Mapeie a saída IdA do
um cano e nosso pássaro, neste caso. Isso significa que os tubos poderiam detectar o
Nó CollisionListener para a entrada Trigger do GameTokenSet
colisão, ou o pássaro poderia lidar com isso.
nó. Se o pássaro colidir com qualquer entidade fisicamente
Dado que, faz mais sentido ter apenas um conjunto de nós do Flux Graph no variável será feita verdade. Em seguida, precisamos realmente agir sobre isso em um
o pássaro em vez de duplicar nós em cada tubo. Para sentir a colisão, nós vamos Seção Game Over do Flow Graph que observa essa variável.
use a mágica do nó Physics : CollisionListener :
Terminando o jogo
1. No seu FG_Main Flow Graph, vá até uma seção em branco abaixo de seu
outras seções. Quando o jogador colide com um obstáculo e morre, o jogo acaba. Nós temos
2. Crie uma caixa de comentários e chame-a de Detect Collisions . Expandi-lo para dar um texto “game over” pronto e esperando fora de vista. No momento da morte,
você mesmo algum espaço. quer simplesmente revelar o texto Game Over para o jogador.
CRYENGINE Flappy Boid Course Ver. 5.5D - 35 - 08: Jogador "Morte"

Se você não quer que o jogador veja que existem apenas quatro tubos, gire o seu
DESAFIO : Exatamente o que devemos mover quando o
Game Over texto e câmera para que fique longe dos canos.
jogo termina, se alguma coisa? Brainstorm 2-3 possíveis
abordagens para mostrar o texto Game Over.
Congelando a câmera na morte do jogador
Poderíamos simplesmente reposicionar o nosso FlappyCam (assim como temos sido) para que ele veja Agora que temos um lugar onde estamos rastreando o status de morte do jogador, nós
o texto “game over” no momento da morte? Você vê algum potencial precisa realmente agir sobre isso, parando o movimento FlappyCam assim que
problemas? booIsDead se torna verdade.
Este método introduz alguns possíveis conflitos , já que outros nós também são Nós definimos o FlappyCam para seguir o jogador enquanto ele pula e cai - mas ele vai
tentando mover FlappyCam (para seguir o jogador). Nós precisaríamos parar isso também siga o jogador até o terreno quando o jogador "morrer".
movimento para que não entre em conflito com o movimento FlappyCam.
Em vez disso, vamos congelar a câmera e deixar o player sair da parte inferior
Um método simples é simplesmente criar uma câmera adicional posicionada para ver o jogo sobre a morte, como indicado pelo nosso booIsDead Jogo token ser verdadeira :
o texto GameOver e habilitar essa câmera quando um jogador morre - ou seja, simplesmente
1. Na seção MOVIMENTO DA CÂMERA do seu FG_Main Flow
alternar câmeras. Em nosso design, escondemos o texto Game Over por trás do FlappyCam,
Graph, arraste um nó Mission : GameToken para o seu gráfico.
e o jogo sobre a câmera por trás do jogo sobre o texto. Ou seja, quando o jogo
termina, nós apenas pular para uma visão de mais longe no eixo Y - longe o suficiente para 2. Clique no botão .. ao lado do parâmetro Token e escolha seu
ver que o jogo acabou o texto que estava lá o tempo todo! Token do jogo de booIsDead .
3. Defina Comparar com para Falso .

Agora, em vez de simplesmente passar a posição da entidade da ave através do nosso deslocamento para 6. Mapeie a saída Pos do seu nó EntityPos para a entrada In do seu
o nó MoveEntityTo que move o FlappyCam, precisamos verificar o valor de Lógica : Portão . Isso simplesmente passa os dados de posição da ave para a lógica
booIsDead e decidir entre duas ações. Nós vamos usar uma porta lógica para portão para esperar até que sua entrada aberta seja disparada, ponto em que
faça isso. passe o valor para a saída Out .
Enquanto booIsDead = false , queremos continuar passando a posição de deslocamento 7. Arraste a saída Equal do seu nó GameToken para a entrada Open
do nó Logic : Gate . Isto significa que quando booIsDead é igual a falso, o
para a entrada Iniciar do nó MoveEntityTo que já configuramos no FlappyCam.
Mas assim que booIsDead = true, precisamos acionar a entrada Stop do porta lógica abre, passando a posição para a câmera se mover.
Nó MoveEntityTo - trazendo o movimento da câmera que já estava 8. Mapeie a saída Out do seu nó Logic : Gate para a entrada A do seu
em andamento para uma parada. Nó SubVec3 .
No entanto, o nó EntityPos continuará a alimentar a posição do Flappy para Por fim, não podemos esquecer de definir o valor inicial de booIsDead para false no jogo
o nó MoveEntityTo, fazendo com que o movimento da câmera comece novamente! Não somente começar:
temos que parar o movimento da câmera em andamento, temos que 9. Abra o seu FG_Main Flow Graph e encontre o seu nó Game: Start .
impedir que o novo movimento comece interrompendo os dados de posição
10. Adicione um nó Missão: GameTokenSet.
fluindo para a câmera:
11. Arraste o nó Saída do seu jogo: Iniciar para a entrada do acionador de
4. Arraste um nó Logic: Gate para o seu gráfico. seu nó GameTokenSet .
5. Remova o conector antigo entre o nó EntityPos e o nó EntityPos. 12. Definir o token de sua missão : GameTokenSet nó para booIsDead
SubVec3 Uma entrada. e o valor para falso.

Nós construímos um obstáculo de tubo completo! Neste ponto, use o que você aprendeu 3. Clique no botão Câmera da janela de exibição Perspective (parte superior esquerda) e
fazer três duplicatas do obstáculo (ou seja, os dois canos e a proximidade escolha Criar Câmera na Vista Atual . Nós posicionamos o nosso em
gatilho) e posicioná-los como uma série , a 15 metros de distância no eixo X. Faço 471, 587, 100 .
Certifique-se de nomeá - los e vinculá- los com cuidado! 4. Encontre sua nova entidade de câmera no Level Explorer e renomeie -a
( Dica : expanda as entidades ligadas no Level Explorer e selecione tudo GameOverCamera .
você quer copiar lá. Você também pode classificar os elementos no Level Explorer 5. Em uma seção em branco do seu FG_Main Flow Graph, adicione uma câmera : View
clicando em qualquer nome de coluna. No entanto, observe que os elementos são agrupados por nó. Atribua sua entidade GameOverCamera a ela.
tipo de entidade ao classificar pelo nome.) 6. Adicione um nó Missão : GameToken . Defina o token para booIsDead e
Nota : o tubo inferior mais à direita deve estar em 440, 500, 96 . Compare para verdadeiro . Isso significa que estamos perguntando se é verdade
que booIsDead = true - ou seja, o jogador está morto?
Configurando um jogo sobre a câmera 7. Arraste a saída Equal do seu nó Mission : GameToken para o
Ativar entrada de sua câmera : Exibir nó para ativar sua nova câmera
1. Posicione seu jogo sobre o grupo de texto atrás de FlappyCam. Nós usamos 472, na morte do jogador.
555, 100 .
Salve e teste . Quando você estiver feliz, torne os nós limpos e adicione um “JOGO
2. Navegue na sua vista em perspectiva para obter a visão desejada do jogo SOBRE ” caixa de comentários ao redor deles. Você também pode querer experimentar
texto com o jogo por trás dele. adicionando um atraso antes de mudar para o jogo através da câmera para fazer o
transição menos dissonante.

4. Copie todos esses nós e substitua os nós antigos nos outros três
tubos.
Parando o movimento da tubulação na morte
Desabilitando o salto após a morte
Desde que vamos voltar para uma câmera com uma perspectiva diferente e
ver todos os tubos simultaneamente, vamos parar o movimento horizontal deles Se você testar ou analisar seu design cuidadosamente, você também descobrirá que
morte: não parou o pássaro de responder à chave de salto, mesmo depois de colidir
e supostamente "morre". Vamos desabilitar isso na morte:
1. No pipeMovement Flow Graph do pipe1_bottom , adicione um
Missão: nó GameToken . 1. No seu FG_Main Flow Graph, arraste a saída Equal do seu
Nó GameToken no jogo sobre a seção para a entrada Desativar do
2. Definir o do GameToken token para booIsDead e Compare Para a verdade.
Nó ActionListener na seção Configuração inicial . Ou seja, você não precisa
3. Arraste o nó Saída da missão: GameToken para a entrada Stop quaisquer novos nós; você só precisa perguntar ao nó que monitora atualmente
do nó MoveEntityTo . Como o nó GameToken é sempre
o valor de booIsDead para desativar o ActionListener que foi
escutando o valor do token, assim que for definido como true , o pipe escutando a tecla de salto.
o movimento irá parar instantaneamente. (Como nossos tubos não têm massa , existe
nenhuma aceleração ou desaceleração, nem a gravidade os afetará).

09: aprimoramentos abordagens para escondê- lo. Uma maneira fácil de esconder o terreno é simplesmente abaixá- lo
então está submerso : no Editor de terreno , escolha Editar > Definir terreno máximo
Altura . A altura do oceano padrão é 16m, então qualquer coisa menor que isso é
Neste ponto, você tem um jogo totalmente funcional, embora básico. Este capítulo
embaixo da agua. (Você também pode usar o mesmo menu para ajustar a altura do oceano:
oferece apenas algumas das muitas melhorias que você pode adicionar ao seu jogo
Edit > Remove Ocean não o remove; ele simplesmente define sua altura para -
projeto para torná-lo mais interessante e mais bonito.
100000m.)
Escondendo terreno A segunda abordagem é esconder o terreno, onde quer que esteja - mas mantenha-se
lembre-se que, embora possa ser invisível, os objetos ainda reagirão normalmente,
Você já deve ter notado que esconder o terreno do editor por como o seu pássaro quando ele cai, o que pode ser confuso para os usuários:
clicar no botão Exibir não o oculta permanentemente no jogo se você
saia e reinicie o CRYENGINE. 1. Abra o seu FG_Main Flow Graph e encontre o seu nó Game : Start .
2. Adicione um nó Debug : ConsoleVariable ao seu gráfico. Um console

Se você olhar no menu Editar do editor de terreno, verá Apagar terreno . Se vocês
Variável ou “cVar” pode ser definido no editor usando a ferramenta Console
clique sobre isso, você verá que a questão é se você quer apagar o
(uma ferramenta de linha de comando). Defina o parâmetro C Var para e_terrain , e o
mapa de altura - informação que esculpe o terreno fazendo colinas e vales -
Valor para 0 .
não o terreno em si. Se você fizer isso, simplesmente vai achatar o terreno, não
remova. 3. Arraste o nó Saída do jogo: Iniciar para a entrada Definir do seu
Depuração : nó ConsoleVariable para forçar o terreno a ser escondido no jogo
Enquanto você não pode instantaneamente remover o terreno (embora você possa meticulosamente começar.
use a ferramenta Make Holes do Terrain Editor para apagá-lo pouco a pouco), existem alguns
CRYENGINE Flappy Boid Course Ver. 5.5D - 42 - 09: aprimoramentos

Adicionando uma Configuração Global de Dificuldade Note que é uma boa prática de programação para indicar o
tipo de variável dentro do próprio nome da variável . É comum
Nosso jogo existente fica chato muito rapidamente, desde que o prática de usar prefixos abreviados como int para integer, boo
os tubos se movem exatamente da mesma maneira em todas as passagens. Vamos adicionar dois Dica Pro : para booleano, str para string, etc. Você pode usar qualquer convenção
Escolha seus nomes de token de jogo
aprimoramentos: primeiro, torne o jogo mais rápido como a pontuação do jogador você prefere, mas a consistência é a chave. Esta prática é uma grande ajuda
pensativamente. Se você decidir
sobe, e segundo, vamos adicionar movimento vertical aleatório para com depuração!
os canos. renomear um token de jogo depois
você criou nós do Fluxograma 3. Vamos mapear esta dificuldade para um intervalo de tubo
Como esses dois recursos (junto com o espaçamento de tubo horizontal) que referência, essa
mudança de nome velocidades : adicione um nó Logic : DeMultiplexer . Arraste o para fora
afetam a dificuldade de todo o jogo, um bom aprimoramento que NÃO vai cascata através do seu Valor do nó GameTokenSet para a entrada Index do
você pode adicionar mais tarde na interface do usuário é convidar os jogadores para escolherGráfico
o seu de Fluxo; voce terá que Nó DeMultiplexador .
próprio nível inicial de especialização e para modificar a dificuldade do jogo encontrar manualmente e alterá-los
4. Como nossos níveis de dificuldade são 1-4, isso irá desencadear
adequadamente. um por um! (Busca do gráfico de fluxo
Portas 1-4 no DeMultiplexer. Adicione quatro
ferramenta é útil com isso.)
Vamos adicionar um token de jogo para a dificuldade geral do jogo: Missão: nós GameTokenSet . Em cada um deles, defina
Token para o seu token de jogo Level.fltPipeSpeed .
1. Use sua ferramenta DataBase > Tokens de jogo para adicionar
novo token de jogo inteiro chamado intDifficulty . 5. Arraste as portas 1-4 para cada uma das entradas do acionador do
quatro nós GameTokenSet , como mostrado na captura de tela.
2. Na seção de configuração inicial do seu FG_Main Flow Graph, adicione um
6 Defina a propriedade Value de cada nó GameTokenSet como desejado
Missão : nó GameTokenSet . Arraste a Saída do Jogo: Start
nó para a entrada Trigger do nó GameTokenSet . velocidade do tubo. Dado o nosso design de jogo, sugerimos 3 , 4 , 6 e 8 (de
mais lento para mais rápido).
3. Defina o Token para Level.intDifficulty .
7 Já que estamos prestes a adicionar movimento vertical aos nossos tubos, vamos definir o
4. Vamos usar uma escala de dificuldade simples de 1 a 4 , onde 1 é o mais fácil e gama de movimento de tubo vertical com base nesta dificuldade: use
4 é o mais difícil. Defina o de GameTokenSet valor para 1, 2, 3 ou 4, sua ferramenta DataBase > Tokens de jogo para criar um novo tipo inteiro
como preferir. Token do jogo. Chame-o de intVertPipeMovement .
Dado que estamos prestes a adicionar velocidade de tubo horizontal dinâmica, precisamos de um jogo 8 Adicione mais quatro nós de Missão : GameTokenSet e defina seu Token
token que podemos definir inicialmente e modificar cada vez que o jogador marcar: propriedade para o seu nível . Token do jogo intVertPipeMovement .
1. Na ferramenta Database , crie um novo token de jogo de ponto flutuante chamado 9 Arraste o Valor de Saída de cada um dos nós GameTokenSet que definiu
fltPipeSpeed . seu fltPipeSpeed para as entradas de gatilho desses quatro novos
2. O valor inicial não importa, porque vamos inicializá- lo com Nós GameTokenSet que vão definir o intervalo do tubo vertical
um jogo: inicie o nó. movimento.
Estamos usando um número de ponto flutuante que permite valores à direita do 10. Por último, defina a propriedade Value dos seus quatro nós GameTokenSet para
casa decimal. Se usamos um inteiro, o menor aumento possível na velocidade a gama desejada de movimento de tubo vertical. Dados os fatores em jogo
seria 1, o que acabaria acelerando a velocidade do jogo tão rapidamente que - o espaçamento horizontal dos nossos tubos, a velocidade das aves, a força do
rapidamente se tornaria injogável. gravidade, e a força de salto para cima - sugerimos valores de 3, 6, 8 e
10 . (Como sempre, esta distância está em metros.) Qualquer um maior que ± 10m

alcance, e seu jogador não será capaz de saltar ou cair rápido o suficiente para o progresso será imediatamente afetado, porque o nó GameToken
navegue pelos canos, não importa o quão habilidosos eles sejam. está sempre ouvindo o valor de seu Token.
Mais tarde, adicionaremos uma interface de usuário completa que solicitará que os jogadores escolham um dos
estes quatro níveis de dificuldade quando o nível é carregado.
Adicionando Velocidade de Tubo Horizontal Dinâmico
Vamos nos livrar da velocidade codificada e conduzir nossos movimentos de tubo com o
token de jogo de velocidade de cano que nós já criamos e inicializamos:
1 Como já inicializamos um token de jogo fltPipeSpeed em nosso

Configuração inicial, vamos alimentá-lo para o movimento horizontal do pipe1: no
o fluxograma do pipeMovement para pipe1_bottom , adicione um
Missão : nó GameToken . Defina sua propriedade Token para o
FltPipeSpeed Token de jogo que nós já criamos.
2 Arraste a Saída do nó GameToken para a entrada Valor do
3 No seu nó MoveEntityTo , certifique-se de que a Atualização Dinâmica esteja definida como 1 .

Isso força o nó a ouvir e responder constantemente às entradas.
Dica Pro :
Outra maneira de manter o fluxo complexo Salve e teste . Quando tiver certeza de que isso é perfeito, selecione todos esses
Gráficos simples e fáceis como nós, copie- os, exclua os nós antigos nos Fluxogramas para os tubos 2, 3 e
possível depurar, você pode alterar 4 e cole os novos nós nos gráficos do pipeMovement .
a curvatura da conexão
Em seguida, precisamos aumentar a velocidade do cano toda vez que o jogador marcar :
linhas por clique e arrastando
horizontalmente na alça circular 4. Na seção Pontuação do seu gráfico de fluxo do FG_Main , adicione um
no meio do conector. este Missão : nó GameTokenModify .
ajudará a evitar linhas de
5. Definir o GameTokenModify do nó token para intScore eo Valor
sobreposição.
para 1 .
6. Arraste o Out of your Logic: Qualquer gate para a entrada Trigger do

Missão : nó GameTokenModify .
7. Defina a operação para adicionar e o valor para 0,2. Note que o maior
Movimento : nó MoveEntityTo . O antigo valor que nós codificamos
esse número, quanto mais rápido os canos aceleram à medida que o jogador ganha, e
na entrada Valor será ignorado em favor do sinal enviado pelo
quanto mais difícil o jogo. Teste e ajuste conforme desejado. Mais tarde, você
Nó GameToken. Note que desde MoveEntityTo está usando velocidade (como
poderia modificar isso com base na dificuldade selecionada pelo usuário.
oposta ao tempo), sempre que este Token de Jogo muda - ou seja, cada
tempo que o jogador marca - a velocidade do movimento do cano já Salve e teste !

Adicionando movimento de tubo vertical aleatório certifique-se de que o espaço não fique muito apertado para o jogador navegar
através dele?
Isso requer um planejamento cuidadoso e há mais de uma abordagem!
• Como você vai limitar o quão longe os tubos se movem verticalmente para garantir que
Considere estas perguntas:
o jogo permanece jogável ? Ou seja, você não pode permitir que os canos acabem tão longe
• Você ainda pode usar seus pontos de tag ai_start e ai_end como destinos para acima ou abaixo do conjunto anterior que o jogador não pode pular ou cair rápido
seus movimentos, mas adicionar randomização? Eles podem ajudá-lo, ou você o suficiente para navegar pela lacuna.
precisa de uma abordagem diferente?
• Você quer que cada par de tubos viaje em linha reta no X
• Se cada par de tubos mantiver uma lacuna consistente entre as partes superiores eixo, ou você gostaria que eles oscilar - para mover-se verticalmente para cima e
e tubos inferiores, ou a diferença deve variar ? Se você variar, como você vai várias vezes durante a viagem pela tela?

• Como você ajustará a velocidade do tubo para as variações na distância campo de jogo no mesmo período de tempo , que mantém os tubos uniformemente
entre os pontos inicial e final criados pela mudança do início e do fim espaçado.
aponta para cima ou para baixo? Ou seja, enquanto os tubos originalmente se moviam 60m em um
No pipeMovement Flow Graph para pipe1_bottom, precisamos randomizar
linha reta ao longo do eixo X, assim que os pontos de início ou fim se movem
ao valor de Z (dentro de um intervalo restrito) da posição do ai_end antes que seja
para cima ou para baixo, essa distância aumenta. Então você não pode simplesmente mover todos
passou para o nó MoveEntityTo. Aqui estão os passos:
canos na mesma velocidade, ou eles não serão uniformemente espaçados. Por exemplo,
quanto mais inclinado o ângulo, maior a distância que deve ser percorrida e 1. Antes de começarmos a randomizar a posição vertical desses tubos, precisamos
quanto mais esses tubos vão cair atrás de tubos que estão viajando mais curtos para saber o intervalo vertical determinado pela dificuldade: adicione um
distância. Se os tubos se juntarem, torna-se impossível para o jogador Missão : nó GameTokenGet e defina seu token para o
para pular ou mergulhar rápido o suficiente para navegar através deles. Nível . Token do jogo intVertPipeMovement .
2. Arraste a Saída da sua Lógica mais à esquerda : Qualquer nó (aquele cujo In1
Tome um minuto para discutir algumas abordagens possíveis com seus colegas ou
entrada está conectada ao nó Game: Start) à entrada Trigger do
faça um brainstorming por conta própria se estiver trabalhando nesse curso de forma independente
Nó GameTokenGet .
antes de ligar para a nossa solução.
Vamos precisar usar o limite superior para a posição Z do tubo definida no
Como abordagem inicial, eis o que vamos construir; se você estiver trabalhando
intVertPipeMovement Token de jogo para estabelecer também um limite inferior . Nós podemos
independentemente, você pode tentar suas próprias variações:
faça isso simplesmente multiplicando o valor original por -1:
• Os Tag Tag ai_start e ai_end são úteis porque nos dão X 3 Adicione um nó Math : Mult . Arraste o Valor de Saída de
e coordenadas Y. Tudo o que temos a fazer é adicionar e subtrair um o nó GameTokenGet do intVertPipeMovement para a entrada A do
número aleatório do valor Z existente . Matemática: nó Mul . Defina o valor B como -1 .
• Precisamos que esse número aleatório seja limitado para que os tubos não se movam assim 4 Agora para a randomização: adicione esses nós: Vec3 : FromVec3 ,
muito para cima e para baixo que eles desaparecem ou os obstáculos se tornam Matemática : Aleatório , Matemática : Adicionar e Vec3 : ToVec3 .
impossível navegar. Isso só pode ser determinado por testes. 5 Arraste o nó Out of the Math: Mul para as entradas Generate e Min de
• Nós vamos embaralhar ambas as posições de início e fim Z para fazer a tubulação o nó Math: Random para definir nosso intervalo de randomização.
movimento mais interessante. 6 Arraste a saída Pos do nó ai_end para a entrada Vec3 do
Nó FromVec3 . FromVec3 simplesmente separa um tridimensional
• Nós vamos apenas mover os tubos em uma linha reta no eixo X a partir de ai_start
coordena (Vec3) em valores X, Y e Z.
para ai_end por enquanto, adicionando oscilação (múltiplos movimentos ao longo do Z
eixo durante cada passagem) será mais complexo. Adicionando muitos recursos 7 Arraste as saídas X e Y do nó FromVec3 para o X e Y
simultaneamente complica bastante a depuração! entradas do nó ToVec3 . Nós não precisamos modificar essas coordenadas,
apenas para passá- los para o nó de movimento como está.
• Por enquanto, vamos mover cada par de tubos juntos e não variar o intervalo
8 Arraste a saída Z do nó FromVec3 para a entrada A do
entre eles.
Matemática : adicionar nó. Esta é a posição Z não modificada de ai_end.
• Para se certificar de que cada par de tubos viaja do início ao fim no 9 Agora precisamos adicionar o deslocamento aleatório à posição Z existente de ai_end:
exatamente o mesmo período de tempo, vamos multiplicar a distância real pelo arraste a porta Out do nó Math : Random para a entrada B do
distância em linha reta para derivar um fator que vamos multiplicar vezes o
velocidade atual do tubo. Isso garante que todo tubo atravesse o

Matemática : adicionar nó. (NOTA: não há diferença entre A e B no Ler estes passos é provavelmente mais confuso do que simplesmente olhar para o
Matemática: adicionar nó; eles são simplesmente adicionados juntos e enviados para o Out.) gráfico em si! Reserve um minuto para investigar e rastreie a lógica até que você
10. Adicionamos o deslocamento aleatório a Z; agora, vamos passar no entende isso.

MoveEntityTo: arraste o nó Out of the Math : Add para a entrada Z de
o nó ToVec3 . Este nó simplesmente combina X, Y e Z separados Ajustando a velocidade do tubo para a distância real de deslocamento
valores em uma coordenada tridimensional (Vec3).
Agora chegamos a um pouco complicado de matemática e lógica: uma vez que nossos tubos estão começando
11. Finalmente, arraste o Vec3 saída do ToVec3 nó para o destino
e terminando em diferentes posições Z, a distância que eles têm para viajar não é
entrada do nó MoveEntityTo .
mais uma linha reta no eixo X ; é um ângulo . E se você pensar em voltar para

faça isso dividindo a distância em linha reta (o X de ai_start para o X de
ai_end) na distância real inclinada. Isso nos dará um número um pouco
maior que 1, o que podemos multiplicar pela velocidade do tubo. (Note que se o
Z aleatório de ai_start e ai_end são exatamente os mesmos, o pipe
vai viajar em linha reta, e nosso fator de velocidade será exatamente 1 - não tendo
efeito):
1. Vamos pegar a atual posição atual do tubo para que possamos medir o
distance to ai_end: adiciona um nó Entity : GetPos . Clique com o botão direito nele e
Escolha Assign Graph Entity . (Note que devemos usar a corrente
posição do tubo, não a posição de ai_start, já que cada par de
tubos começam em diferentes posições no início do jogo.)
2. Arraste o Vec3 saída do Vec3: ToVec3 nó ao Obter entrada de

sua geometria do ensino médio, você vai lembrar que esta linha angular é sempre nó GetPos da entidade do gráfico .
vai ser mais longo do que uma linha puramente horizontal, como mostrado neste diagrama.
3. Adicione um nó Vec3: SubVec3 . Arraste o Vec3 saída do ToVec3
O problema é que nossa velocidade de cano atualmente não leva isso em conta; todos nó (na seção que você acabou de criar que randomiza a extremidade Z
os canos são orientados a se mover na mesma velocidade , mas as distâncias que eles têm que percorrer posição) para a entrada A do nó SubVec3 que você acabou de adicionar.
não são mais iguais. Isso significa que os canos não percorrerão essa distância em um
4. Arraste a saída Pos do nó GetPos para a entrada B do SubVec3
duração igual de tempo . O resultado é problemático: os tubos se aproximarão ou
nó. Este nó está agora calculando a diferença entre os
afastar-se mais, afetando a jogabilidade do jogo. posição atual e posição final recentemente randomizada a que se
Para consertar isso, precisamos ter certeza de que cada par de tubos atravesse seu começo-para- está prestes a ser movido - mas como um tipo de dados Vec3, que consiste em
distância final em exatamente o mesmo período de tempo, independentemente da distância . Bem diferenças separadas em X, Y e Z.

5. Vamos calcular a distância como um valor numérico único: adicionar um 9. Finalmente, estamos prontos para calcular um fator de distância: add a Math : Div
Vec3 : nó MagnitudeVec3 . Arraste o nó Out of the SubVec3 para (dividir) nó. Arraste a saída Comprimento do seu nó MagnitudeVec3
a entrada Vector do nó MagnitudeVec3 . à sua entrada A e ao nó Out of your Math : Sub na entrada B.
A saída Comprimento nos dará a distância real que esse tubo deve percorrer. Agora Etiquete este nó para calcular a diferença entre a linha real e a reta
distância."
vamos calcular qual seria a distância se o tubo viajasse em linha reta
ao longo do eixo X. Para fazer isso, dividiremos as coordenadas Vec3 em X separado 10. Agora, vamos multiplicar esse fator pela velocidade do tubo atual: adicionar um
Y e Z valores, e apenas medir a distância de X a X: Math : Mul (multiplique) nó. Arraste o nó Out of the Math : Div para
a entrada B e a Saída do nó GameToken de fltPipeSpeed para
6. Adicione duas Vec3 : FromVec3 nós. Arraste a saída Vec3 do
a entrada A.
ToVec3 nó da entrada Vec3 do seu primeiro nó FromVec3 . Ajudar
você acompanha o que esses nós estão fazendo, adicione um comentário acima 11. Vamos alimentar a velocidade ajustada ao movimento entidade: arrastar o Out of
este primeiro nó do FromVec3 que diz "obtenha a posição do ponto final". a matemática : Mul nó para tanto o valor e os Iniciar entradas do
Nó MoveEntityTo .
7. Arraste a saída Pos do nó GetPos da entidade do gráfico para o Vec3
entrada do outro nó FromVec3 .
Randomizing Z of Pipe Start Point
8. Agora vamos fazer a diferença na posição X entre o tubo e seu
posição final pretendida: adicione um nó Math : Sub (subtrair). Arraste o X Nós randomizamos com sucesso o Z do ponto final e ajustamos a velocidade
saídas de seus dois nós FromVec3 para as entradas A e B do para a distância real. Agora vamos randomizar o ponto inicial Z :
Matemática: subnó, respectivamente. Etiquete este nó “calcule a linha reta
1. Primeiro, vamos mais uma vez obter o intervalo de randomização Z salvo no jogo
distância."
start: adicione um nó Missão : GameTokenGet e defina seu token para o

Nível. Token do jogo intVertPipeMovement . Arraste a saída Finish de 6. Novamente, vamos apenas passar os valores X e Y não modificados : arraste ambos
o nó MoveEntityTo para a entrada Trigger . as saídas X e Y do nó FromVec3 para as entradas X e Y de
2 Adicione um nó Math: Mult . Arraste th e Emitidas Valor de GameTokenGet o nó ToVec3 .

nó para th PT A entrada . Definir th e B valor t O -1 . 7. Vamos passar a posição Z existente de ai_start para modificação: arraste o
3 Podemos economizar algum tempo copiando e colando os mesmos quatro nós Saída Z do nó FromVec3 para a entrada A do nó Math : Add .
que randomizado ai_end's Z. No entanto, queremos colar apenas os nós, 8. Arraste o nó Out of the Math : Random para a entrada B do
não os links, senão teremos espaguete! Arraste seu mouse Matemática : adicionar nó.
em torno do Vec3 : FromVec3 , Math : Random , Math : Adicionar e
9. Arraste o nó Out of the Math : Add para a entrada Z do ToVec3
Vec3 : ToVec3 nós, Ctrl - C para copiá-los, clique com o botão direito do mouse à esquerda nó. Isto combina os X e Y existentes com o Z aleatório em
o nó BeamEntity e escolha Editar > Colar sem Links . (Ou uma coordenada Vec3.
Ctrl-Shift-V )
10. Finalmente, arraste o Vec3 saída do ToVec3 nó para tanto o
4 Arraste o valor de saída do nó GameTokenGet para a entrada máxima de
Entradas Position e Beam do nó BeamEntity .
o nó Math : Random . Arraste o nó Out of the Math : Mul para o
Entrada mínima do nó Math : Random . Salve e teste ! Brinque com isso por vários ciclos até ficar satisfeito
os pontos inicial e final são randomizados para o primeiro conjunto de tubos. Este é um bom
5 Exclua o conector antigo da saída Pos do ai_start para o BeamEntity
hora de esconder os outros três conjuntos de tubos para garantir que seu gráfico esteja livre de bugs
Entrada de feixe. Em seguida, arraste a saída Pos da entidade ai_start para o
antes de copiá-lo para os outros tubos.
Vec3 entrada do FromVec3 nó. Mais uma vez, isso separa o ai_start
posição em X, Y e Z. Depois de corrigir os bugs, copie todo este fluxo de movimento do Fluxograma para
os outros três canais na pasta pipeMovement , certificando-se de
exclua completamente os nós antigos primeiro!

Adicionando Death Triggers Para Restringir o Jogador Em suma, precisamos evitar que o nosso jogador acidentalmente ou deliberadamente
"Fora dos limites", ficar confuso ou frustrado, ou quebrar o jogo. Nós podemos
Existem situações que temos que considerar em nosso design de jogo: o que use um conjunto adicional de gatilhos de proximidade diretamente acima e abaixo do nosso
acontece se o jogador deixar Flappy cair para baixo antes mesmo dos canos FlappyBoid para evitar isso "matando" o jogador em contato:
alcançar? O que acontece se eles pulam tão rápido que passam por cima
1. Crie dois gatilhos de proximidade e posicione-os diretamente acima e
os canos?
abaixo do seu player, como mostrado nesta foto. Dimensões sugeridas para

seus gatilhos: 10x10x1m. (Lembre-se, para escalar gatilhos de proximidade, editar 7 Adicione um nó Missão > GameTokenSet ao seu Fluxograma.
suas propriedades Lua > Dim X / Y / Z, não Transform> Scale.) 8 Arraste o Out of your Logic : qualquer nó para a entrada Trigger do seu
2. Vamos usá-los como nossos gatilhos de "morte". Nomeie- os como deathTriggerTop Nó GameTokenSet .
e deathTriggerBottom . 9 DICA : você pode recolher uma lógica: qualquer nó para mostrar apenas as entradas usadas
Você provavelmente vai querer experimentar o quão longe acima e abaixo do jogador (ou qualquer número de entradas que você escolher) clicando na seta na sua
para posicioná-los, e isso vai depender da amplitude de movimento vertical que você canto superior direito.
programado no movimento do tubo. 10. Nas Propriedades do nó GameTokenSet , defina o token para
Muito perto, e o jogador pode não ser capaz de desviar de canos que se movem para o booIsDead e o valor para true .
limites extremos de suas restrições verticais sem morrer sem aparente 11. Adicione uma caixa de comentários em torno desses nós interconectados e nomeie -o
razão e tornar-se frustrado. Longe demais, e Flappy pode passar por cima ou por baixo do "Protect Game Boundaries" ou o que você achar descritivo.
tubos. Salve e teste!
Colocamos os nossos 11 metros acima e 11 metros Uma melhoria sugerida para você trabalhar de forma independente seria fazer
Dica Pro :
abaixo de Flappy e, claro, a 500 X, 500 Y. À medida que seus gráficos de fluxo aumentam, estes limites do jogo visíveis , então o jogador sente que eles foram razoavelmente
3 Lembre-se que o nosso FlappyBoid não é você pode precisar conectar dois avisou sobre os limites dentro dos quais eles podem pular ou cair.
nós que estão distantes no
o "jogador", tanto quanto GameSDK é
em causa. Desmarque o único jogador
gráfico. Se você diminuir muito o zoom (para Fazendo o nível recarregar automaticamente após a morte
ser capaz de ver aqueles díspares
caixa em Propriedades > Lua
nós), você não poderá clicar Depois de exportar seu jogo como um aplicativo independente, quando
Propriedades para ambos os gatilhos de proximidade.
nas portas com precisão, a fim de jogador morre, eles terão que reiniciar o jogo manualmente. Como isso poderia ser
4 Nós não queremos colisões com os canos conecte-os. A solução é bastante irritante para os próprios jogadores que queremos ficar viciados em jogar
para desencadear esses gatilhos, então precisamos
zoom em uma porta, clique na porta nosso jogo mais e mais, vamos fazer o nível recarregar automaticamente após a morte:
ser específico : Cole “FlappyBoid” ou o seu
e comece a arrastar um conector
nome exato da entidade do jogador no com o botão esquerdo do mouse, 1. Vá para a seção Game Over do seu FG_Main Flow Graph.
Propriedades> Propriedades de Lua> Apenas 2. Adicione um nó Missão : LoadNextLevel .
enquanto segura a esquerda
Caixa Entidade Selecionada . botão, use a roda de rolagem e 3. Defina o valor Next Level do seu nó Mission : LoadNextLevel para o
5 Adicione as duas entidades a uma área vazia de botão direito do mouse para navegar nome real do seu nível. Certifique-se de copiá-lo e colá-lo
seu gráfico de fluxo do FG_Main . (Selecione veja o nó de destino, então
o File Explorer ou digite-o exatamente certo! Isso força o nível a recarregar
ambos, clique com o botão direito no seu Fluxograma complete a conexão. depois da morte do jogador.
e escolha Adicionar entidade selecionada .)
4. Arraste a saída Equal do seu nó Mission : GameToken para o
6 Precisamos sentir se o jogador colide com ou Entrada do acionador do seu nó Mission : LoadNextLevel .
da nossa morte desencadeia. Adicionar uma lógica: qualquer nó ao seu fluxograma e
mapa do Enter saída da proximidade aciona a In1 - In2 Nós forçamos o nosso único nível de jogo a recarregar assim que o jogador morre, mas
entradas de sua lógica: qualquer nó. há um problema com isso: isso acontecerá imediatamente e o jogador
Nunca tenha a chance de ver o seu texto "game over"!
Quando o jogador colide com um dos nossos gatilhos de "morte", queremos definir
nossa variável booIsDead para true :

5. Vamos inserir um atraso para dar ao jogador tempo para "chorar" após a morte: Missão : GameToken nó eo Mission : LoadNextLevel nó
clique com o botão direito no ponto central do conector entre o e escolha Time Delay .
6. Defina o valor de atraso para talvez 3 ou 4 segundos.

Observe que recarregar o mesmo nível não funcionará quando você estiver usando o Editor - ou seja, no modo de teste de jogo, apenas uma vez que você exportar o jogo como um stand-alone

Aplicação .EXE. 5. Na seção "Movimento da câmera" do seu gráfico de fluxo do FG_Main , localize
o nó Vec3: SubVec3 que ajusta a posição alimentada por FlappyBoid
Minimizando a distorção da lente usando o FOV da câmera e alterar os deslocamentos X e Y (o parâmetro B ) para corresponder ao
diferença entre a posição X e Y de FlappyBoid e X de FlappyCam
Você deve ter notado que os canos na borda da tela, bem como os e posição Y no editor: X 17 , Y - 55 .
Esfera olhar esticado horizontalmente. Isso é porque o motor está imitando
Salve , teste e ajuste até ficar satisfeito com a aparência do seu jogo.
como as coisas parecem através de lentes normais a amplas, e nosso padrão atual de FOV
(campo de visão) é razoavelmente largo a 60º. DICA : Você pode achar que deseja diminuir sua caixa de segundo plano se
aperte o FOV do seu FlappyCam, ou encolha a textura da nuvem para evitar ver
Para mudar isso, precisamos sobrescrever o FOV do FlappyCam no Flux Graph com um
pixilation. (Você também pode precisar ajustar a textura e a oscilação.)
ângulo menor. No entanto, isso significa que veremos menos horizontalmente e
Reduzir o FOV efetivamente torna sua “lente” mais longa, o que comprime
verticalmente. Assim, temos que também mover a câmera para mais longe do nosso
a distância aparente entre os objetos. Ou seja, sua caixa de fundo parece mais próxima
entidades:
e você não verá as bordas tão facilmente.
1 Tente usar duas viewports , uma definida como FlappyCam e outra com
Vista esquerda .
2 Mude o seu FOV atual na janela de visualização do FlappyCam para 30º . Apenas este
afeta a visão do Editor, não o jogo. Você verá que o FlappyCam
agora vê muito pouco de suas entidades.
3 Selecione a entidade FlappyCam no Level Explorer . Na esquerda

porta de visualização, arraste -o mais longe dos canos até que a visualização FlappyCam pareça
do jeito que você quer. Tente 483, 555 , 100.
4 Para efetuar isso durante o jogo, precisamos substituir o padrão de 60º

FOV no Flow Graph quando o jogo for lançado: encontre a Câmera : View
nó na seção INITIAL SETUP do seu FG_Main Flow Graph.
Altere o parâmetro FOV para 30º .
DESAFIO : Se você salvar e testar, você pode estar em uma Explorando Câmeras
surpresa grosseira. Por que as coisas parecem do jeito que são? Por quê
você está vendo tão pouco? Tente solucionar o problema Apenas mudando a posição da sua câmera pode ter um tremendo efeito sobre o
antes de olhar em frente para a resposta. aparência do seu jogo. Você pode querer sair do "side scroller"
olhe este jogo e experimente criar câmeras adicionais. Para
Você descobriu o problema? Embora você tenha movido o FlappyCam exemplo, tentando criar um que "segue" Flappy de perto por trás, como em
posição no editor, seu código do Fluxograma reposiciona dinamicamente para esta vista usando um deslocamento de -14X, -15Y e um FOV de 25⁰.
siga FlappyBoid! Você tem que ajustar o deslocamento da posição da câmera em
Fluxograma para corresponder à sua posição modificada no editor:

Finalização opcional: movimento da câmera 1. Clique para selecionar o seu grupo de entidades Game Over e selecione Level > Group
> Desagrupar a partir do menu.
Outra maneira de revelar o texto do Game Over seria simplesmente mover nossa
2. Selecione todas as oito letras e mova-as para baixo para que elas
FlappyCam para trás (chamado de “dolly back” na terminologia do filme). Nós
caixa plana por baixo deles.
já sabemos onde precisamos enviá-lo: para a posição do nosso
3. No Level Explorer , arraste todas as oito letras para o objeto da caixa para vincular
GameOverCamera. Vamos usar isso como destino e ter a câmera
eles para a caixa. Isso nos permitirá mover todo o jogo pelas entidades
passar por um período de um segundo:
apenas movendo o objeto pai da caixa, assim como fizemos com os pipes.
1. Na seção Game Over do seu FG_Main Flow Graph, adicione um
4. Posicione seu GameOverBox para que uma visão frontal dele esteja desviando o olhar
Entidade : EntityPos e um nó Movement : MoveEntityTo .
do resto do seu jogo. Nós posicionamos os nossos em 500, 715, 23.
2. Atribuir o GameOverCamera ao EntityPos nó para que ele possa consultar
5. Como queremos facilitar a rotação da câmera que será exibida
sua posição.
nos o jogo sobre o texto, certifique-se de que o seu jogo sobre entidades tem zero
3. Atribua o FlappyCam ao nó MoveEntityTo para que ele saiba o que rotação nos três eixos.
mover.
Em seguida, queremos criar uma câmera que inicialmente fica acima do oceano,
Arraste a saída Pos do nó EntityPos da GameOverCamera para o e fazer com que o jogo acabe com o texto, surpreendendo o jogador, caindo de cima do
Destino do nó MoveEntityTo do FlappyCam para que o movimento saiba FOV da câmera:
para onde enviar nossa câmera.
6 Posicione sua visualização padrão na viewport de perspectiva até que ela esteja procurando
4. No nó MoveEntityTo do FlappyCam , defina o Tipo de Valor para hora para o jogo sobre o texto, 18m acima da água, mas inclinado para baixo por isso
e o valor para 1 (segundo). Você pode escolher uma velocidade diferente se
não pode ver o jogo sobre o texto (verifique a exibição no modo de tela cheia).
quer um movimento de câmera mais lento ou mais rápido. Posicionamos nossa câmera em 500, 705, 18 com uma rotação de -15 ,X, como
5. Para ver isso, precisamos desativar nossa lógica criada anteriormente mostrado aqui.
permite a GameOverCamera , porque queremos continuar vendo
7 Quando estiver satisfeito com a sua visualização, clique no visor da perspectiva.
o jogo da nossa FlappyCam: clique com o botão direito do mouse no centro da Menu da câmera e escolha Criar câmera a partir da exibição atual .
conector entre a saída igual do nó GameToken e
Nomeie sua câmera como “DiveCam”.
Câmera : veja Ativar entrada e escolha Desativar. A linha deve
tornar-se pontilhada em vez de sólido.
Salve e teste batendo em um tubo. A câmera deve se mover para trás

revelar o jogo sobre o texto.
Final opcional: respingo e pia
Aqui está uma forma mais dramática de terminar quando o jogador morre: mude para um fim
vista do oceano, deixe o texto do jogo vir espirrar na água,
flutuar nas ondas por um momento e depois afundar a câmera sob as ondas
enquanto inclina-se para ver o texto “game over” quando este desaparece. Primeiro, certifique-se
seu oceano é visível nas configurações de exibição .

Agora, vamos adicionar a mecânica do jogo quando o jogo terminar: splash antes de afundar: adicione um nó Time: Delay e defina o Delay para 4
segundos.
8. Primeiro, abra a seção Game Over do seu Flappy> FG_Main Flow
Gráficos 15. Adicione um MoveEntityTo nó e RotateEntityToEx nó. Atribuir
DiveCam para os dois.
9. Se você estava usando o t_scale cVar para criar câmera lenta no final,
Clique com o botão direito e desative o conector para o Debug: ConsoleVariable 16. No nó MoveEntityTo , defina o Tipo de Valor para hora e o
nó que define isto quando booIsDead = true ou simplesmente o exclui. Valor para 8 segundos.
10. Vamos habilitar nossa nova câmera quando o jogador morrer: adicione um 17. No nó RotateEntityToEx , defina o valor X do destino como 45 ⁰ ,
Câmera: Visualizar nó; atribuir DiveCam a ele; e arrastar o Equal o Tipo de Valor para o Tempo e o Valor para 6 segundos. Isso fará com que o
saída do nó booIsDead Mission: GameToken para o Enable câmera inclinar-se para a 45 ⁰ ângulo como ele está afundando. Dependendo da distância
entrada da sua câmera: Visualizar nó. entre a câmera e o jogo sobre o texto, você pode querer ajustar
o tempo do movimento descendente e rotação. A ideia é
11. Tal como acontece com os tubos e FlappyCam, vamos afundar a câmera usando
mantenha a câmera olhando para o jogo enquanto ele afunda.
Entidade : MoveEntityTo. Adicione esse nó agora e atribua sua DiveCam
para isso. 18. Arraste o nó Out of the Time: Delay para as entradas Start do
Nós MoveEntityTo e RotateEntityToEx .
12. Vamos recuperar e compensar a posição original da câmera: adicione um
Entidade: nó GetPos e atribui o DiveCam a ele. Arraste os booIsDead Em seguida, vamos fazer nosso jogo cair e mergulhar no oceano:
Saída igual do Token do jogo à entrada Get do nó GetPos . 19. Para fazer nossas entidades de texto do jogo caírem, nós apenas temos que desabilitar o
Note-se que desde que só precisamos consultar a posição do DiveCam uma vez em
Descansando propriedade para habilitar gravidade: adicionar uma Entidade: PropertySet entidade
o jogo, estamos usando um nó GetPos disparado manualmente em vez de um e atribua o GameOverBox a ele. Clique na caixa de valor ao lado de
Nó EntityPos que está sempre escutando (e, portanto, exigindo computador Propriedade , em seguida, no botão .. e escolha a Física > bResting
Recursos).
propriedade. Defina o valor como falso .
13. Vamos adicionar o deslocamento Z para a câmera: adicione um nó Vec3: SubVec3 . 20. Agora só precisamos acionar esse nó quando o jogador morrer: arraste para
Arraste a saída Pos do nó GetPos da DiveCam para a entrada A do conecte a saída Equal do token de jogo booIsDead ao Set
Nó SubVec3 . Defina o valor Z do SubVec de B em 15 .
entrada do nó PropertySet .
14. Como precisamos dar tempo para que nossas entidades de Game Over caiam no
oceano, vamos adicionar um atraso para dar a câmera a chance de testemunhar isso

Randomizing Pipe Materials maneira eficaz de melhorar esta ilusão é trocar aleatoriamente o material em cada
conjunto de tubos como eles são enviados de volta para o ponto ai_start. Desde GameSDK
Desde o nosso design de jogo tenta criar a ilusão de que o jogador é fornece muitos materiais adequados, temos muitos materiais para melhorar o
navegando através de uma série interminável de tubos, tudo o que podemos fazer para esconder o ilusão de tubos sem fim:
O fato de estarmos usando apenas quatro tubos seria desejável. Um simples e muito

1 Abra o pipe_movement Flow Graph do pipe1_bottom e encontre o os gatilhos de entrada são usados.
Entidade : nó BeamEntity que envia seus pipes de volta para ai_start. Abaixo 5. Precisamos definir a propriedade General > Material de cada par de tubos:
todo o seu gráfico de fluxo, vamos criar uma nova caixa de comentários chamada adicione dois nós Material : EntityMaterialChange . Atribuir o tubo superior
algo como "randomize pipe material". para um desses nós, e a entidade do gráfico (ou seja, o tubo inferior) para o
2 Queremos texturizar nossos tubos a partir de uma lista aleatória de materiais no outro nó.
momento em que o jogo começa e toda vez que um par de canos é reiniciado Como podemos traduzir os inteiros aleatórios gerados pelo nosso nó Math: Random
ai_start: adicione um jogo : Inicie o nó e uma lógica : qualquer nó para o seu novo
em materiais da entidade? Se você selecionar um canal, clique em Geral > Material
seção (para lidar com as duas entradas). Arraste a saída Done do
propriedade na guia Propriedades, copie o texto para a área de transferência e cole -o
BeamEntity nó ao In1 entrada do Logic : Qualquer nó. Arraste o
editor de texto, você verá que isso é apenas uma seqüência de caracteres, especificamente um
Saída do jogo : inicie o nó para a entrada In2 da lógica : qualquer
caminho relativo para a pasta Materiais e o nome de um arquivo de material .
nó.
Então, precisamos da geração de um número específico para acionar a entrada Set do
3 Precisamos fazer uma seleção aleatória de uma lista de materiais: vamos adicionar
um nó Math : Random . Arraste o Out of the Logic : Qualquer nó para o Material : EntityMaterialChange e codifique um caminho de material específico
Gerar entrada do nó Math: Random. Defina seu Min para 0 e seu e nome na entrada Material do Material : EntityMaterialChange
Máximo a 7 . Por que 0 a 7? Adicione um nó Logic : DeMultiplexer e você nó. Como o nosso DeMultiplexer tem oito saídas, podemos escolher entre oito
veja que tem oito saídas, de 0 a 7. materiais.
4 Arraste a saída Out Rounded do nó Math : Random (Out Podemos fazer isso de duas maneiras: poderíamos ter 16 Material : EntityMaterialChange
Arredondado produz apenas números inteiros ) para a entrada Index do nós (um para o topo e um para o tubo inferior) predefinidos com 8 diferentes
Lógica : nó DeMultiplexador . Definir o modo do materiais e acioná-los diretamente das saídas Port do DeMultiplexer,
Lógica : nó DeMultiplexer para IndexOnly para garantir que apenas o índice ou podemos passar o material apropriado como uma string para uma lógica: qualquer nó com

apenas dois materiais : nós EntityMaterialChange . Este último usa menos nós, seu Fluxograma para os Fluxogramas do pipe_movement para os outros tubos - mas
e assim é uma escolha melhor: não se esqueça de atribuir o tubo superior correto para cada um dos seus
EntityMaterialChange nós! Não há necessidade de trocar o tubo inferior
6 Adicione oito nós String : SetString . Mapear a entrada Set de cada um deles
EntityMaterialChange node, como se refere simplesmente à Entidade Gráfica pai.
para uma saída de porta diferente do DeMultiplexer.
7 Você precisará escrever cuidadosamente o caminho exato e o nome do material Usaremos exatamente a mesma técnica de Fluxograma para randomizar a escolha de
a propriedade In dos nós SetString. Para evitar erros de digitação, recomendamos efeitos de partículas no próximo capítulo, quando adicionamos estrelas onde a nossa pontuação
alterar temporariamente a propriedade do material de um dos seus tubos, e gatilhos de proximidade são.
em seguida, basta copiar e colar da propriedade do material para o
Na propriedade SetString In: selecione qualquer canal no editor e clique no Desativando o efeito de morte do FPS no Game Start
botão de pasta ao lado da propriedade Geral> Materiais. Isso também dá
você tem a chance de ver uma prévia de como cada material ficará e Você deve ter notado que a primeira vez que você muda para o modo de jogo,
escolha seus oito favoritos. Recomendamos explorar o tijolo , a tela fica vermelha e depois fica com uma cor normal. Este efeito é a "morte"
pastas de concreto , metal e madeira dentro do GameSDK > Materiais efeito também usado quando o jogador morre, mas não faz muito sentido em nossa
> Pasta genérica . Evite materiais translúcidos como vidro. Atribuir um jogos. Podemos facilmente desativá-lo abrindo a pasta Material FX no Flow
material diferente para cada um dos seus oito nós SetString. Graph, clique com o botão direito sobre o player_death gráfico e escolha Desativar .
8 Para rotear essas oito strings diferentes para seus dois

Nós EntityMaterialChange , inclua uma Lógica : Qualquer nó à direita de
seus nós SetString. Arraste a saída de cada um dos seus nós SetString
para uma entrada diferente da sua lógica : qualquer nó.
9 Finalmente, arraste o Out of your Logic : Qualquer nó para o Set e Material

entradas de ambos os seus nós EntityMaterialChange .
Como sempre, isso é muito mais fácil de ver do que ler, então consulte a captura de tela de
o Fluxograma concluído, salve e teste em apenas um par de tubos. Uma vez
você está confiante de que está funcionando perfeitamente, copie e cole toda esta seção

10: Adicionando alvos de pontuação animados acima do oceano se você o tivesse movido debaixo d'água - ou simplesmente escondesse o
oceano. Na ferramenta Designer , selecione a entidade Cilindro . Role para baixo até
as propriedades do cilindro e definir a contagem de subdivisão para 5 para um cinco
Uma maneira fácil de dar ao jogo mais apelo visual e torná-lo mais
pentágono tomado partido.
satisfazendo-se a jogar é adicionar alvos visuais atraentes em vez de apenas
proximidade invisível desencadeia entre os tubos. Vamos adicionar algumas estrelas girando 1. Com sua grade tirar off , clique no terreno e mover o mouse para
crie um pentágono com cerca de 4m em sua face. Clique para parar o dimensionamento
e faça-os explodir quando o jogador os tocar, como se os colecionasse.
X / Y e mova seu mouse para cima para fazer sua espessura em Z 1m.
Primeiro, vamos modelar as estrelas usando a ferramenta Designer:
Clique no X ao lado da guia Designer na parte superior da perspectiva
Porta de visualização para sair da ferramenta Designer.
Modelando as Estrelas
2. Clique em outro lugar para cancelar a seleção do objeto Designer e, em seguida , selecione novamente
1. Para fazer isso, precisamos ver o terreno , então faça isso temporariamente isto.
visível através do menu Display da Perspectiva Viewport, ou posição
3. Na guia Seleção da ferramenta Designer, escolha Polígono . Clique em qualquer um dos
CRYENGINE Flappy Boid Course Ver. 5.5D - 62 - 10: Adicionando alvos de pontuação animados
as cinco faces laterais do seu pentágono para selecioná- lo. (Você verá um roxo
caixa no meio do polígono que ficará laranja quando selecionado.)
4 Na guia Avançado > Extrusão / Excluir da ferramenta Designer , selecione

Extrude ferramenta.
5 Clique e arraste a face selecionada para longe do meio do
pentágono até o seu comprimento é quase o mesmo que o próprio pentágono.
6 Sem desmarcar o pentágono ou a ferramenta Extrude, mantenha pressionado
Tecla Alt e clique com o botão esquerdo do mouse em cada um dos outros quatro
rostos para expulsá- los da mesma maneira que o primeiro. Mova sua câmera
em torno do pentágono, conforme necessário, para ver cada rosto antes de clicar nele. 3. Vamos copiar este material antes de modificá-lo: clique no botão Salvar
no Material Editor Legacy. Uma cópia aparece na lista de materiais.
7 Mais uma vez, selecione a ferramenta Designer > Seleção > Ferramenta Polygon .
Clique com o botão direito na sua cópia e escolha Renomear . Renomeie
Clique em qualquer uma das cinco faces externas para selecioná- lo. glass_frosted_red .
8 Clique na ferramenta Designer> Advanced> Extrude / Delete>
4. Modifique as configurações de cor especular e emissiva da iluminação conforme desejado para
Recolher a ferramenta. A face selecionada se tornará um único ponto .
torne sua estrela mais colorida, como neste exemplo.
9 Repita essas duas últimas etapas em cada uma das outras faces externas.
(Observe que, diferentemente da ferramenta de extrusão, você não pode usar a tecla Alt-Esquerda Convertendo Modelos de Designer para o Formato CGF
Botão do mouse clique para simplesmente repetir a transformação.) Consulte o
passo a passo fotos para orientação. A ferramenta Designer é uma ferramenta de whiteboxing - excelente para projetar rapidamente um nível,
mas os modelos que produz não são otimizados. Vamos otimizar nossa geometria de estrelas
10. Desmarque a estrela e selecione-a novamente . Use seu gizmo de rotação para aguentar
como se estivesse sentado em duas pernas. Use o seu snap de rotação para se certificar de que exportando-o como uma malha CGF, que também nos permitirá usá-lo como modelo
gira exatamente 90⁰ (ou -90⁰). Você provavelmente achará que também precisará para qualquer tipo de entidade de que gostamos:
para girá-lo ligeiramente em torno de seu próprio centro. 1. Com a estrela acabada selecionada, clique na ferramenta Designer >
Avançado > botão Exportar . Nas opções de exportação , clique no botão. CGF
Criando um Material de Vidro para as Estrelas botão. Salve seu arquivo como star.cgf no
Pasta GameSDK \ objects \ props \ flappy_boid .
1. Vamos dar um material à estrela: com a estrela selecionada, clique no
2. Agora você pode excluir o objeto de designer, ocultá-lo ou simplesmente deixá-lo
navegue ao lado de Material na janela Propriedades > Geral .
Selecione GameSDK > materiais / genéricos / glass / glass_frosted . em algum lugar fora da vista.
3. Use a ferramenta Criar objeto para adicionar uma entidade herdada > física >
NOTA: Se a sua câmera estiver posicionada de modo que sua caixa de fundo da nuvem
BasicEntity ao seu nível. Como de costume, o modelo padrão é uma esfera.
atrás da estrela, ela desaparecerá. Vamos discutir como endereçar este shader
Arraste -o para o terreno.
questão mais abaixo; por enquanto, reposicione sua câmera para o fundo da nuvem
caixa não é visível atrás da estrela.) 4. Selecione o BasicEntity e desça na Propriedades janela para
Lua Properties > Model e clique no botão procurar ao lado
2. Vamos tornar o material mais colorido : no Material Editor Legacy, primitive_sphere.cgf. Selecione seu
clique no botão Obter propriedades da seleção . O glass_frosted Malha GameSDK \ objects \ props \ flappy_boid \ star.cgf .
o material é selecionado e suas propriedades exibidas.
5. Nomeie sua primeira estrela como "ScoreStar1". 5. Defina sua velocidade no eixo Z para 2 . Você pode querer experimentar com o
velocidade, dependendo de quão rápido o seu movimento do tubo está definido. Se você realmente
Considerando problemas de Shader quer tornar seu jogo dinâmico, você pode criar um Token de jogo para
a velocidade da nuvem e incrementá-lo com a pontuação como você fez com o
Precisamos posicionar nossa estrela entre o primeiro conjunto de tubos, mas se você movê-lo movimento da tubulação.
então você está olhando com a textura da caixa de fundo / nuvem atrás dele, a estrela
6. Como o propósito do movimento do céu é simplesmente criar a ilusão de que
ficará invisível! (Gire a câmera para olhar para ela sem a caixa atrás nosso personagem Flappy está se movendo para a direita, vamos fazê-lo parar quando
para verificar se ainda está lá. o jogador morre : adicione um nó Missão : GameToken à esquerda do seu
Por que isso está acontecendo? Nó RotateEntity .
7. Defina o valor do token para o seu token de jogo booIsDead e

É porque mudamos o tipo de shader na caixa de fundo para
Compare para valor para true .
ReferenceImage , que remove todas as informações de iluminação e sombra . Desde a
nossa estrela tem um material de vidro translúcido, não pode ser renderizado na frente 8. Mapeie a saída Equal do nó GameToken para a entrada Pausada
caixa. do nó RotateEntity para fazer com que a rotação pause no player
morte.
Poderíamos mudar o material da estrela para algo opaco , mas já que estamos
planejando usar efeitos de partículas (fumaça, fogo, faíscas), teremos o mesmo Salve e teste , ajustando a velocidade conforme desejado.
problema: apenas partículas completamente opacas serão processadas.

Adicionando sombras de nuvens em movimento
Nós temos que mudar o shader da caixa de fundo de volta para Illum, o que significa
lidar com as sombras do tubo de alguma forma, ou encontrar uma maneira diferente de criar o nosso Outra maneira de estender a realidade física da iluminação é usar uma nuvem
fundo das nuvens. textura para simular sombras projetadas por nuvens. Fazemos isso nas configurações de nível:
1. Nas suas Configurações de Nível , vá até as propriedades do Cloud Shadows . Clique

Adicionando uma cúpula de céu animado na caixa ao lado de Cloud Shadow Texture e encontre o
textures / clouds / cloud_pattern.dds ou arquivo semelhante.
Aqui está uma opção comum para adicionar um céu nublado usando uma meia-esfera simples
que tem uma imagem de nuvem e céu texturizada: 2. Se você quiser que essa textura de sombra de nuvem se mova como se fosse do vento, defina
os valores da Velocidade da sombra da nuvem X e / ou Y para um número pequeno (Z
1. Primeiro, oculte ou elimine a sua caixa de fundo existente.
faz nada). Tente 0,005 .
2. Use sua ferramenta Criar Objeto para selecionar a Entidade de Malha Estática >
objetos > céu> forest_skydome.cgf modelo e arraste -o para o seu Configurando as estrelas de pontuação
nível. Você pode querer olhar para o seu nível da janela de exibição Top para
Certifique-se de que a cúpula do céu está centrada em torno de sua área de jogo. Seu Z 1. Mova e gire sua estrela conforme necessário para centralizá- la entre o primeiro
posição deve ser 0. Nomeie-o SkyDome. conjunto de tubos (485, 500, 100) voltados para a mesma direção da câmera (0
3. Vamos fazer girar então parece que Flappy está se movendo para a direita: make rotação em Z). Escale como quiser, é fácil de ver, mas não
certeza que o SkyDome está selecionado. Na seção Configuração inicial do seu preenche a lacuna entre os canos.
FG_Main Flow Graph, adicione um nó Movement : RotateEntity .

4. Clique com o botão direito do mouse no nó RotateEntity e atribua o SkyDome a ele.
2 Arraste seu ScoreStar1 para o Pipe1_bottom para vinculá- lo ao pipe 6. Vamos manter a estrela girando constantemente: adicione um
montagem. Desta forma, a estrela vai se mover com o nosso tubo existente Movimento : nó RotateEntity . Clique com o botão direito e atribua o gráfico
movimento gráfico de fluxo. entidade (ou seja, a própria estrela).
3 Vamos adicionar nossa mecânica de jogo : primeiro, clique com o botão direito na estrela e 7. Defina a velocidade em Y para 50 . Seu eixo pode ser diferente dependendo
escolha Criar gráfico de fluxo . Desde que vamos usar o existente a rotação do seu modelo. Observe que esse nó não possui um acionador de entrada; isto
gatilhos de pontuação, poderíamos estender a seção de pontuação do nosso Fluxograma, começará no início do jogo automaticamente.
mas seria confuso organizar, e nós não teríamos o
Nós escondemos a estrela no contato; agora vamos fazê-lo reaparecer quando o tubo
vantagem de usar a estrela como a entidade gráfica . Escolha o seu existente
a montagem é enviada de volta para a posição inicial para ser reciclada:
Pasta FG_Main .
1. Abra o seu Fluxograma de Fluxo de Movimentação para pipe1_bottom .
4 Clique com o botão direito do mouse no novo Flow Graph e escolha Add Graph Default
Entidade . Você notará que o nó da entidade possui uma entrada Ocultar . Vamos fazer 2. Selecione sua entidade ScoreStar1 se você ainda não tiver feito isso.
a estrela desaparece quando o jogador entra em contato: selecione o 3. Todo o caminho no lado direito ao lado do seu nó BeamEntity, à direita
scoreTrigger1 (ou o que você chamou de gatilho de proximidade clique e escolha Adicionar entidade selecionada .
entre o primeiro conjunto de tubos). Clique com o botão direito no seu gráfico e escolha
4. Arraste a saída Done do nó BeamEntity para a entrada UnHide do
Adicionar entidade selecionada .
o nó ScoreStar1 .
5 Arraste a saída Enter do nó ProximityTrigger para o Hide
5. Salve e teste . Não duplique a estrela para os outros tubos ainda, como nós vamos
entrada do GraphEntity da estrela .
adicionar um efeito de explosão e nós Fluxograma adicionais primeiro que
você vai querer copiar.
Adicionando efeitos de partículas 10. Nomeie seu efeito como ScoreEffect1 . Arraste -o para pipe1_bottom para vinculá-lo.
Salve e teste sua primeira estrela de pontuação. Quando estiver confiante, duplique o
Efeitos de partículas usam texturas translúcidas 2D para fornecer efeitos como faíscas, fogo,
estrela e partícula efeito mais três vezes e posicioná-los entre o outro
fumaça, etc. Uma grande biblioteca deles já é fornecida no GameSDK. Vamos
tubos. Certifique-se de renomeá- los corretamente, para copiar os nós do Flux Graph e para
adicione um efeito toda vez que o jogador colide com os gatilhos de pontuação:
modificar as atribuições da entidade corretamente. Não esqueça o nó adicionado no
1 Abra a ferramenta DataBase View ( Tools > DataBase View ) e clique em Gráfico do PipeMovement. Nós também adicionamos uma diferença de 30⁰ na rotação no Z
na guia Partículas . eixo entre cada uma das quatro estrelas para que eles não estão todos na mesma posição no
2 Clique na lista suspensa na guia Partículas que diz "Nível" mesmo tempo.
e selecione " explosões " . Uma árvore de pastas listando todos os efeitos de explosão Quando você testar esses efeitos no modo de jogo, você descobrirá que alguns
aparece à esquerda abaixo da barra de ferramentas. eles não funcionam como estão porque incluem uma onda de choque que empurra Flappy
3 Clique no sinal de mais ao lado da pasta do monitor e arraste o longe - ou seja, eles geram vento. Você pode mudar isso editando a partícula
efeito a_linger_elec no ScoreTrigger1 para colocá-lo no nível. efeito na exibição de banco de dados .
Posicione-o exatamente entre o primeiro par de tubos em 485, 500, 100.
4 Nomeie seu efeito de partícula como ScoreEffect1 . Dentro Eliminando forças físicas de efeitos de partículas
o Propriedades > Propriedades Lua , desmarque
1. Primeiro, selecione seu efeito de partículas na janela de exibição de perspectiva.
a propriedade Active para que o efeito não
fogo toda vez que você abrir este nível no Dica Pro : 2. Na ferramenta DataBase View > Particle , expanda o efeito de partículas
Editor. Toda vez que você quiser ver como pasta pai e procure por um componente geralmente chamado de vento . Dentro
efeito de partículas no seu nível parece GameSDK, os designers geralmente mantinham qualquer efeito de vento (shockwave)
5 Então você pode facilmente selecionar o efeito de partículas,
enquanto no Editor, clique com o botão direito nele um componente separado para facilitar a localização - caso contrário você
use o Level Explorer para congelar
e clique em Eventos > Spawn . para verificar todos os componentes.
ScoreStar1 e ScoreTrigger1.
Você também pode testar diferentes partículas 3. Percorra a longa lista de parâmetros para o Advanced
6 Com a entidade ScoreEffect1 selecionada , efeitos arrastando -os do
seção, e encontrar onde Force Generation está definido como Wind . Defina para
clique com o botão direito em seu gráfico de fluxo ScoreStar1 Banco de dados > Janela de partículas para
Nenhum .
e escolha Adicionar entidade selecionada . uma entidade ParticleEffect no
cena. 4. Salve suas alterações clicando no botão Salvar em partículas modificadas.
7 Para se certificar de que o efeito de partículas
Botão de bibliotecas .
não aparece até a primeira colisão, vamos
desativá- lo no início do jogo: adicionar um jogo: Iniciar
nó.
Randomização de efeitos de partículas
8 Arraste o nó Saída do jogo: Iniciar para a entrada Desativar do Assim como a aleatorização dos materiais do tubo aumentou a ilusão de tubos sem fim,
Nó da entidade ParticleEffect . vamos usar a mesma técnica para escolher aleatoriamente a partir de uma seleção de adequado
9 Nós desativamos o efeito de partículas, então precisamos ativá- lo para efeitos de partícula:
disparar (spawn) o efeito: arraste a saída Enter do 1. Abra o fluxograma do pipe_movement do pipe1_bottom e encontre o
Nó da entidade ProximityTrigger às entradas Enable e Spawn do Entidade : nó BeamEntity que envia seus pipes de volta para ai_start. Por quê
Nó ParticleEffect .
colocar a randomização de partículas aqui? Porque vamos atribuir um
efeito de partícula aleatória no mesmo momento em que atribuímos um material de tubo: mudando temporariamente a propriedade de Efeito de Partícula de um dos seus ParticleEffect
quando cada conjunto de tubos é enviado de volta ao ponto ai_start . entidades, e simplesmente copiando e colando a partir da Lua Properties >
2 Queremos atribuir um efeito de partícula de uma lista aleatória no momento Particle Effect propriedade nas setString do Em propriedade:
o jogo começa e toda vez que um par de canos é resetado para ai_start: adicione um 7. Use a ferramenta DataBase Tool> Partículas para arrastar várias explosões
Lógica : Qualquer nó (para lidar com as duas entradas) à direita do seu no seu ParticleEntity selecionado para atribuir e visualizá-los. Não faça
Nó BeamEntity. Arraste a saída Done do nó BeamEntity para esqueça que você deve desativar o Advanced > Force Generation
a entrada In1 da lógica : qualquer nó. Arraste a saída do propriedade, ou então o efeito irá afastar o seu jogador Flappy.
Jogo : Inicie o nó que você já adicionou para o material do tubo
8. Ao encontrar cada efeito de partícula que deseja usar, copie o nome dele
randomização para a entrada In2 do nó Logic : Any .
da propriedade Lua Properties > Particle Effect em cada um dos
3 Adicione um nó Math : Random . Arraste o Out of the Logic : qualquer nó para oito propriedades In de SetString , usando um efeito diferente em cada
o Gerar entrada do nó Math : Random . Defina seu Min para 0 e seu seus oito nós SetString .
Máximo a 7 .
9. Para rotear essas oito strings diferentes para o nó Entidade: PropertSet ,
4 Adicione um nó Logic : DeMultiplexer . Arraste a saída Out Rounded de Adicione uma Lógica : Qualquer nó à direita de seus nós SetString. Arraste o
o nó Math : Random para a entrada Index do Fora de cada um dos seus nós SetString para uma entrada diferente do seu
Lógica : nó DeMultiplexador . Definir o modo do Lógica : qualquer nó.
Lógica : nó DeMultiplexer para IndexOnly para garantir que apenas o índice
10. Finalmente, arraste o Out of your Logic : Qualquer nó para o Set e Value
disparador de entrada é usado.
entradas do nó Entidade: PropertSet .
5 Precisamos definir a propriedade Lua Properties > Particle Effect de cada
Salve e teste . Quando tiver certeza de que sua lógica está correta, copie e cole o
Entidade ParticleEffect: adicione um nó Entity: PropertySet . Selecione o
nós para os outros fluxogramas de fluxo de tubos, tomando o cuidado de atribuir
entidade scoreEffect1 ParticleEffect no seu nível, clique com o botão direito do
suas quatro entidades ParticleEffect para os nós Entity: PropertySet.
nó e escolha Atribuir Entidade Selecionada . Definir a propriedade deste nó
Parâmetro para Propriedades: ParticleEffect . (Use o botão .. para navegar Note que você pode facilmente experimentar diferentes efeitos selecionando um
para a propriedade correta.) entidade ParticleEffect existente e arrastando um novo efeito do banco de dados
6 Adicione oito nós String : SetString . Mapear a entrada Set de cada um deles janela para uma entidade de efeito no seu nível. Tenha cuidado para não acidentalmente
para uma saída de porta diferente do nó DeMultiplexer . criar entidades de efeito adicionais, arrastando em algum lugar diferente de um
efeito existente .
Você precisará escrever cuidadosamente o nome exato do caminho e do efeito no campo
propriedade dos nós SetString. Para evitar erros de digitação, recomendamos novamente
11: Adicionando Áudio Depois de criar seus sons, você precisará colocá-los no
pasta projectFolder \ audio \ sdlmixer \ assets . CRYENGINE irá automaticamente
crie arquivos .cryasset para cada arquivo .OGG que os exponha ao mecanismo.
Nosso jogo está faltando um componente importante: som ! Design de som e música
para jogos de vídeo é em si uma vasta especialização e uma arte, além de ser
Ativando a Depuração de Áudio
altamente técnico, mas adicionar sons básicos ao seu jogo é bastante simples - e
faz uma enorme diferença na experiência de jogo. Existe um depurador separado apenas para entidades de áudio e eventos que
Enquanto o áudio é tratado pelo que é conhecido como middleware, o CRYENGINE não é extremamente útil quando você está projetando o áudio em seu jogo. Use o
amarrado a um middleware específico. A camada de tradução de áudio (ATL) Ferramenta de console para digitar o seguinte:
comunica entre eventos do jogo, entidades, arquivos de som, gatilhos e s_DrawAudioDebug?
parâmetros dentro do seu jogo, abstraindo e traduzindo-os à sua escolha
de middleware de áudio. Você verá todos os parâmetros para o depurador de áudio exibido, da seguinte maneira:
Um middleware de áudio muito simples e gratuito chamado SDL Mixer é fornecido com Uso: s_DrawAudioDebug [0ab ...] (sinalizadores podem ser combinados)
0: Nenhuma informação de depuração de áudio na tela.
CRYENGINE, embora você também possa usar o fMod mais completo e
a: desenhe esferas em torno de objetos de áudio ativos.
Middleware Wwise . A maior funcionalidade dessas ferramentas vem com b: Mostra rótulos de texto para objetos de áudio ativos.
taxas de licenciamento e obrigações significativas antes que você possa distribuir um jogo c: mostra os nomes dos gatilhos para objetos de áudio ativos.
comercialmente, dependendo de quantos sons você usa. d: mostra os estados atuais dos objetos de áudio ativos.
e: Mostrar valores de parâmetro para objetos de áudio ativos.
A ferramenta Audio Controls Editor é a sua interface para configurar bibliotecas de áudio de
f: mostra as quantidades de ambiente para objetos de áudio ativos.
sons que podem ser disparados de várias maneiras. Adicionar áudio traz consigo um g: mostra a distância do listener para objetos de áudio ativos.
todo um novo conjunto de questões de design que você aprenderá a planejar cuidadosamente, incluindo h: Mostrar rótulos de raio de oclusão.
tempo, a ordem dos eventos, misturando vários sons, proximidade e aparente i: Desenhe raios de oclusão.
localização e muito mais. j: Mostrar arquivos autônomos do objeto.
m: oculta informações da memória do sistema de áudio.
Já que o Wwise é complexo o suficiente para merecer um curso inteiro em si, este n: Aplicar filtro também às informações de depuração do objeto inativo.
introdução ao áudio incidirá sobre o significativamente menos complexo SDL Mixer u: Listar arquivos autônomos.
middleware. É altamente recomendável que você reserve alguns minutos para ler v: Listar Eventos Ativos.
através da nossa documentação sobre o uso do mixer SDL. w: Listar objetos de áudio ativos.
x: mostra as informações de depuração do FileCache Manager.
Vamos habilitar algumas informações úteis usando o seguinte comando do console:
Design de som
s_DrawAudioDebug abdfgmv
O SDL Mixer só reproduz arquivos .WAV ou .OGG com uma taxa de amostragem de 48kHz e
um tamanho de amostra de 16 bits. No entanto, você precisará usar o formato .OGG compactado Você verá imediatamente as informações de áudio sendo sobrepostas no
para manter seu tamanho de compilação dentro da razão. Recomendamos que você projete e salve Perspectiva de perspectiva. Lembre-se, para desativar isso depois de terminar a depuração,
seus sons em um formato não compactado de alta qualidade como .WAV ou .AIFF, tipo s_DrawAudioDebug 0
exportar cópias no formato .OGG comprimido usando o nível de qualidade seis (60%) para
qualidade de balanceamento e tamanho do arquivo.
CRYENGINE Flappy Boid Course Ver. 5.5D - 70 - 11: Adicionando Áudio

Adicionando sons ambientais você já deveria ter copiado para o seu
projectFolder \ audio \ sdlmixer \ assets . Veja as instruções de configuração se você
O design de som pode estender os limites do seu jogo além do que o jogador já não fiz isso.
pode ver. No nosso caso, o mundo do jogo consiste no céu sobre o oceano até onde 4 Assim que seus arquivos forem copiados, o CRYENGINE criará
olho pode ver. Esses elementos sugerem sons ambientais : vento, ondas, correspondentes arquivos .cryasset que exporão os arquivos de áudio ao
talvez até mesmo a gaivota de passagem ocasional. motor, ponto em que eles aparecerão no Editor de Controles de Áudio em
Sons ambientais, como todo o áudio, originam-se em um lugar específico. Assim, eles o painel Dados de Middleware.
vem de uma direção específica . Enquanto o vento pode soar como está por toda parte 5 No lado esquerdo da ACE, clique no botão Adicionar e, em seguida, na biblioteca .
nós, os sons de ondas neste jogo definitivamente vêm de baixo , dada a nossa Nomeie sua nova biblioteca FlappyAudio .
posição da câmera 100M no ar. 6 Clique com o botão direito na sua biblioteca FlappyAudio e escolha Adicionar > Trigger .
Isso significa que quanto mais próximo "nós" - ou seja, a nossa câmera - chegar à superfície de Nomeie seu primeiro oceano de gatilho .
o oceano, quanto mais alto o som do oceano deveria estar. Como Flappy Cam sobe 7 Arraste o arquivo de áudio ocean.ogg da coluna Dados do Middleware
e para baixo para seguir o pássaro, o volume do oceano deve variar ligeiramente. Além disso, no painel Conexões . Clique no ocean.ogg em Conexões se
quando a nossa câmera pula para o jogo por cima do texto e salta para o oceano, não está selecionado. Abaixo o arquivo são parâmetros para o seu áudio
nossa câmera está muito perto da superfície do oceano, então o ambiente do oceano desencadear. Defina a ação para iniciar, de modo que o disparo comece a
deve ser alto. Então teremos a diversão de adicionar áudio para o splash e som.
nos dê uma sensação de que a câmera está afundando abaixo da superfície! 8 Defina o volume para -14db e desative Ativar Panning para que o som
está ao nosso redor. Defina a distância mínima para 0 e a distância máxima para
Criando uma biblioteca de áudio 200 e habilite o Infinite Loop para que o som se repita. (Isso é típico
para ambientes como vento e ondas, ao contrário de sons únicos
Antes que possamos adicionar sons ao nível, temos que escolher nosso áudio
como um tiro.)
middleware e criar uma biblioteca de som.
9 Teste seu novo gatilho clicando com o botão direito no gatilho do oceano verde em
Na ferramenta Console, definimos o cVar s_AudioImplName seguido pelo painel Controles do Sistema de Áudio e escolhendo Executar Acionador . Você
biblioteca de middleware que queremos carregar. O padrão é o SDL Mixer : deve ouvir o som do oceano.
1. Na ferramenta Console, digite s_AudioImplName 10. Vamos garantir que o som do oceano pare quando o jogo acabar:
CryAudioImplSDLMixer . Tecnicamente, isso não é necessário, uma vez que clique com o botão direito do mouse na biblioteca FlappyAudio e escolha Adicionar > Trigger .
O SDLMixer é o middleware padrão, mas será importante Nomeie seu gatilho stop_game (você pode chamá-lo como quiser).
Conheço este cVar mais tarde, quando você quer mudar para um dos outros 11. Arraste o som ocean.ogg para o painel Conexões para o seu
ferramentas de middleware ( CryAudioImplFmod ou CryAudioImplWwise ).
acionador stop_game . Defina a ação para este som para parar . Você também
2. No menu, clique em Ferramentas > Editor de controles de áudio . Maximize isso deseja adicionar ações de parada para quaisquer outros sons que possam estar sendo reproduzidos
janela da ferramenta. quando o jogo termina neste nível.
3. Sua pasta de recursos de áudio padrão é 12. Por último, clique no botão Salvar no canto superior esquerdo do
projectFolder \ audio \ sdlmixer \ assets . Recomenda-se manter este Controls Editor para salvar as alterações na biblioteca de áudio.
configuração padrão. Nós fornecemos arquivos de áudio para o projeto FlappyBoid
na pasta \ FlappyBoidCourse [version #] \ FlappyAssets , que

Adicionando disparadores de áudio ao seu jogo
Agora que criamos um acionador de som, vamos adicioná-lo ao seu jogo:
1 Na janela de exibição Perspective , navegue até onde seu texto "game over"
está localizado. Use sua ferramenta Criar Objeto para adicionar um objeto AreaBox apenas
acima da superfície da água. Esta caixa inteira será efetivamente uma
alto-falante que emana o som do oceano, então precisamos dele para cercar o nosso
Câmera DiveCam. Faça seu tamanho 30x30x1M e posicione uma borda apenas
passado o jogo sobre o texto. Posicionamos nosso jogo na caixa de texto
483, 562, 23 , nossa AreaBox em 483, 551, 16,5 , e nossa DiveCam em 483,
552, 18 . Nomeie sua AreaBox ab_GameOverOceanBox .
2 Vamos adicionar um som : use a ferramenta CreateObject para adicionar um áudio >
Entidade AudioAreaAmbience . Não faz diferença onde você
posicionar essas entidades . Eles não emitem realmente o som; eles são
usado apenas para conectar um som a uma entidade de área. Como sempre, organização
é primordial e, como com outros tipos de entidade, recomendamos a nomeação
suas entidades de áudio usando abreviações que indicam seus tipos de objeto.
Nomeie sua entidade AudioAreaAmbience
aaa_GameOverOceanAmbience .
3 Vamos conectar nossa entidade AudioAreaAmbience à entidade AreaBox para
realmente ouvir o som: selecione a entidade AreaBox e clique no
Escolha o botão na paleta Propriedades > Área . Clique no
Objeto aaa_GameOverOceanAmbience para vincular as entidades. UMA
linha de conexão aparece. Você pode posicionar o AudioAreaAmbience
ícone em qualquer lugar que você gosta. Sugerimos colocá-lo bastante perto do
AreaBox.
4 Vamos atribuir um som real: clique na entidade AudioAreaAmbience

e role para baixo até Propriedades> Propriedades de Lua> Play Trigger. Clique
Agora você pode testar seu som no Editor: quanto mais perto você mover a câmera para
no ícone da pasta e selecione o gatilho oceânico.
esta caixa Aaa_GameOverOceanAmbience AudioAreaAmbience, o mais alto do
5 Embora o SDLMixer não tenha a capacidade de transmitir parâmetros, O som do oceano deveria ser. Salve e teste o jogo, e você deve ouvir o oceano
ainda precisa combinar a Distância Rtpc (Controle de Parâmetro em Tempo Real) fica mais alto quando Flappy desce e mais suave à medida que sobe. Quando Flappy morre e
parâmetro aqui para a configuração de distância máxima , então defina-o como 200. a câmera pula diretamente acima desta caixa AudioAreaAmbience, o oceano
6 Clique na pasta ao lado da propriedade Stop Trigger e escolha o seu deve ser muito mais alto.
stop_game para garantir que o som pare quando o jogo terminar.
O efeito de volume ao voar através dos tubos é muito sutil, no entanto,
7 Por fim, clique na propriedade Enabled para ativar o som. porque o áudio está tão longe do Flappy. Dado que vamos adicionar

respingos altos e sons de afundamento para o jogo, você pode querer ao rigoroso realismo. Embora nossa entidade de jogador seja atualmente apenas uma esfera,
Mova sua caixa AudioAreaAmbience para mais perto do Flappy para um vai tratá-lo como o pássaro voador que acabará por substituí-lo para dar-lhe um
efeito. Não se esqueça de alterar a distância de atenuação na distância máxima mais orgânico, divertido personagem do que uma simples esfera.
propriedade no acionador de áudio e para combiná- lo no AudioAreaAmbience
Primeiro, vamos adicionar um acionador de áudio com base em um som de colisão que fornecemos:
propriedade Rtpc Distance da caixa.
1. No Audio Controls Editor , clique com o botão direito no seu FlappyAudio

Adicionando um som de colisão biblioteca e adicione outro gatilho . Nomeie -o como pipe_collision .
A forma dos seus modelos e as texturas que você aplicou a eles ajudarão 2. Arraste o arquivo pipeCollisionWithSquawk.ogg para as Conexões
determinar quais sons parecem apropriados, embora você não precise se limitar janela.

3. Defina a ação para iniciar , o volume para -10db e desative a opção Ativar escolha se estivéssemos usando atenuação. No entanto, vamos manter este exemplo
Panning , Enable Attenuation e Infinite Loop . simples: selecione sua câmera FlappyCam no Level Explorer, então
4. Clique no botão Salvar no canto superior esquerdo da ACL e clique com o botão direito do mouse no nó Audio : Trigger e escolha Assign Selected
volte para a sua janela de exibição Perspective . Entidade . Isso significa essencialmente que o som virá de
onde quer que “nós” estamos - isto é, a câmera.
Ao contrário do som ambiente do oceano, queremos disparar este som quando o Flappy
Salve e antes de testar, prepare sua mão para pressionar a tecla Esc. Você deve
colide com um tubo. Vamos precisar do Flow Graph para isso, e podemos construir o
ouvir o som quando Flappy colide, mas você também vai ouvir alguns
ouvinte de colisão de física que já configuramos:
coisas estranhas: o som será acionado mais de uma vez - provavelmente muitos
5. Encontre a seção Collisions Pipe do seu FG_Main Flow Graph. Adicionar vezes de forma irrealista.
um nó Audio : Trigger .
6. Arraste a saída IdA do nó Physics : CollisionListener para o Prevenindo vários sons de colisão
Reproduzir a entrada do nó Audio : Trigger para reproduzir o som quando o Flappy
colide com alguma coisa. O que está acontecendo? Flappy continua batendo nas coisas enquanto cai - os canos,
o terreno invisível, etc! Uma versão sofisticada deste evento pode incluir uma
7. Verifique se o seu nó Audio: Trigger está selecionado e , em seguida, no Flow
som de colisão inicial seguido por sons de raspagem no contato subsequente com
Na janela Graph Properties , clique na caixa ao lado do Play Trigger
o cano. Vamos nos certificar de que o nosso som de colisão só aconteça pela primeira vez
propriedade, em seguida, no ícone da pasta para navegar. Selecione o pipe_collision
contando colisões com uma variável:
gatilho que você já criou e clique em OK .
8. Por fim, precisamos informar à ACL onde colocar o áudio no espaço 3D. 1. No menu Flux Graph , escolha Ferramentas > Editar tokens do gráfico .
Como desativamos a atenuação para esse som específico, ele não fará Os tokens do gráfico são variáveis como os tokens do jogo, mas são locais
diferença. Tecnicamente, o som deve vir de onde quer que Flappy (visível) para apenas um gráfico. (FG_Main no nosso caso.)
é, desde que o som é gerado colidindo com algo. Dentro 2. Crie um novo token chamado IntCollisions do tipo Integer .
termos de um ambiente sonoro realista, que seria o correto
3. Vamos inicializar nosso contador de colisão no início do jogo: no Initial

Seção de configuração do seu FG_Main, adicione um nó Missão : GameTokenSet . Nó GameTokenGet . Definir a propriedade Token do GameTokenGet
Na do nó GameTokenSet Propriedades , defina o token para o nó para intCollisions .
token do gráfico intCollisions e o valor para 0 . 8. Arraste o Valor de Saída do nó GameTokenGet para o In do
4. Arraste o nó Output of the Game : Start para a entrada Trigger do Matemática : nó InRange . Defina o Min e Max do nó Math : InRange como
Nó GameTokenSet . 1 . Em outras palavras, nós só queremos tocar nosso som pela primeira vez
5. De volta à seção Colisões de Tubulações do seu Gráfico de Fluxo, adicione estas Flappy colide com algo - morte instantânea.
nós da esquerda para a direita: Missão : GameTokenModify , 9. arrastar o IdA saída da Física : CollisionListener nó para o Em
Missão : GameTokenGet , Math : InRange e Logic : Gate . entrada do nó Lógica : Gate . Arraste o Out of the Logic : Gate para o
6. Vamos incrementar nosso contador em cada colisão: arraste a saída IdA de Reproduzir entrada do nó Áudio : Trigger . Agora nós temos uma colisão
o nó Physics : CollisionListener para a entrada Trigger do pronto para acionar o nosso som de colisão, mas só queremos abrir o
Nó GameTokenModify . Defina o de GameTokenModify token para portão na colisão # 1:
intCollisions , a operação para adicionar , o tipo para Int e o valor 10. Arraste a saída True do nó Math : InRange para a entrada Open
para 1 . da saída Logic : Gate e False do nó Math : InRange para
7. Para verificar o valor do contador em cada colisão, arraste o valor de saída de a entrada Close da Logic : Gate .
o nó GameTokenModify para a entrada Trigger do
Dica Pro :
A ferramenta Localizar no Fluxograma é
muito útil quando você precisa encontrar
um nó , entidade , porta ou
mesmo um valor específico - especialmente
como seus gráficos ficam complexos. Somente
pressione Ctrl-F ou escolha Editar> Localizar
no menu Flux Graph. o

O painel de pesquisa inclui muitos
opções, incluindo o escopo de
sua pesquisa e o tipo de dados

você quer encontrar. Clique duas vezes em um
resultado para saltar para ele no gráfico.

Jogue e teste. Você deve ouvir um som ininterrupto de colisão e socorro. e teste .
Desabilitando o salto em colisão Adicionando Game Over Sounds
Se você testar cuidadosamente, você notará que o jogador ainda pode "pular" depois Nós lhe demos dois sons para a sequência do jogo: uma queda e
colidindo com um cano. Vamos consertar isso: salpicos de som quando o texto Game Over cai na água e o som
de submergir debaixo d'água para quando a câmera afunda. Vamos adicioná-los:
1. Na seção de configuração inicial do seu Flow Graph, encontre o GameToken
nó que verifica o valor de booIsDead e alimenta o Disable 1. No Audio Controls Editor , clique com o botão direito no FlappyAudio
entrada do nó ActionListener (que fornece a ação de salto). biblioteca e adicione um novo gatilho chamado GameOverFallAndSplash .
2. Selecione o nó GameToken e altere sua propriedade Token para 2. Arraste o som fall_and_splash.ogg para o painel Conexões do
intCollisions e a propriedade Comparar para 1 . Agora, logo que o o ACL. Selecione o som no painel Conexões e defina seu
primeira colisão de tubulação ocorre, a ação de salto é desativada. propriedades da seguinte forma: Action = Start , Volume = -6db , Enable
Consulte a captura de tela do Fluxograma concluído com cuidado antes de salvar Panorâmica e Ativação de Atenuação desativada .
3. Adicione outro gatilho chamado afundando . Arraste o som sinking.ogg para dentro

o painel Conexões . Defina suas propriedades da seguinte maneira: Action = Start ,
Volume = -6db , Ativar Panning = Desativado , Ativar Atenuação =
Habilitado , Distância máxima = 100 . Salve sua biblioteca de áudio.
4. Na seção Colisões de tubulação do seu gráfico de fluxo FG_Main , adicione

outro áudio : nó de disparo . Defina seu acionador de reprodução para o
Gatilho GameOverFallAndSplash.
5. Selecione a câmera FlappyCam no Level Explorer, clique com o botão direito

no nó Audio : Trigger e escolha Assign Selected Entity .
Novamente, com a atenuação desativada, isso pode estar em qualquer lugar.
6. Arraste o Out of the Logic : Gate para a entrada Play do

Áudio : nó de disparo .
7. Vamos atrasar este som inicial brevemente para dar ao som pipe_collision um
chance de ser ouvido : clique com o botão direito na alça circular no
conector entre os nós Logic : Gate e Audio : Trigger e
escolha Hora : Atraso . Defina a propriedade Delay para 0,2 segundos. 3 Arraste o nó Out of the Time : Delay para a entrada Enable do
Nó CameraView para dar ao jogador a chance de assistir Flappy cair
Salve e teste . Você deve ouvir cair e depois espirrar sons. Mas tem
antes de saltar para o Game Over.
um problema: o timing do som não corresponde ao visual do game-over
4 Adicione um nó Audio: Trigger . Arraste o nó Out of the Time : Delay
texto batendo na água. Há muitas maneiras de lidar com isso: podemos usar
(aquele que alimenta os nós MoveEntityTo e RotateEntity que
sons de queda e salpicos separados, use um gatilho de proximidade subaquática para
controlar sua câmera de mergulho) para a entrada Play do Audio : Trigger
sentido quando o jogo termina o texto, a fim de parar o som cair e começar
nó.
o som do splash, etc.
5 Defina o gatilho do Play do Audio: Trigger node para o seu trigger de afundamento,
Como fornecemos um som combinado de queda / splash de duração específica , vamos
e atribua a câmera da diveCam como a entidade.
basta atrasar o interruptor para o jogo através da câmera para dar ao jogador um momento
Salve e teste. Ajuste o atraso conforme necessário para que o som e o som
para assistir Flappy cair e atrasar a queda da caixa para dar um som
chance de ser ouvido, como se a caixa estivesse caindo de uma grande altura: estão sincronizados.
1. Primeiro, arraste a saída Out do nó Logic : Gate para o Trigger Adicionando um som de "Flap"
entrada do nó Missão : GameTokenSet que define booIsDead para
verdade . Isso garante que isso só aconteça na primeira colisão. Toda vez que o jogador pressiona a tecla de pulo, nosso Flappy se esforça para se mover
2. Na seção Game Over do seu Flux Graph, insira um Time: Delay para cima. Vamos adicionar um som humorístico simples e ativá-lo em cada salto:
nó entre o nó GameToken que verifica booIsDead e o 1. No Audio Controls Editor , clique com o botão direito no FlappyAudio
Entidade: nó PropertySet que desativa a propriedade bResting do biblioteca e adicione um novo gatilho chamado squawk_low .
GameOverBox. Tente um atraso de 1,3 segundos. Você pode precisar ajustar
2. Arraste o arquivo de áudio squawk_low.ogg para a janela Conexões .
esta.
Defina as propriedades do acionador da seguinte forma: Ação : Iniciar ; Volume : 0db ;
Ative Panning / Enable Attenuation : desativado . Salve seu som

biblioteca. Você vai notar que nós fornecemos vários grasnidos de galinha Adicionando sons aos efeitos de partículas
sons em tons de alto a baixo, então sinta-se livre para usar qualquer um deles.
Mais tarde, você pode querer explorar a seleção do som de grito Primeiro, vamos adicionar um efeito de som apropriado para cada efeito de partícula diretamente no
dinamicamente baseado em quão duro seu pássaro está lutando para escalar. Ferramenta de partículas. Você pode tentar arrastar vários efeitos de partículas do
(Incluímos um Fluxograma que faz isso no jogo finalizado Biblioteca GameSDK em qualquer uma das suas quatro entidades de partículas para testá-los e
nível no FlappyBoidCourse .zip que fornecemos, que não é impresso decida qual você quer usar para este jogo. Apenas lembre-se de verificar se há
aqui, mas pode ser aberto, estudado e talvez até melhorado.) não é selecionado vento na seção Advanced > Force Generation , ou então o
3. Na seção Configuração inicial do seu gráfico de fluxo do FG_Main, adicione um onda de choque vai empurrar o seu Flappy para longe.
Áudio : nó de disparo . Defina seu Play Trigger para o gatilho squawk_low Agora que você decidiu quais efeitos de partículas você deseja usar, vamos adicionar
você acabou de criar. sons para cada um deles. Neste exemplo, vamos percorrer o processo de
4. Arraste a saída pressionada de sua entrada: ActionMaps: ActionListener adicionando um som ao monitor > efeito a_lingering_elec :
nó para a entrada Play do nó Audio : Trigger .
1. No Audio Controls Editor , clique com o botão direito no seu FlappyAudio
Salve e teste. Cada vez que o Flappy salta, ele deve gritar. biblioteca e crie um novo gatilho . Nomeie algo como
“ PfxMonitorLingeringElec ” (onde “pfx” = efeitos de partículas).
Adicionando sons de pontuação 2. Arraste o arquivo de áudio star_electrical.ogg para a janela Conexões .
Defina suas propriedades da seguinte forma: Action = Start , Volume = -3db , Enable
Nossas estrelas explodindo clamam por efeitos sonoros! Existem duas maneiras de abordar
Panning / Enable Attenuation = desativado . Salve a biblioteca de áudio.
isso: podemos atribuir acionadores de áudio diretamente para as partículas usando o DataBase
> Partículas ferramenta (você vai notar uma seção de áudio com um gatilho Iniciar), por isso, quando um 3. Na ferramenta Database View > Particles , clique no efeito que você deseja
efeito de partícula é gerado, seu som é reproduzido. Ou podemos simplesmente usar o mesmo modifique ( monitor > a_lingering_elec neste caso) e então clique em
Proximity Trigger para reproduzir um som através de um nó Audio: Trigger no Flow o botão Add New Item na barra de ferramentas Particles. Nomeie o áudio .
Gráfico. Seu novo componente aparece como um item recuado sob o
efeito a_lingering_elec.
No entanto, você já deve ter percebido como os mesmos quatro efeitos de partículas
4. Clique no seu novo componente de áudio e role para baixo na partícula
repetir na mesma ordem - tornando óbvio que existem apenas quatro
propriedades para a seção de áudio . Clique na pasta ao lado do Start
tubos que são reutilizados indefinidamente. Adicionando efeitos sonoros para cada um desses
Propriedade Trigger e escolha o seu FlappyAudio>
partículas que também se repetem na mesma ordem 1-2-3-4 só vão fazer isso
Acionador pfxMonitorLingeringElec. Clique no botão Save Modified
mais óbvio.
Botão Bibliotecas na barra de ferramentas Partículas.
Vamos melhorar o nosso design de jogo, atribuindo aleatoriamente uma das muitas partículas Como sempre, salve e teste .
efeitos para cada tubo toda vez que ele volta para ai_start, assim como fizemos com o
materiais de tubulação.

12: Exportando um jogo para uma construção independente 11. Certifique-se de copiar toda a pasta _package para seus clientes ou
testadores.
Uma vez que você testou e depurou e está confiante em seu design de jogos, é
Portando um nível para outro computador ou compilação
hora de colocar o seu jogo nas mãos de alguns QAs sérios (garantia de qualidade)
jogadores que podem fazer o seu melhor para ajudá-lo, tentando quebrá-lo - para encontrar o seu Se você construiu este jogo em uma sala de aula ou se encontra em uma posição de
falhas, e para lhe dar feedback sobre se é divertido ou poderia usar algum querendo trazer o seu nível para outro computador, há alguns passos que você precisa
melhorias. seguir. Também é um bom momento para considerar a estrutura de pastas de um
Instalação do CRYENGINE e como a pasta GameSDK está configurada.
Ocultar informações de exibição na compilação
GameSDK: todos os componentes GameSDK que você baixou do
Veja como você obtém seu jogo em um aplicativo de PC autônomo: Mercado CRYENGINE
1 Salve seu nível atual.

Desafios para aprimoramentos adicionais
2 No mecanismo, escolha Arquivo > Exportar para o mecanismo .
3 Saia do CRYENGINE. Nós deliberadamente deixamos o nosso jogo imperfeito na esperança de que você seja inspirado
para aprender mais aprimorando-o e aprimorando-o. Aqui estão alguns sugeridos
4 Vá para a pasta do projeto, clique com o botão direito do mouse no arquivo .cryproject
aprimoramentos que deixaremos para você projetar usando as habilidades que você aprendeu:
(GameSDK.cryproject neste curso) e escolha Iniciar jogo .
5 Teste seu jogo. Tente variar os parâmetros gráficos. Jogue contanto que • Conecte a velocidade de oscilação horizontal da textura da nuvem (ou
você pode. taxa de rotação da entidade SkyDome) para a velocidade do tubo horizontal para
Aumente a ilusão de que a ave está se movendo em velocidade crescente.
6 Se você encontrar problemas e precisar fazer alterações no Editor, certifique-se
você começar a voltar ao passo um . • Crie níveis adicionais com complexidades crescentes para o tubo
7 Quando estiver 100% confiante, crie o aplicativo independente movimento. Tente variar a geometria dos tubos em cada nível ou
clicando com o botão direito no arquivo .cryproject e escolhendo Package Build . mesmo aleatoriamente dentro de um nível. (Você encontrará geometria de tubo adicional
Isso pode levar algum tempo, por isso certifique-se de que a linha de comando lhe diz que é na mesma pasta onde você encontrou o pipe básico.)
terminou antes dos testes finais. • Em vez de mover os tubos da direita para a esquerda em linha reta, descubra
8 Finalmente, podemos definir variáveis do console em nosso arquivo .cryproject; um que como fazer os tubos subir e descer várias vezes (ou seja,
nós definitivamente vamos querer definir depois que terminarmos a depuração, mas oscilar verticalmente) ao atravessar a tela. ( Dica : olhe para o seno
antes de enviar o jogo é para esconder as informações de exibição: abra o seu ondas.)
arquivo gamesdk.cryproject no Bloco de Notas ou em qualquer editor de texto simples.
9 Encontre a seção “console_variables”. Adicione a seguinte linha abaixo: O Design Final
{“Name”: “r_displayinfo”, “value”: “0”}, Aqui estão algumas capturas de tela do nosso jogo final de vários ângulos.
10. Para testar o aplicativo real, abra a pasta _package
(GameSDK_package neste curso)> bin > win_x64 e clique duas vezes
GameLauncher . exe . Jogue seu jogo!
CRYENGINE Flappy Boid Course Ver. 5.5D - 80 - 12: Exportando um jogo para uma construção independente
Indo além
Parabéns, você construiu um divertido jogo acabado e aprendeu um conjunto de

habilidades que você pode aplicar a todos os seus futuros designs de jogos do CRYENGINE!
A melhor coisa que você pode fazer neste momento é aplicar o que aprendeu
construindo seus próprios jogos. Você também pode tentar estender a funcionalidade de
seu jogo boid flappy. Enquanto você provavelmente tem muitas idéias para
melhorias, aqui estão algumas sugestões para as quais publicaremos passo a passo
passo instruções em futuras edições deste tutorial:
Substitua a pontuação da mensagem de depuração por uma interface de usuário do Flash polida
Troque a esfera padrão e substitua-a por uma ave animada (experimente

Objeto ParticlePhysics, como RigidBodyEx suporta apenas modelos .CGF)
Adicione recursos como jogar novamente, um número finito de pontos para acumular
terminar o nível, etc.
Adicione níveis adicionais e carregue automaticamente o próximo quando um jogador

atinge uma certa pontuação.
Por fim, sempre agradecemos o feedback. Se você tiver sugestões, veja erros de digitação ou
erros em qualquer parte deste tutorial, entre em contato conosco!

CRYENGINE FlappyBoid Syllabus 5.5D em Português

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

CRYENGINE FlappyBoid Syllabus 5.5D em Português

Enviado por

Direitos autorais:

Formatos disponíveis

CRYENGINE Flappy Boid Course 5.

Livro de exercícios do aluno

Definindo uma câmera padrão 12

Configuração do curso para estudo autônomo 3 Fazendo a câmera seguir o player 16

Requisitos de sala de aula para professores 3 Considerações sobre design de jogos 18

Impedindo o jogador de tiro de andar 12 Movendo o primeiro tubo 27

CRYENGINE Flappy Boid Course Ver. 5.5D -1- Configuração do curso

Detectando Colisões 35 Design de som 70

CRYENGINE Flappy Boid Course Ver. 5.5D -2- Configuração do curso

5 Confira e baixe os dois ativos do mercado.

CRYENGINE Flappy Boid Course Ver. 5.5D -3- Configuração do curso

10. Use a física para movimentos realistas; seletivamente desativar física em

18. Use as Variáveis do Console para controlar o Editor e testar ambientes

6. Distribua as pastas de trabalho pré-impressas do aluno.

CRYENGINE Flappy Boid Course Ver. 5.5D -4- Configuração do curso

grande, mantendo-os limpos e

bem organizado é primordial. UMA

cada nó clicando na seta em

canto superior direito.

CRYENGINE Flappy Boid Course Ver. 5.5D -5- Configuração do curso

RigidBodyEx é uma “entidade legada” - é específica do GameSDK. Tem tantos

2 Clique duas vezes na porta de entrada Message do seu DisplayMessage

Adicionando uma Câmera 4 Arraste da porta de saída de

Branco número de ponto flutuante

3 Ligue a saída da porta do Jogo: Comece nó ao conjunto de entrada

Visualizando Física e Sistemas AI

Uma última dica de desenvolvimento de jogos : os sistemas de física e IA são complexos e

4 Certifique-se de que o Coord Sys (sistema de coordenadas) do

Por que não um tempo zero para o nosso MoveEntityTo ? Considerando a

1. Clique na sua esfera FlappyBoid para selecioná- la.

3 Encontre uma textura interessante e claramente visível em um dos materiais

tubo inferior usando Snap To Pivot : 9. Renomeie o Trigger de Proximidade pipe1Score_trigger .

Faz sentido conectar todas as partes do texto “game over”. Você

10. Substitua o “G” por um “A” usando a mesma propriedade Model.

1. Certifique-se de que sua caixa de plano de fundo ainda esteja selecionada .

Removendo sombras através de shaders

Podemos tentar consertar isso ajustando a direção do Sol no ambiente.

1. Selecione a caixa de fundo.

2. Na ferramenta Legado do Material Editor , altere as Configurações do material >

Escalando e posicionando a caixa de plano de fundo

Vamos fazer o fundo preencher a tela escalando e posicionando -a. Como

Crie uma viewport secundária baseada na câmera FlappyCam e assista como

CRYENGINE Flappy Boid Course Ver. 5.5D - 27 - 06: Mover os canos

7. Clique com o botão direito do mouse no círculo no meio do conector entre

CRYENGINE Flappy Boid Course Ver. 5.5D - 28 - 06: Mover os canos

Fechamos o ciclo no nosso movimento de canos! Vamos testar: Ctrl-S; Ctrl-G .

CRYENGINE Flappy Boid Course Ver. 5.5D - 29 - 06: Mover os canos

CRYENGINE Flappy Boid Course Ver. 5.5D - 30 - 06: Mover os canos

Salve e teste . Você deve ver imediatamente a visão do seu

CRYENGINE Flappy Boid Course Ver. 5.5D - 31 - 06: Mover os canos

5. Altere as entradas do nó selecionado > Tipo de operação para Adicionar a

2. Clique na guia GameTokens . Exibindo a pontuação na tela

CRYENGINE Flappy Boid Course Ver. 5.5D - 32 - 07: Mantendo Pontuação

3. Mapear o para fora de sua seqüência : Concat nó à mostra e o

CRYENGINE Flappy Boid Course Ver. 5.5D - 33 - 07: Mantendo Pontuação

9 Atribua a entidade FlappyBoid ao nó ActionImpulse . Tente definir

CRYENGINE Flappy Boid Course Ver. 5.5D - 35 - 08: Jogador "Morte"

3. Defina Comparar com para Falso .

CRYENGINE Flappy Boid Course Ver. 5.5D - 36 - 08: Jogador "Morte"

CRYENGINE Flappy Boid Course Ver. 5.5D - 37 - 08: Jogador "Morte"

( Dica : expanda as entidades ligadas no Level Explorer e selecione tudo GameOverCamera .

CRYENGINE Flappy Boid Course Ver. 5.5D - 38 - 08: Jogador "Morte"

CRYENGINE Flappy Boid Course Ver. 5.5D - 39 - 08: Jogador "Morte"

2. Adicione um nó Debug : ConsoleVariable ao seu gráfico. Um console