‫Olá e bem-vindo.
‫Nesta palestra, exibiremos uma tela solta e farei isso inteiramente de
‫dentro do C++ para gerar esse widget.
‫Vamos mergulhar e ver como é feito.
‫Ok, então gostaríamos de exibir alguma interface do usuário quando um jogador morre para dizer o que está acontecendo que ele perdeu e
‫que o nível está prestes a ser reiniciado.
‫Portanto, não é uma surpresa para eles.
‫Portanto, não precisamos criar uma interface do usuário, widgets de interface do usuário, UMG, widget de gráficos em movimento irreais.
‫Então, vamos fazer isso primeiro, criando uma pasta para armazenar a interface do usuário.
‫E eu já sei que teremos dois itens de interface do usuário, então acho que terei uma pasta de interface do usuário
‫aqui e então vamos entrar aqui e clicar com o botão direito e ir, você deveria ter feito isso antes, mas vamos vai
‫orientá-lo através dele.
‫Vamos para a seção de interface do usuário, selecione o esquema de widgets e o prefixo
‫para usar é o sublinhado WB P e, em seguida, será a tela solta.
‫Agora você pode fazer algumas classes base para esse tipo de coisa em C++, mas não vamos cobrir isso
‫nesta seção.
‫Geralmente não é necessário fazer isso, e é muito mais fácil fazer as coisas no Blueprint.
‫Não há muita vantagem em fazer isso em C++, a menos que uma interface do usuário fique super complicada e você queira colocar
‫um pouco dessa lógica de interface do usuário em C++.
‫No nosso caso, este não é o caso, então podemos seguir em frente e usar as plantas.
‫Afinal, a interface do usuário é uma coisa visual.
‫Faz sentido usar uma ferramenta visual para montá-lo agora porque você já sabe como criar
‫widgets.
‫Então eu vou dar isso como um desafio para você montar uma tela solta.
‫Queremos adicionar algum texto explicando que o jogador perdeu e que estamos prestes a reiniciar.
‫Quer posicionar esse texto provavelmente no centro, torná-lo visível, certifique-se de que esteja visível no jogo.
‫E, no entanto, como eu disse, explique que haverá um reinício chegando.
‫E depois que você tentar esse desafio, veremos como podemos gerar isso a partir do C++.
‫Você viu talvez como fazer isso no Blueprint antes de vermos como podemos fazer isso de dentro do C++.
‫Então pause o vídeo e pronto.
‫Ok, bem-vindo de volta.
‫Então eu vou criar, antes de tudo, um pouco de texto.
‫Então, eu quero procurar na paleta à esquerda, vou procurar o item de texto e trazê-lo.
‫Eu vou mudar isso para você perder.
‫Diálogo bastante direto e sem imaginação escrevendo aqui.
‫Eu vou mudar a cor e a opacidade e a aparência para vermelho para deixar bem claro que eles
‫perderam e apenas esfregar um pouco mais e eu vou expandir essa fonte e mudar o tamanho para ser maior
‫.
‫E então vou expandir a caixa ao redor do nosso texto e vou centralizar nosso texto.
‫Então, descendo a justificativa, vou centralizar o texto.
‫E se eu expandir, vamos ver se há algum outro lugar onde eu possa fazer alinhamento centralizado que não
‫há.
‫Então eu vou fazer as caixas mais ou menos apropriadas e então eu vou até meus alinhamentos e minhas âncoras
‫e coisas assim.
‫E vou selecionar o menu suspenso para âncoras e selecionar a predefinição para ancoragem no meio, porque é isso que
‫quero fazer.
‫Eu quero definir meu alinhamento como 0. 5 e 0. 5, o que basicamente significa que estamos alinhando ao
‫centro do objeto ao invés do canto superior esquerdo que vai fazer a âncora novamente.
‫Ok, isso não foi muito útil.
‫E então a posição X por que eu acho que se eu apenas definir a posição ao lado de zero e zero
‫porque eu configurei minhas âncoras assim, então minha posição de perda vai estar em algum lugar no meio e eu
‫vou movê-la para cima sempre tão ligeiramente.
‫Mantenha minha posição X em zero, posição Y em -50, porque eu quero adicionar algum texto secundário dizendo, na verdade, pode ser mais
‫fácil apenas duplicar o outro texto aqui porque ele tem toda a configuração que
‫eu já preciso.
‫Eu só quero torná-lo um pouco menor.
‫Posicione zero novamente e direi que o nível será reiniciado em 5 segundos e farei com que o tamanho da fonte seja
‫muito menor.
‫Então é menos na sua cara, algo assim, e então apenas mova um pouco para
‫baixo, um pequeno entalhe e continue redefinindo essa posição X para zero e 100% feliz com o posicionamento.
‫Só vou subir um pouco mais.
‫Se eu mantiver o shift pressionado, posso bloqueá-lo no eixo com o qual estou me movendo para que fique mais ou menos central
‫assim.
‫Ok, então estou feliz com isso.
‫Agora precisamos ir em frente e tentar gerar a coisa.
‫Como vamos fazer isso?
‫Bem, antes de tudo, precisamos saber qual classe de widget devemos gerar, e precisamos saber de onde
‫vamos fazer isso a partir de agora.
‫Como já disse, acho que um bom lugar para fazer isso é no próprio controle do player.
‫E vamos precisar saber no controlador do jogador qual classe, qual classe de widget estamos tentando
‫gerar?
‫Agora, eu sei que é uma classe de projeto, mas ainda precisamos que seja uma classe que estamos tentando gerar.
‫Então, vamos fazer isso criando uma nova propriedade aqui.
‫Haverá edições em qualquer lugar e vamos querer que isso seja uma subclasse de porque essa é sempre uma
‫boa maneira de garantir uma nova classe.
‫Basicamente, você pode usar o tipo new class se quiser, mas isso não restringe o tipo de classe que
‫podemos usar.
‫E aqui queremos restringi-lo apenas a você usar widgets.
‫Se você for ao seu blueprint, poderá ver se formos a algum lugar aqui, você poderá descobrir se uma classe pai usa
‫um widget que sabemos que quando você coloca o prefixo nele se torna um widget.
‫Portanto, esta é uma subclasse de.
‫E então nós usamos nossos colchetes angulares e você usa um widget e eu vou declará-lo aqui
‫em vez de fazer qualquer inclusão.
‫E então classe você usa um widget e então vamos chamar isso de classe de tela perdida.
‫Apenas mantenha bem óbvio o que está acontecendo lá.
‫Agora, vou prosseguir e compilar neste estágio enquanto fazemos as próximas coisas, porque compilar ao alterar um arquivo leva
‫um pouco mais de tempo.
‫Agora, na verdade, a compilação falhará neste estágio porque não incluímos o módulo UMG.
‫Não sabemos como fazer isso.
‫Não se preocupe com a compilação neste estágio e em cerca de 9 minutos no vídeo, corrigiremos esse
‫erro.
‫Agora no C++, o que vamos querer fazer é realmente gerar esse widget.
‫Então nós não queremos fazer isso talvez antes da hora.
‫Isso realmente não importa porque o cronômetro não espera.
‫Ele apenas define o tempo e depois vai direto para a próxima linha de código, então não vamos esperar 5 segundos se
‫fizermos isso no Stripe, se tivermos gerado a interface do usuário logo em seguida, não importa a ordem que faça
‫isso em.
‫Então, o que vamos querer fazer é usar uma função chamada create widget, que não está disponível no momento.
‫Então, precisamos incluir algo em hash primeiro e vamos incluir o blueprint e a barra para usar um
‫widget.
‫E essa é uma classe que precisamos para acessar essa função create widget.
‫E vamos basicamente dizer criar widget.
‫Precisa estar bem, na verdade, vamos ver o que precisamos fornecer.
‫Estou indo para f 12 para sua implementação.
‫Você pode ver que é um pouco complicado de ver, mas nós temos um parâmetro de modelo aqui que é basicamente
‫por padrão que você usa um widget, então provavelmente não precisamos fornecer isso.
‫E depois há o objeto proprietário e a classe que precisamos criar e, em seguida, um nome de widget que
‫não precisamos fornecer necessariamente.
‫E então ele retorna como o ponteiro para o widget.
‫Então, o que eu realmente vou fazer é aqui, vamos dar a ele um objeto proprietário.
‫Agora, apenas certas coisas podem possuir o widget.
‫Uma dessas coisas é, na verdade, o controlador do jogador.
‫Então, podemos apenas passar isso.
‫E a próxima coisa é que queremos passar a subclasse t de você usar um widget.
‫Bem, felizmente, já configuramos isso no cabeçalho do arquivo.
‫Então, podemos ir em frente e passar isso e eu impedirei meu recuo de tentar se corrigir enquanto não tiver colocado um ponto
‫e vírgula no final da linha.
‫E então vamos dar uma olhada no que mais.
‫Bem, é isso.
‫Ele apenas retorna o widget neste momento.
‫Então, o que podemos fazer é ter um ponteiro para você, usar uma loja de widgets e essa será nossa tela perdida.
‫Então, temos que perder a classe de tela.
‫Depois que criamos o widget, ele se torna uma tela solta.
‫A próxima coisa que precisamos fazer é tornar essa interface do usuário visível.
‫Fazemos isso adicionando-o à janela de visualização em linguagem irreal.
‫Mas primeiro, porque adicionamos à viewport chamando uma função na tela azul, precisamos ter certeza de que não
‫é um ponteiro nulo.
‫Então, se a tela de perda não for igual ao ponteiro nulo, por que não haveria pontos?
‫A propósito, pequeno desafio para você.
‫Veja se você pode descobrir por que podemos acabar com um ponteiro nulo aqui.
‫Bem, uma razão é que talvez tenhamos esquecido de definir a classe de tela de perda.
‫E se esse for o caso e não tivermos uma classe de tela azul válida definida, então criar widget apenas
‫retornará um ponteiro nulo para nós.
‫E não queremos que isso aconteça e certamente não queremos chamar uma função no ponteiro nulo.
‫Assim como a seta da tela azul.
‫E então o que queremos aqui é uma função chamada add to viewport.
‫Que simplesmente vai fazer exatamente isso.
‫Vá e adicione-o à tela para que possamos ver a tela azul.
‫Agora, vou em frente e compilar isso também, e ir até o Unreal e abrir nosso projeto
‫para o controlador do jogador.
‫Então atire em um controle de jogo aqui e devemos ser capazes de ver em algum lugar aqui.
‫E uma variável ainda não apareceu.
‫Talvez eu tivesse algumas áreas de construção.
‫Vamos dar uma olhada no log de mensagens.
‫Sim, podemos ver alguns erros de compilação aqui, ou seja, esses estranhos sobre símbolos externos ausentes.
‫Se dermos uma olhada dizendo coisas sobre você, use um widget que não está disponível.
‫Agora, se você se lembrar de algumas palestras anteriores, sabemos que esses tipos de erros tendem a ocorrer
‫quando estamos perdendo uma dependência de módulo.
‫Então, se abrirmos nossos documentos de construção de atirador simples e eu fechar o terminal para um pouco mais
‫de espaço adicional, você poderá ver o que precisamos fazer é adicionar uma nova dependência pública aqui.
‫Então, ao final disso, vamos adicionar uma dependência pública para UMG.
‫Então, uma nova vírgula e depois entre aspas vai colocar UMG.
‫E isso basicamente nos permite fazer uso das inclusões que tínhamos aqui, o widget de uso de barra para frente do
‫blueprint.
‫Todas essas coisas estão em um módulo separado.
‫Então, o material padrão que está incluído.
‫Então, precisamos dizer ao desvelar que queremos usar esse módulo em C++.
‫Vamos em frente e construir e ver se funciona agora.
‫OK.
‫Isso parece bem sucedido.
‫Se formos ao editor e voltarmos para filmar um controle de jogo.
‫Por algum motivo, acho que não recarreguei corretamente, então tive que clicar em compilar aqui no editor.
‫Voltamos agora ao controlador de jogo de tiro.
‫Finalmente você pode ver aquela aula de tela solta.
‫Podemos clicar no menu suspenso e selecionar AWP, sublinhar, perder a tela lá, compilar, salvar
‫e vamos nos matar.
‫Leve um tiro algumas vezes.
‫Bate, bate.
‫E aí vai.
‫A tela Alu apareceu nos dizendo o que está acontecendo que o nível está prestes a reiniciar em 5 segundos,
‫e de fato acontece.
‫Portanto, agora você sabe não apenas como criar gráficos UMG, mas também como gerá-los a partir de C++ em
‫vez de Blueprint.
‫Na próxima palestra, vamos ter uma visão menos pessimista das coisas e tentar ver se
‫também podemos criar algumas condições de vitória para este jogo.
‫Vejo você então.