‫Nesta palestra, vamos montar um controlador de jogador que receberá informações de que o jogo
‫terminou do modo de jogo e criará esse comportamento de reinicialização que após 5 segundos recarrega o
‫nível após a morte do jogador.
‫Vamos mergulhar e ver como é feito.
‫Então, quando o jogo realmente terminar, precisamos notificar o controlador do jogador e também precisamos ter um controlador do jogador
‫em nosso C++ para que possamos implementar o comportamento de nos permitir reiniciar o nível e
‫tal.
‫Então, a primeira coisa a fazer é quando este ponto é morto, antes de tudo, estamos apenas registrando indiscriminadamente.
‫Queremos verificar se o jogo acabou ou não.
‫Agora, há dois cenários.
‫Um é onde ganhamos e outro é onde perdemos.
‫A derrota é a primeira que vou enfrentar porque é mais fácil.
‫Se o peão morto é o jogador que você perde, é isso.
‫Você pode optar por ter várias vidas com diferentes iterações deste modo de jogo, mas não vou fazer
‫isso.
‫Só vou ter uma vida de solteiro.
‫Se você morrer, game over.
‫Você pode querer reiniciar.
‫Então, como verificamos se esse peão é um controlador de jogador?
‫Bem, isso é bem direto.
‫Podemos apenas fazer um elenco para que possamos fazer um elenco para um controlador de jogador e para o peão morto.
‫E então se isso não for nulo.
‫Então vamos pegar o ponteiro.
‫Um ponteiro de controle de player para cima o chama de controlador de player e armazena o resultado desse ponteiro aqui.
‫E vamos dizer basicamente se isso não é não.
‫Então, se o controlador do jogador não é um ponteiro nulo, então sabemos que é o jogador que morreu e que o jogo
‫acabou para o jogador.
‫Então, o que queremos fazer é chamar esse método do controlador do jogador.
‫Já sugerimos o fato de que existe um método de jogo terminado.
‫Vamos dar uma olhada nisso.
‫Se fizermos um controle P e dermos uma olhada no controlador do jogador ponto h e pudermos procurar se um jogo terminou.
‫Você pode ver com certeza que existe um método virtual aqui chamado jogo terminou e você pode ver que há um
‫foco no final do jogo.
‫Em qual ator devemos focar no final?
‫Jogo por padrão, são pontos nulos e provavelmente é isso que vou usar.
‫E então vamos dizer, este é o vencedor?
‫Basicamente, você tem que deixar o jogador controlar e saber se ele ganhou ou não.
‫E isso é bastante simples, digamos, neste caso.
‫Não, eles não têm.
‫Então nós vamos fazer um jogo de controle de seta terminou, então eu vou colocar ponteiro nulo para o foco do
‫jogo final porque nós realmente não precisamos desse recurso e então é o vencedor.
‫Simplesmente vai ser falso.
‫Este não é o controlador do jogador vencedor porque é o que acabou de morrer.
‫Então é hora de um pequeno desafio para você implementar.
‫O jogo terminou em um controlador de jogo.
‫Isso significa que precisamos criar um controlador de jogador C++, criar sua subclasse de blueprint, gerar essa subclasse de blueprint
‫por padrão em nosso modo de jogo e então você deseja prosseguir e substituir.
‫O jogo terminou e coloquei uma mensagem de log lá para verificar se realmente estamos conseguindo.
‫Esse jogo acabou na hora certa.
‫Faça uma pausa, grave o vídeo e experimente.
‫OK.
‫Bem vindo de volta.
‫Então, passo um, crie esse controlador de player C++, crie uma nova classe C++.
‫Então vá e procure vamos ver, controlador de jogador.
‫Em seguida, vamos chamá-lo de controlador do jogador de tiro.
‫Vá em frente e crie essa classe.
‫Feito isso, queremos ir para nossos blueprints e criar uma classe de blueprint baseada nele.
‫Então, queremos o controlador de jogador de tiro como base assim e vamos chamá-lo de BP, controlador
‫de jogador de tiro de sublinhado.
‫No momento, isso não é realmente necessário, mas mais tarde, vamos querer conectar alguns recursos de interface
‫do usuário ao controlador do player.
‫Então nós vamos tê-lo lá pronto.
‫Em seguida, vamos para o modo de jogo BP KML e encaixamos isso porque queremos alterar a classe de controlador de jogador
‫padrão do controlador de jogador para nosso BPM, o controlador de jogador de atirador da escola.
‫Frio.
‫Então queremos substituir.
‫Nosso jogo acabou.
‫Então vamos ver se vamos para o controle do jogador para h.
‫Podemos ver que isso está na seção pública.
‫Aqui está a assinatura.
‫Vamos copiá-lo.
‫Vá para o ponto de controle do jogo de tiro e crie público.
‫Para esse jogo vazio virtual terminou.
‫Legal e já temos que substituir porque isso estava claramente sendo substituído de algum lugar para.
‫E então o que podemos fazer é ir em frente e implementá-lo.
‫Mudança de controle p, queremos chamá-lo de super-lembrete.
‫E queremos fazer jogo terminou assim.
‫E queremos passar no foco final do jogo e o B é o vencedor e então queremos logar.
‫Então você loga.
‫Ele é meu macro lá.
‫Terminamos.
‫Vai ser a mensagem de log saindo no final.
‫Então, vamos compilar e ver se isso está funcionando.
‫Eu vou para o log de saída.
‫Aperte o play.
‫Vá e seja morto, basicamente.
‫A saúde está indo devagar.
‫E então devemos ver uma mensagem.
‫Estamos recebendo a mensagem?
‫Não.
‫Então vamos dar uma olhada.
‫Qual é o controlador do player aqui?
‫O controlador do jogador de tiro BP sublinhado parece ser o correto.
‫O jogo de substituição terminou.
‫Agora, aqui, eu localizo um bug.
‫Agora, isso é algo que alguns de vocês devem ter notado e gritado
‫na tela é que aqui temos nosso controle de jogador para o qual estamos lançando e estou ficando confuso com
‫o peão real do jogador.
‫Então, o que queremos fazer aqui é pegar o controlador do peão que foi morto.
‫Então peão morto dot get erro do controlador.
‫Então, a seta obtém o controlador e queremos transmitir isso para o controlador do jogador.
‫E se isso for nulo, tudo bem, isso deve funcionar.
‫Então vamos em frente e tentar isso.
‫Vá em frente e aperte o play.
‫Castle está morto de novo.
‫E desta vez também não recebemos nenhuma mensagem.
‫E desta vez, é por uma razão sutil.
‫Isso é porque estamos desconectando do controlador.
‫Antes de chamar isso de -- morto.
‫Então, quando ele tenta pegar o peão controlador, isso é realmente não, não há mais peão controlador.
‫Portanto, precisamos fazer essa notificação antes de fazer a desconexão do controlador.
‫I inclui subir a linha que se apodera do nosso modo de jogo.
‫Eu não acho que isso importaria, mas agora que eu realmente penso sobre isso, sim, claro que importa.
‫Então vamos para o nosso nível e jogar.
‫Vamos levar um tiro.
‫E uma vez feito isso, você pode ver que terminamos de imprimir como queremos.
‫Então, tivemos alguns contratempos ao longo do caminho.
‫Não é sua culpa se você não conseguiu isso no desafio.
‫Você fez todo o resto até aquele ponto.
‫Isso é ótimo.
‫Então, espero que você tenha tentado depurar isso, mas não se preocupe se você ficou preso nessas coisas.
‫A última coisa que eu queria fazer aqui é realmente reiniciar o jogo em um cronômetro.
‫Agora, a maneira como podemos fazer isso é bastante direta, porque o controlador do player realmente possui um método de
‫reinicialização.
‫Então, se formos dar uma olhada nisso, deve ser um nível de reinicialização.
‫Esse é o que queremos chamar e queremos fazer isso em um temporizador.
‫Então, usamos temporizadores antes para repetir coisas, mas também podemos usá-lo apenas para atrasar uma ação em
‫uma certa quantidade.
‫Então eu vou para o jogador de tiro, controlador, ponto H e criar uma propriedade privada aqui.
‫Privado pode ser sua propriedade que é editada em qualquer lugar.
‫Flutuador.
‫Esse será o atraso de reinicialização.
‫Você pode ver por que já precisamos de uma base de projeto para isso.
‫Vou dar um atraso de 5/2.
‫Então eu vou passar para o C++ e vamos querer fazer um get timer bem, timer manager.
‫E então podemos fazer isso.
‫Então precisamos incluir.
‫Então hash include e será o gerenciador de timer dot H.
‫Então devemos ser capazes de usar o operador ponto porque o tipo de retorno aqui é uma
‫referência e vamos fazer um cronômetro definido.
‫E aqui precisamos passar um identificador de timer.
‫Então, na seção privada, vamos criar um conjunto.
‫Poderia ser um identificador de timer f.
‫Vou chamá-lo de temporizador de reinicialização como.
‫Então, esse será o identificador que passaremos para o nosso timer definido.
‫A próxima coisa que precisamos na quinta assinatura aqui é ter o objeto que queremos chamar, que será
‫apenas isso.
‫E então haverá acho que deve ser apenas o método em si.
‫Então, podemos fazer isso fazendo e comercial.
‫E então é na verdade o método, o método de nível de reinicialização, que queremos chamar que foi
‫definido no controlador de jogador A.
‫Portanto, um controlador de jogador.
‫Dois pontos, nível de reinicialização de dois pontos.
‫E então só precisamos passar o atraso que já definimos como o atraso de reinicialização.
‫Então faça isso, mas um ponto e vírgula no final e esperamos que possamos reiniciar após 5
‫segundos.
‫Agora vamos tornar o teste um pouco mais fácil abrindo nosso rifle e tornando-o um pouco
‫mais letal.
‫Então eu vou para os padrões, fazer o dano em 50.
‫Então seja morto com dois tiros.
‫Vamos e aperte o play.
‫Sejamos mortos rapidamente.
‫E depois de 5 segundos, esperamos que devamos reiniciar o nível que reiniciamos e voltamos ao nível.
‫Portanto, nosso cronômetro está funcionando como esperamos.
‫Agora, em versões posteriores, você descobrirá que, em vez de reiniciar, o que você verá é uma mensagem de erro que se parece com
‫isso e fala sobre falha de viagem e diz algo sobre você ler caixa de areia morna,
‫blá blá blá.
‫Bem, a maneira que temos de contornar isso quando estamos tentando reiniciar e queremos verificar
‫se nossa reinicialização está funcionando, é ir ao nosso menu ponto, ponto, ponto em vez do menu play e temos
‫que jogar como um jogo autônomo.
‫Se você jogar um jogo autônomo, demora um pouco mais para iniciar, mas a
‫reinicialização funcionará conforme o esperado e vemos o nível recarregado.
‫Agora, obviamente, não há muita indicação de que isso vai acontecer.
‫Então, vamos olhar para a interface do usuário nas próximas aulas.
‫Eu te vejo lá.