Transcrições
1. Apresentação: Neste curso,
vamos aprender como
desenvolver um multiplayer
para a plataforma pixel off usando blueprints
e Unreal Engine phi phi recriando uma mini versão
do conhecido
jogo 2D Maple Story. Este curso contém
tudo o que você precisa saber para começar com multiplayer para o desenvolvimento de
jogos no Unreal Engine cinco, incluindo Unreal Engine cinco, visão geral e navegação. Importando para o design do
ambiente de ativos usando mapas de mosaico, certo? Alguns flip books para
animar os ativos de pixel. Os fundamentos de projetos, criação de
personagens e
movimentos como pular, correr e bater em um
sistema de câmera para o personagem, criando inimigos
trabalhando com IA. Mecânica cegante para
cordas e letras. dano à saúde e a morte são tanto o jogador
quanto o inimigo. E experimente e
nivelando o sistema, criando interfaces de usuário,
carregamento de combate, texto, efeitos
visuais e efeitos
sonoros e recursos úteis
que o
ajudarão no processo de
desenvolvimento de jogos. Também fornecerei o projeto
finalizado para que você possa inspecioná-lo como
quiser enquanto segue o curso. Meu nome é mais caso
e eu sou o CEO, diretor de
jogos e
designer de capacetes de pixel. Eu tenho trabalhado no
Unreal Engine nos últimos oito anos e
recentemente lançei cauda de
ventilador no vapor, que recebeu
muito positivamente. Também passei dois
anos desenvolvendo meu projeto pessoal board craft. E atualmente estou dirigindo e programando o novo título da minha
empresa, que é um jogo de plataforma
3D sem aviso prévio. No final deste curso, você poderá criar
com confiança seu próprio projeto de
jogo 2D multijogador a partir do zero. Eu projetei este curso
para quem está interessado em criar
jogos e Unreal Engine cinco lutas com a
criação de um jogo
que atenda aos padrões atuais da
indústria. Espero que você se inscreva e
se junte a mim neste curso. E lembre-se de que estou aqui
durante todo o curso para ajudá-lo.
Espero vê-lo em breve.
2. Como baixar o Unreal Engine 5: Vá Instalar o Unreal Engine cinco, você tem que ir ao
Epic Games.com. Então, à direita, Epic Games.com, dentro do seu navegador de Internet. E dentro daqui você tem um botão azul à
direita chamado download. Então, clicando neste botão de
download, ele instalará o iniciador
Epic Games. Agora vou cancelar a instalação porque
já a instalei. E aqui está o
lançador na minha área de trabalho. Então, vou lançar
o lançador Epic Games. Agora ele pedirá que você faça
login e você pode inscrever com uma
conta gratuita da Epic Games se você não tiver uma, você também pode entrar com
todas as outras opções. Mas vou entrar com minha conta da Epic Games porque já
fiz uma. Então, clicando aqui, estou escrevendo meu e-mail, executando minha senha. E depois de fazer login
no iniciador da Epic Games, é
assim que parece. Dentro daqui, o que
você quer fazer é clicar nesta guia Unreal Engine. E dentro daqui você
quer clicar na biblioteca. Em vez de biblioteca, você pode ver todas as versões do Epic Game são todas
as versões do Unreal Engine. E você pode clicar
neste botão mais se
quiser instalar e a versão do
Unreal Engine. Então, clicando nele,
você pode ver este aparece e clicando
no número, você pode selecionar qual versão do Unreal Engine
deseja instalar. Agora você pode ver que eu já instalei o
Unreal Engine 55.2. Este pode ser um número diferente no momento em que você está
assistindo a este vídeo, talvez seja 0,4 ou 5,1, e isso realmente não importa. Este curso funcionará em qualquer versão que você
tenha instalado aqui. Então, apenas
certifique-se de instalar o Unreal Engine cinco aqui em baixo, você pode ver
seus projetos anteriores. Então, esses são meus
projetos anteriores e isso
estará vazio se você não tiver
usado o mecanismo antes. Então, depois de instalar o Unreal Engine cinco,
vamos seguir em frente.
3. Como criar um novo projeto: Vamos prosseguir e lançar o
Unreal Engine cinco. Depois de
iniciar o motor, essa janela aparecerá. Aqui. Você pode abrir
seus projetos recentes, mas agora estamos criando um projeto totalmente novo
e um jogo totalmente novo. Então, clicando aqui
na guia de jogos, você também pode ver um implacável, você pode fazer coisas
como filme e vídeo, automotivo, design,
arquitetura e assim por diante. Muito legal. Mas agora
estamos interessados em jogos. Então, clicando aqui e
à direita, você pode ver modelos diferentes com
os quais você pode começar. Por exemplo, você pode começar com um modelo
em primeira pessoa. Se você estiver criando um jogo de tiro em
primeira pessoa, você pode começar com um modelo de
terceira pessoa, um modelo de veículo e assim por diante. Mas você pode ver que não
há um para o
slot picks ou um jogo 2D.
E tudo bem. Todos esses modelos, você pode criá-los você
mesmo do zero se souber o que está fazendo. Portanto, isso não é muito
difícil de criar. E o que costumo fazer pelos meus
projetos, para meus cursos, costumo começar com
um projeto em branco porque quero ensinar-lhe
tudo do zero. E depois de aprender
tudo do zero, você poderá criar todos
esses modelos você mesmo. Então, vamos criar
um projeto em branco. E para a codificação,
estamos selecionando o blueprint. A plataforma de destino é desktop, a predefinição de qualidade é máxima. E para esse consentimento de dados se
isso estiver marcado para
você Apenas nos tickets, então não temos nada aqui. Só queremos um projeto em branco e
em branco e agora selecione
um nome para o projeto. E para isso estamos criando uma pequena versão
de uma história de bordo. Então vamos chamá-lo de história de
Maple assim. E você pode, claro, selecionar
onde deseja salvá-lo. Mas eu apenas o salvo
no local padrão. Então vá em frente e clique em Criar. Uma vez que o projeto é lançado, é
assim que ele se parece e diz: Gostaria de
atualizar este projeto? Só vou
clicar em atualizar. E para os plugins,
vou clicar em descartar. E isso provavelmente
não está aberto para uso em. Vou escondê-lo rapidamente. Seu motor provavelmente
se parece com isso. E agora que
criamos nosso primeiro projeto, vamos passar para
a próxima lição.
4. Visão geral do Unreal Engine 5: Antes de começarmos a criar
nosso projeto 2D, vamos ter uma
visão geral rápida desse mecanismo. A coisa mais importante aqui
no meio é a viewport. E dentro da janela de exibição, você pode ver seu
jogo de visualmente. Lembre-se, este é um mecanismo 3D, então estamos dentro de um mundo 3D. Este é o mapa de inicialização padrão dentro do Unreal Engine cinco. E aqui dentro da
porta de exibição você pode navegar. Então, segurando o botão
direito do mouse,
então, mantendo pressionado o botão
direito do mouse e clicando
em W no teclado, vamos movê-lo para frente. E segurar o botão direito do
mouse para baixo e clicar em S o
moverá para trás. Clicar em D irá movê-lo para a direita e clicar em um
irá movê-lo para a esquerda. Então lembre-se de segurar o botão direito do mouse
e você pode ver, você pode olhar ao redor, você pode se mover com W. D é um a, e isso é o que eu
uso o tempo todo. É assim que eu navego por
dentro do motor. Mas você também pode segurar
o botão direito do mouse e segurar o botão
esquerdo do mouse. Então, segurando os dois botões,
você
pode ver que você pode se mover
assim também. Segurando apenas o botão
esquerdo do mouse, você pode avançar e
para trás assim. E segurando o botão
direito do mouse, clicando em E no teclado, vamos movê-lo para cima e segurando
o botão direito do mouse e clicando até que eu o mova
para baixo no seu teclado. E como a última coisa, você pode aumentar e diminuir o zoom
com a roda do mouse. Se você tiver isso no mouse, você pode aumentar e diminuir o zoom. E novamente, o controle mais
básico que uso é segurar o
botão direito do mouse e clicar em W, D, S e a. Então é assim que eu encontro, a maneira mais fácil de
navegar, mas você é bem-vindo para
encontrar seu próprio estilo. Tudo bem. Em seguida, temos alguns botões
aqui na janela de exibição. Então, clicando no
primeiro
aqui , você pode, por exemplo, mostrar os quadros por segundo
e ver como, quantos quadros por segundo seu jogo está sendo executado
agora. Então, basta sobre isso agora, vamos remover o FPS. Há também algo
chamado visualização do jogo. E a visão do jogo
alega todos os ícones
dentro do jogo. Então, clicando neste aqui, você pode ver o
ícone desaparecer. O atalho é um G no
teclado, então clique em G. Você pode visualizar e ocultar
todos esses ícones. E isso é muito legal
quando você realmente
quer visualizar seu jogo
sem ícones. Você pode imaginar se você
tiver um jogo grande, você pode ter muitos ícones
dentro do seu nível. Então, clicando em G, você pode ver seu jogo sem
todos esses ícones. Você também pode ir para o modo
imersivo aqui embaixo, o atalho é se 11, e isso maximizará
a viewport. Então, clique em G irá
ocultar os ícones. Clicar em se 11 minimizará
ou maximizará a janela de exibição. E você pode realmente
ver o jogo aqui em tela cheia sem ícones e você pode ver como ele
se parece. Então, vou clicar em F7 novamente e clicarei em G
novamente para ver os ícones. Em seguida, estamos dentro
do modo de perspectiva, mas também há algo
chamado visões ortográficas. Assim, podemos ver o
jogo pela esquerda. Então, isso é o que
parece da esquerda. Se você diminuir o zoom, é assim que
parece de
cima e assim por diante. Vamos voltar ao modo de
perspectiva. Só quero mostrar
que isso existe. Então, vamos voltar
ao modo de perspectiva. Você tem os
modos de visualização aqui agora estamos assistindo
no modo Dalit. Então, com a iluminação, também
podemos assisti-lo
sem iluminação. Então, clicando em unlit, é
assim que o
jogo se parece. Sem qualquer iluminação aplicada, você pode usá-lo
no modo wireframe. Você pode voltar ao modo
lead e assim por diante. Em seguida, muito importante,
temos ferramentas diferentes que
usamos o tempo todo. A primeira é
a ferramenta de seleção. E antes de fazer isso, eu realmente queria gerar
algo dentro do meu nível. Então, vamos seguir em frente
e clicar neste botão Adicionar ao projeto
rapidamente. Clicando aqui em formas. E eu só quero
adicionar um cubo simples. Então, clicando neste
cubo e ele o
adicionará à sua janela de exibição
aqui no nível. A ferramenta Selecionar é apenas uma ferramenta na
qual você pode selecionar itens. Tão autoexplicativo. Clicando na ferramenta Mover, você pode mover itens. Então, clicando nesta
caixa aqui ou neste cubo, e você pode ver um ponto de
pivô aqui. E você pode arrastar
do tamanho diferente e
você pode movê-lo. Ou podemos clicar nisso,
neste círculo branco
no meio e você pode movê-lo para todas as
direções de uma só vez. Mas se você quiser
movê-lo para apenas uma direção, você pode arrastar essas setas. Em seguida, você tem a ferramenta girar. E novamente, você pode
girar essa caixa arrastando
esses ângulos aqui. E então você tem a ferramenta de
escala onde podemos
dimensionar a caixa em ângulos
diferentes. E se você quiser
dimensioná-lo uniformemente novamente, você pode clicar aqui
no meio. E você pode dimensioná-lo
para todos os lados ao mesmo tempo. Agora, é
muito importante lembrar os
atalhos para essas ferramentas. Então, clicando em q
no teclado, selecionaremos a ferramenta Selecionar. Clicar em w
selecionará a Ferramenta Mover, clicando em E no teclado, selecionaremos a
ferramenta Girar e
clicar em R selecionará a ferramenta de escala. E você pode ver
que isso o torna muito mais rápido. Em vez de clicar
aqui e movê-lo, clicar aqui novamente e
girá-lo e assim por diante. Isso leva uma eternidade. Então, clicando em w, Por exemplo, podemos movê-lo como um
E. Podemos girá-lo. Clicando em nosso talvez
você queira escalá-lo para cima, clique em W para movê-lo
acima do solo novamente. E você pode ver que isso é
muito mais rápido para se trabalhar, então você não precisa clicar
aqui o tempo todo. Mas lembre-se de que você
pode usar os atalhos Q, W, E e R. Então, se você quiser um documento completo
de todos esses atalhos, você pode encontrá-los no meu site. Em seguida, temos as ferramentas de encaixe. Então este é o encaixe de
movimento. Então você pode ver quando
eu clico em w para minha ferramenta de movimento e eu movo minha caixa, você pode ver que ela não está
se movendo sem problemas, está
se encaixando em algo. E esta é a
ferramenta de encaixe se você desativá-la. Então, clicando aqui, você pode ver agora que posso
movê-lo sem problemas. Se eu ativá-lo novamente,
estou encaixando agora. Você também pode aumentar esse
encaixe clicando
nesse número e
aumentando o número. Agora você pode ver que ele se
encaixa muito mais. E isso é muito útil
para usar se você quiser
colocar itens como ao lado um do
outro em um local específico. Então, outro atalho
é que você pode segurar Alt no teclado e
clicar e arrastar. E isso basicamente copiará colar o item assim. E talvez você queira colocar itens como este,
como segurar Alt, arrastá-los e
colocá-los assim. Isso é muito legal onde você
pode usar o encaixe aqui. Mas se você quiser mover
algo sem problemas, você pode simplesmente desativá-lo. E talvez você queira
colocá-lo
especificamente assim ou o que
quer que esteja fazendo aqui. Em seguida, temos o encaixe de
rotação. Então, novamente, clique em E. Você pode ver que ele gira a
cada dez graus. Você pode desativá-lo e agora podemos
girá-lo sem problemas. Mais uma vez. Você também pode aumentar
os valores de encaixe, por exemplo, a cada 30 graus. Agora ele se encaixa a cada 30 graus. Agora você pode
configurá-los novamente para o normal, por exemplo, dez aqui, e não foi até aqui. E o mesmo se aplica
ao dimensionamento. Você também pode fazer o encaixe
para o dimensionamento. A última coisa que temos
é a velocidade da câmera. Então você pode ver quando eu movo
minha câmera na janela de exibição, digamos que você tenha esse
grande mundo aberto e
levará uma eternidade para eu me mover
até lá. É assim que você pode
aumentar as velocidades da câmera. Então, por exemplo, você
pode colocá-lo em oito. Agora posso ver que posso me mover
muito mais rápido no meu mundo. E isso é muito útil para usar quando você tiver um mundo grande. Mas duvido que
usaremos tanto para nosso jogo 2D porque
realmente não temos um mundo tão
grande. Mas em um jogo 2D, talvez você queira se
concentrar em algo muito pequeno. E aqui é muito
útil reduzir a velocidade
da câmera para
algo muito lento. Porque talvez
às vezes em jogos 2D, você está olhando para detalhes
muito pequenos. E isso é bom para
configurá-lo para muito lento para que ele possa realmente se
aproximar dos itens. Ok, basta sobre a janela de exibição. Essa foi a
coisa mais importante dentro do motor. É aqui que você
pode ver o jogo. Em seguida, temos o painel Detalhes
e, dentro daqui, você pode
ver diferentes detalhes sobre itens
selecionados na janela de exibição. Então você pode ver quando eu
seleciono o chão aqui embaixo, eu recebo detalhes diferentes. Quando eu seleciono esse cubo. Mais uma vez, detalhes diferentes. Detalhes como localização, onde esse cubo está localizado
dentro do meu mundo? Qual é a rotação
desse cubo? Qual é a escala? E lembre-se que
escalamos esses cubos. Vou aumentar um
pouco a velocidade da
minha câmera novamente. Então este cubo aqui, lembre-se de que o
escalamos para cima e para baixo. E se você quiser redefini-lo, você pode simplesmente descer aqui para a escala no painel Detalhes. E você pode escrever
111, assim. E agora estamos de volta ao
que esse cubo era. Então, estava na escala de 111. Se você tiver girado, você
pode ver que giramos o cubo em dez graus
e o eixo z. E você pode ver o que é x, é segurando
o mouse sobre ele. Então o vermelho é o eixo x
e o verde é o eixo y, e o z é o azul. O azul aqui em cima é o Z, o X é esta seta vermelha, e a verde
aqui é o eixo y. Novamente, você pode redefinir a
rotação escrevendo 000, e agora redefinimos
sua rotação. E se você quiser colocar o
cubo em um local específico, você pode editar o local aqui. Você pode ver as edições de
localização quando você move esse cubo assim
na janela de exibição, basta olhar aqui para
que ele é o valor y agora. Mas se você quiser colocá-lo
especificamente em mil, você também pode apenas
mil assim. E você pode ver
que o cubo foi colocado especificamente
em mil. Muito útil usar o painel
Detalhes aqui. Se você tiver números específicos em que
deseja que os itens estejam. E se você rolar para
baixo, poderá ver todos esses detalhes diferentes que você pode visualizar e editar sobre esse
item selecionado. Portanto, não se preocupe com todos
esses detalhes por enquanto. Vamos trabalhar com tudo isso mais tarde
no projeto. Aqui em cima, no World Outliner, você pode ver o que você tem
atualmente dentro do seu nível. Então, neste momento, se você
clicar neste cubo, por exemplo, você pode vê-lo também selecioná-lo dentro
do outliner. Se você selecionar este cubo
aqui no selecionado, automaticamente dentro
do outliner. Você também pode selecionar os itens
clicando aqui
no outliner. E eu uso isso principalmente
quando quero encontrar um item específico e
clico nesse item. Por exemplo, a
luz de direção é a luz solar. E quando clico nele,
posso ver que está aqui em
baixo com todos
os outros ícones. Então, muito, muito básico. O World Outliner exibe todos os itens que você tem
atualmente dentro
do seu nível. Se eu clicar neste cubo e clicar em Excluir no meu teclado, clico neste cubo também e clico em Excluir
no meu teclado. Você pode ver que eles desaparecem
do World Outliner porque você não os tem
mais dentro do mundo. Aqui em cima, temos a barra de ferramentas
com os botões básicos. Então, clicando no arquivo, você pode criar um novo nível. Você também pode salvar o projeto e
criar um novo projeto. Dentro da edição, você tem as preferências do editor. E dentro das preferências da
guia de edição, você pode editar as configurações
sobre seu editor. Por exemplo, quando
eu seleciono essa caixa, você pode ver que a
linha de seleção é laranja. Eu posso basicamente
clicar aqui sobre isso, essa cor laranja aqui. Posso clicar nele e posso
realmente mudar a cor. E você pode ver que posso alterar a cor da seleção
dentro da minha janela de exibição. Agora eu nunca tive
a necessidade de editar nada dentro daqui,
então, na verdade, vou
fechá-lo novamente, mas é bom
saber que você tem essa opção dentro das configurações
do projeto. Você pode editar as configurações
dentro deste projeto. Então, por exemplo, você pode editar o ícone
de inicialização desse projeto. Você pode escrever um nome de empresa, você pode escrever um e-mail de
contato de suporte. Por exemplo, quando você
libera o jogo no Steam, as pessoas sabem com quem
contatar se
tiverem bugs dentro do jogo ou se realmente
querem entrar em contato com você. Você também pode adicionar um filme. Então, você sabe, quando
você abre um jogo, você tem esse
filme de inicialização, talvez cinco segundos. Então você pode realmente adicionar
um dentro daqui. Então, muitas coisas que você pode editar aqui especificamente para este
projeto. Portanto, as preferências do editor
são configurações para o seu editor e as configurações do projeto são configurações especificamente
para este projeto, os projetos Maple Story
que estamos criando agora. E então temos plugins e queremos trabalhar com
isso agora. Portanto, não se preocupe com isso. Em seguida, dentro da janela, você pode abrir várias janelas. Isso é muito útil se você
tiver vários monitores. Por exemplo, podemos ir para Viewport e clicar
em Exibir porta dois. E isso abre uma
segunda janela de visualização aqui. E posso ver aqui esta
viewport, isso é muito útil. Posso ver meu jogo em tela
cheia e posso colocar isso dentro do meu outro monitor. E agora eu posso ver
este jogo aqui. E no meu segundo monitor, tenho essa janela de visualização que abri o tempo todo. Não se preocupe com tudo isso. Não tocaremos nisso até
mais tarde no projeto. E no final
da ajuda, você pode visualizar a documentação
do Unreal Engine cinco. Acho que está um pouco faltando
agora e difícil de entender, mas você pode dar uma
olhada se quiser. Aqui na barra de ferramentas, você tem ferramentas diferentes
que você pode alternar. Por exemplo, você pode
criar paisagens, você pode criar folhagem, como grama e
árvores e assim por diante. Mas não queremos
tocar em nenhuma dessas ferramentas, porque lembre-se,
estamos criando um jogo 2D e não um jogo 3D. Então, vamos manter essas
ferramentas por enquanto. Para este botão, você pode
adicionar itens diferentes. Adicionamos a esfera ou o cubo, na verdade o cubo
dentro daqui. Mas você também pode adicionar outros
itens, como iluminação. E você pode adicionar cinemática. Então, câmeras, você pode adicionar
volumes, efeitos visuais. E vamos adicionar algumas
coisas dentro daqui. Mas, novamente, lembre-se,
estamos criando jogos 2D, então não usaremos
toda essa iluminação. Mas eu diria o
mais legal sobre a criação um jogo 2D dentro de um mecanismo 3D. Você pode imaginar, você pode criar um jogo 2D com efeitos
de iluminação 3D. Há algumas coisas legais
que você pode fazer dentro de um mecanismo 3D ao
criar jogos 2D. Aqui estão as plantas. Esta é a codificação e
trabalharemos com isso mais tarde. Portanto, não se preocupe com isso. E aqui você pode clicar
no botão Play
para jogar o jogo. E agora não temos
muita coisa acontecendo. Portanto, não há muito o que ver. Clicar em escapar sairá
do Modo Play Game. E como a última coisa, o que eu quero mostrar
é o navegador de conteúdo. E é aqui que todos os arquivos que iremos
importar serão. Então, se você for
aqui para a esquerda, você tem algo
chamado desenho de conteúdo, clicando nesse botão, essa janela aparecerá
dentro desse desenho de conteúdo. Todos os itens que
importamos estarão dentro daqui. Então, todos os
personagens que temos, todas as músicas, todos os efeitos visuais, todos os arquivos estarão aqui no Navegador de
conteúdo. E agora você pode
ver que você tem que
clicar aqui para abrir isso. E acho que para mim é um
pouco chato porque quando
clico em algo na
janela de exibição, isso desaparecerá. Algumas pessoas acham que isso é legal, e tudo
depende do estilo. Mas acho que para mim é
um pouco chato que ele desapareça o tempo todo quando clico em algo aqui. E também para o curso, acho que será ótimo
ter isso o tempo todo. Então, vou clicar
em escavado no layout. também assim que foi
no Unreal Engine quatro. E isso vai ficar
acordado o tempo todo mesmo que eu clique
nas coisas aqui. E prefiro ter isso o tempo
todo para poder ver meus arquivos dentro
do navegador de conteúdo. Você pode clicar neste botão Adicionar e adicionar coisas
diferentes. Por exemplo, podemos
adicionar uma classe de blueprint, e essa é a
programação que
faremos mais tarde. Você também pode adicionar coisas
sobre a animação, coisas sobre blueprints, efeitos de
folhagem, interfaces de
usuário para a interface do usuário. E isso pode parecer
esmagador porque você tem tantas coisas
que você pode adicionar, mas você só vai usar, eu diria que cerca de vinte e cinco
por cento de tudo isso. Portanto, não se preocupe com
todos esses botões. Você não usará tudo isso. E eu diria que
você deve começar a aprender o
básico e apenas seguir em frente e
facilitar para si mesmo
aqui e para o papel 2D, é com
isso que
estaremos trabalhando. Então este é o pixel art, o jogo 2D com o qual
estaremos trabalhando. Você também pode adicionar itens dentro do navegador de conteúdo
clicando com
o botão direito do mouse aqui. Então você pode ver, você pode
ver a mesma coisa. Normalmente, nunca
clico neste botão. Acabei de clicar com o botão direito
aqui à direita. Você também pode adicionar pastas
diferentes clicando com o botão direito do mouse aqui. E na parte superior você pode clicar em Nova pasta e criar novas pastas. E vou
excluir este clicando em Excluir no
meu teclado por enquanto. E se você quiser,
você pode ir em frente e clicar neste cubo excluído, excluir este também. Agora conhecemos o básico
desse mecanismo e
como ele é construído. Portanto, é muito mais fácil
para nós trabalhar com nosso projeto.
5. Como criar um novo nível: Para criar um novo nível, primeiro
vamos criar uma pasta. Aqui na pasta de conteúdo. Vamos clicar com o botão direito do mouse e
clicar em Nova pasta. E vamos chamá-lo de mapas. Em vez desta pasta de mapas
aqui à direita, você pode clicar com o botão direito do mouse
e clicar em nível. Agora
vamos chamar isso. Gostaria de dar a todos os meus
arquivos que crio um prefixo. Então, vou
chamá-lo de mapa para começar. E isso facilita uma vez que
você tenha muitos arquivos, você pode realmente
procurá-los muito mais fácil escrevendo o prefixo. Então, chamá-lo de mapa, e
vamos chamá-lo de principal. Acabei de chamá-lo de mapa principal. Não sei o nome que
quero dar agora, então vamos chamá-lo de Mapa Principal. E aqui em cima, a propósito, você pode salvar tudo, então salve tudo. E se você tiver feito edições
dentro desse nível, então antes de editarmos cubos, então se eu adicionar um cubano excluído
e você estiver tentando salvar, ele pede que você salve este mapa aqui porque
você fez edições. E, na verdade, não
queremos salvar esse mapa porque não vamos
usar esses mapas padrão. Vou clicar duas vezes no
meu novo mapa que criei. Vai me pedir para
salvar esse nível aqui. Vou clicar
em Não salvar. Agora estou dentro do meu
novo nível e você pode ver aqui no meu outliner, World ,
Outliner,
realmente não tem nada porque você não tem nada dentro desse nível agora. Agora, antes de encerrarmos este vídeo, vamos definir esse nível
como nosso mapa padrão. Então, vou editar e
dentro das Configurações do projeto, você pode clicar em mapas e modos. E aqui você pode ver o
editor Startup Map é atualmente esse mapa mundial
aberto padrão. Clicando aqui e alterando-o para o nosso mapa que criamos, tanto o Mapa de Inicialização quanto
o mapa do jogo padrão. Assim mesmo. Agora, quando você
fechá-lo, basta clicar em arquivo e salvar tudo. Agora, quando você fechar o
mecanismo e abri-lo novamente, ele será
aberto por padrão nesse nível.
6. Como importar os recursos do ambiente: Vamos agora importar os ativos do
ambiente que usaremos
nas lições futuras. Então, aqui, vou clicar com o botão
direito do mouse
na pasta de conteúdo novamente
e criar uma nova pasta. E vamos chamar isso de ativos. Em vez dessa pasta de ativos, vou clicar com o botão direito do mouse
e criar uma nova pasta. E vamos chamar isso de um
ambiente em restos de fio. Ok, então é muito bom
manter-se organizado dentro do seu projeto porque quando
o projeto se tornar grande, será uma dor navegar se
você não souber onde os arquivos estão localizados dentro desta pasta de ambiente,
vou clicar nela. Queremos importar nossos arquivos. Eu lhe dei este material
do curso. Então, dentro dos materiais do
curso, se você puder entrar na pasta Ambiente, dentro daqui,
forneci alguns dos arquivos. Pode haver mais arquivos
que você vê aqui. Só estou colocando esses arquivos dentro dessa pasta à medida que vou. Então, o que eu quero que você
importe como apenas este, a estrada do dragão t e a chamada
estrada do dragão do mar, BG para fundo. Então, esses dois aqui, você pode simplesmente clicar e arrastá-los e colocá-los dentro
da pasta Ambiente. Lembre-se, se seus arquivos
ainda estiverem em um formato raro ou zip, você não pode arrastar diretamente de
uma pasta zip dentro daqui você precisa extrair esses
arquivos para sua área de trabalho talvez, ou qualquer local que
você queira. E então você pode simplesmente,
assim como uma pasta normal aqui, arrastá-los para dentro do projeto. Certo? Quando você está dentro
do projeto aqui,
você pode ver que temos nossas duas texturas e
quando você clica nelas, então, por exemplo, clico neste PGY1 e dopants
no meu segundo monitor. Este é o que
usaremos. Agora este pode ter, você pode ver quando eu
zoom in, está desfocado. Não é realmente escolhe muito. E, como você sabe, a pixel art não
está borrada assim. São
pixels muito claros que queremos. E é isso que estamos
conseguindo agora, porque você está novamente dentro de um mecanismo 3D e o mecanismo 3D explode para
fazer tudo parecer bom. Mas, no caso de um jogo 2D, não
queremos que
ele se desfoque. Isso é muito fácil. Basta clicar em ambos. Então clique neste
pressionando Control, clicando no segundo,
posso clicar com o botão direito do mouse, ir para ações
Sprite e dizer Aplicar
papel às configurações. E isso basicamente
removerá esse efeito de desfoque. Então, quando volto
aqui e amplio, você pode ver que o
efeito de desfoque se foi agora e você pode ver
cada pixel. E agora vamos clicar
em Arquivo e Salvar Tudo, e foi isso para este vídeo. É muito importante tirar deste vídeo quando você
importar arquivos
de pixel art,
lembre-se de clicar com o botão direito do mouse, ir para ações do Sprite e
aplicar configurações de pimenta 2D para remover esse efeito de desfoque que
o mecanismo anuniza por padrão.
7. Como criar um conjunto de Tile: Agora que temos
nossos ativos prontos, estamos prontos para
criar um conjunto de blocos. E no próximo
vídeo, vamos criar algo
chamado mapa de mosaico. Então, a diferença
entre um conjunto de toalhas e um mapa de azulejos é que Tell
disse que você pode imaginá-lo. Se você estiver pintando,
o conjunto de toalhas são suas cores e o
mapa de azulejos é sua tela. Então, precisamos dizer aos conjuntos
para criar um mapa de mosaico. Vamos criar os conjuntos de toalhas, as cores com as quais você está
realmente querendo
pintar no mapa de azulejos
que criamos mais tarde. Então, vamos clicar com o botão direito do mouse
neste primeiro aqui. Esses são os azulejos. Vamos clicar com o botão direito do mouse. Vamos para a ação Sprite e vamos clicar em
Criar conjunto de toalhas. Vou renomeá-lo. Normalmente, excluo esse
conjunto de mosaico e o fim aqui. E eu só chamo isso de
ts ou conjunto de toalhas. E vamos fazer a mesma coisa
aqui com o plano de fundo. Vá para ações do Sprite e
aplique outro lugar. Conjuntos de ferramentas muito ótimos. E novamente, vamos renomear esses dois níveis
desde o início. Então agora temos que contar conjuntos. Vamos no primeiro
aqui, nossos azulejos. Então agora podemos ver que estes são os azulejos e não podemos fazer muito aqui em vez
de um conjunto de toalhas. Lembre-se desse conjunto de mosaico, só o criamos
para que possamos
usar esses blocos para
pintar em nosso mapa de mosaico. E agora você pode clicar nesses diferentes
azulejos e você pode realmente ver as toalhas
quando você clica nelas. Eles serão exibidos
aqui à direita para que você
possa ver a toalha e
o que ela parece. Mas o tamanho não está correto. Você pode ver aqui o tamanho do
ladrilho à direita. Você tem que definir isso
para 30 pixels por 30 pixels porque eu
sei que são 30 pixels. Eu os componho
dentro do Photoshop, então os juntei
aqui em uma textura. Então eu sei que o
tamanho total é de 30 pixels. Pixels. Quando você baixa coisas
da Internet, elas geralmente
especificam o tamanho delas. Então é aqui que você os define. Então 30 por 30. Agora isso está correto e quando
você clica nos blocos, você pode ver
que é assim que eles se parecem. E usaremos isso mais tarde
para pintar em nosso mapa de azulejos. Vamos fechar isso
e vamos o título definido
para o plano de fundo. O tamanho do bloco também é 30 por 30, então temos que mudar
isso para 30 por 30 pixels. Então, isso foi o importante. Definimos o tamanho do nosso ladrilho
dentro deste conjunto de azulejos. E agora que temos
esses conjuntos de blocos, deixe-me realmente clicar com o botão direito
dentro dessa pasta, criar um novo chamado texturas. E eu quero colocar
essa textura dentro das minhas texturas porque não
vamos precisar mais disso. Não o exclua porque eles são realmente
derivados dessa textura. Lembre-se de que clicamos com o botão direito
e criamos um conjunto de toalhas. Mas eu só os coloco
dentro de texturas porque não
precisamos ver isso de novo. Além disso, a mesma coisa com
esse plano de fundo, mova-o para dentro dessa pasta, e só precisamos
ver esses conjuntos de blocos. Então, vamos clicar em Arquivo, Salvar Tudo e vamos seguir em frente.
8. Como criar um mapa de mosaicos: Agora podemos clicar com o botão direito do mouse
em nosso conjunto de ferramentas. E quando você clica com o botão direito do mouse, você pode ver aqui que
você tem a opção criar um mapa de mosaico. Então, vamos criar um mapa de mosaico. E novamente, vou excluir esse mapa aqui no
final que ele colocar. E vou chamá-lo de TM para mapa de mosaico como prefixo. E você pode clicar duas vezes
no mapa de mosaico para
entrar aqui. Aqui antes de eu fazer
qualquer coisa à direita, lembre-se que você tem que definir
a largura e a
altura da cauda para 30 por 30. Então, certifique-se de que
isso esteja correto. E isso é apenas para definir
o mesmo que este. Então, seja lá o que você definir
aqui dentro do conjunto, você tem que definir a
mesma coisa dentro
do mapa de mosaico quanto à largura e altura do
mapa, você pode escolher
o tamanho do seu mapa. Então, qual a largura do seu mapa B? E para este, acho que vou
com 60 e a largura e 40 e a altura. Então este é o mapa
em que estaremos trabalhando à esquerda. Você pode ver os conjuntos de toalhas. Então, agora, o conjunto ativo de
azulejos é este, a estrada do dragão onde
temos nossos azulejos. E você pode clicar em qualquer lugar
aqui, selecionar algo. E quando você
selecioná-lo aqui à esquerda,
agora você o tem aqui como um pincel
dentro de seus mapas de mosaico. Então eu posso clicar aqui e
você pode ver quando você clica em sua pintura
no seu mapa de mosaico. Não há uma
maneira rápida de excluí-lo. Você precisa
excluí-lo, mas um por um. Então, clicando em e para
escolher a borracha. E você também pode
clicar aqui em cima a pintura, navalha e o preenchimento dizer clicando
em e para escolher a borracha. Você pode apagá-los
e clicar em B no teclado para
escolher o pincel. Então B para o pincel
e clicando no IE para apagar esses pincéis novamente. Então, o que eu também
gostei aqui à esquerda, agora
você pode pintá-lo
aqui no mapa de azulejos. E dentro do mapa de mosaico, ele consiste em camadas. Então, se você trabalhou dentro do Photoshop, você
sabe o que é isso. Se você quiser alterar
um nome de uma camada, você pode clicar em F2
no teclado. Você pode clicar com o botão direito do mouse
e alterar o nome, mas geralmente clico em
F2 para renomear as coisas. Então, clicando em F2
e, por exemplo, posso chamá-lo de camada base. Posso criar uma nova camada
clicando neste botão. E eu posso, por exemplo, renomear isso para plano de fundo
na camada base. Se você tiver isso selecionado, vamos pintar algumas peças
aleatórias aqui. Vamos fingir que esses são os
azulejos que temos. Agora posso ir para o fundo e digamos que quero
pintar o fundo. E vamos dizer apenas aleatoriamente, meu histórico é esse. Posso pintar isso. Você pode ver que agora está em primeiro plano porque é
assim que as camadas funcionam. Então, a frente
estará na frente. Então, se você quiser que este
seja o plano de fundo, você tem que colocá-lo
abaixo da camada base. Então clique no plano de fundo. Você pode clicar nesta seta. Diz Enviar para trás, e ele o colocará
para trás aqui. E agora, seja lá o que
você pintar, você pode ver que não pode
pintar sobre isso porque
esse
é o seu plano de fundo. Agora, quando você clica na camada
base agora você pinta mais. Você pode ver, você pode pintar
na frente do seu plano de fundo. Porque lembre-se que este
é o plano de fundo e essas são duas camadas
separadas. Então, se você clicar no olho
aqui na camada base, você pode ver que este
é o plano de fundo. Você também pode ocultar o
plano de fundo e assim por diante. Muito, muito útil. Vamos usá-los
para pintar nosso mapa. E isso é basicamente para
o mapa de mosaico. Então, nada complexo.
Temos alguns azulejos. Podemos desenhar nosso mapa aqui
e torná-lo incrível. E podemos usar essas
camadas para pintá-lo. Então, o fundo, a base, talvez
tenhamos um
primeiro plano e assim por diante. Lembre-se de definir a largura e altura do seu mapa como desejar. Eu quero que o meu seja 60 por 40, e a torre
teria que ser 30 por 30 porque esses blocos
são 30 por 30 pixels, você pode simplesmente excluir
o plano de fundo. Então, clicando aqui em cima, clicando em
Excluir no meu teclado, ele esmagou meu mecanismo. Deixe-me reiniciá-lo. Às vezes acontece
com o Unreal Engine. Então, às vezes, ele apenas
esmaga aleatoriamente. Então,
deixe-me voltar para o meu conjunto de blocos e você pode ver tudo
isso já excluído. Então isso acontece às vezes, então Unreal Engine,
tenho que recriá-lo. Então, criando o mapa de mosaico, vou criar
a coisa toda de novo, ok, agora estou de
volta onde estou. Eu defini minhas configurações
aqui e estamos de volta. Então, vamos passar para
a próxima lição e vamos
projetar o ambiente.
9. Como criar o ambiente: Vamos agora começar a projetar
nosso ambiente. Então, para começar, vamos
voltar ao nosso mapa de mosaico. E dentro daqui, se você não tiver um conjunto de toalhas
selecionado aqui para o lado, como você pode ver na minha tela, você pode clicar
neste pequeno botão. É também aqui que
você alterna entre seus blocos de fundo e
suas células normais aqui. Então, vamos começar com esses azulejos
normais por enquanto. O que vou
começar é apenas chamando essa camada de quatro baías. Então, vou clicar em F2, chamando-o dessa camada base. Dentro daqui
vamos pintar. Mas antes de pintar,
o que eu gosto de
fazer aqui nas alturas do mapa, gosto de adicionar um pouco mais de
peças como tampão. Porque quando nosso personagem é, você pode imaginar que este é nosso mapa e esses
são os limites. Quando o personagem está
parado aqui no jogo. E a câmera é assim,
assistindo o personagem. A coisa aqui abaixo do
mapa aqui ficará escura. E não queremos que o jogador
assista a essa parte inferior aqui. Eu quero que o personagem fique
parado de uma forma em que a câmera nunca fique
abaixo desta linha aqui. Gosto de adicionar um pouco mais de peças do que o que escrevi aqui, só para ter alguns blocos de
buffer para que a câmera nunca
fique abaixo do chão. Então eu gosto de adicionar dez
peças ao fundo aqui, e também dez peças
no topo aqui. Então a câmera e nunca
vai acima desta linha aqui. Então o que eu posso fazer é, então dez mais dez é 20
obviamente, e é 60. Algo muito legal
e Unreal Engine. Você pode realmente escrever
mais 20 e pressionar enter, e ele o adiciona automaticamente
e diz 60. Agora, acho que não precisamos de
um buffer aqui e aqui porque o que vou
fazer é
parar a câmera. Quando o jogador
caminhar assim, vou parar
a câmera aqui. Então, nunca vai
atrás dessa linha, mas sempre podemos torná-la
maior se você quiser. Certo, então vamos contar aqui. Adicionamos dez tampão, dez blocos de buffer aqui. Então 123412345678910. Então, aqui, aos 50. Então, se pintarmos uma toalha
aqui, estou aos 50 anos. Então, os blocos de buffer
vão até aqui e os blocos reais estão
acima aqui. Então, o que você pode fazer é pegar essas peças aqui e
começar pela esquerda. Então, você pode selecionar
vários blocos. Você não precisa
selecionar um de cada vez. Você pode selecionar,
clicar e passar o mouse e selecionar vários blocos de uma só vez. E você pode
colocá-los aqui dentro da nossa camada base que
criamos. Então agora eu coloquei isso, você pode continuar colocando assim. Mas, como variedade, vou
clicar em Control Z para desfazer. Como variedade, você pode ver que
você tem alguns deles. Então você pode escolher aleatoriamente outro como
este e colocá-lo. Ele pode escolher um aleatório, colocá-lo, isso dá às
telhas um pouco de variedade. Então você pode ver aqui que
você tem um pouco de variação e você pode dizer que
esses são o mesmo título. Então, vou
selecionar aleatoriamente aqui. Não importa
quais você escolher apenas para tentar
selecionar aleatórios. Então, eliminamos padrões
repetitivos que
vemos às vezes em pixel lot. Muito bom ter telhas
diferentes que
você pode colocá-la. Certo, vou
acelerar esse processo. Vou fazer isso
o caminho todo aqui. E você também tem que
fazer isso todo o caminho aqui. Então, continue fazendo isso. Isso levará
talvez cinco minutos. Tudo bem, então agora estou
terminando aqui. Estou fazendo as últimas peças. Então agora eu terminei
esta parte inferior aqui. Certo? Então, quando você
terminar essa parte, você já deve criar
a grama aqui em cima. Então aqui em baixo para a
grama, a mesma coisa. Você tem alguma variação
que você pode adicionar. E você pode selecionar, clicar e selecionar
todos os três. E lembre-se também de selecionar esta parte superior porque
se você clicar aqui, você pode ver que está
perdendo a grama aqui
se você não estiver selecionando
essa parte superior também. Então, clicando em
ambos, selecione isso e isso acima dele. Então, esses seis azulejos. E então você pode
simplesmente, assim como antes, clicar aqui e selecionar outra variação
e clicar ao lado dela. E continue até que eu não quero que você faça
isso até aqui. Eu quero que você pare
em algum lugar por aqui, então eu só vou
avançar um pouco. Certo. Então vou parar aqui e
parei por volta de 3947. Estas são as
coordenadas que você não precisa fazer exatamente como eu, mas se você quiser, essas as coordenadas com as quais
estou parando. Você pode fazer seu próprio design. Isso é bom. Você não é obrigado
a fazer a mesma coisa. Mas o que eu quero fazer aqui, temos algumas rampas
aqui na textura. E queremos adicionar esses azulejos. Quero adicionar uma rampa aqui para que
possamos ter alguma variação. Então, novamente, você pode clicar aqui
e selecionar assim aqui. E você pode adicionar
a rampa aqui. E, novamente, vamos
continuar com os blocos, selecioná-los e
continuar como antes. Continue selecionando uma
variação como essa. Você pode ver que leva algum tempo, mas também, acho que
é a parte divertida. Você pode ser criativo com
o mapa que você está criando. E você pode criar
algo legal. Então, estamos perdendo
alguns azulejos aqui em cima. Agora. Vamos em frente
e, como antes, apenas, vamos preencher
essas lacunas vazias. Tudo bem, então esta parte está pronta. Agora, o que eu quero fazer como a última parte é aparecer em
uma plataforma. Então, vamos, novamente, adicionar uma plataforma, vamos
selecionar essa parte inferior. Então, selecionando um desses, você pode ver que tem
variações aqui também. Então, selecionando a
parte inferior, eu não sei. Sim, nós realmente precisamos selecionar
a parte inferior aqui também porque você pode ver que existem alguns pequenos azulejos que
estão abaixo disso. Então, novamente, assim como
a grama onde
selecionamos seis peças aqui, temos que selecionar seis
peças aqui também. E para a plataforma, só
temos que olhá-la, ver onde está o personagem. E eu acredito em algo
como aqui em cima. E novamente, vamos escolher algumas variações e apenas
adicioná-las. Lembre-se de selecionar
todo o sexo e não,
não apenas aqui em cima, porque senão você está perdendo as
peças aqui embaixo. Então selecione aqui, faça
algumas variações e faça a plataforma pular um pouco à frente. Tudo bem, então agora que eu tenho
essa longa plataforma aqui, você pode adicionar a grama
e, como antes, basta selecionar o que
fizemos aqui. Selecione a variação. E agora estamos perdendo esses
azulejos aqui à direita. Eu realmente não consegui encontrá-los. Eu tentei e
tentei e não consegui encontrá-los. Mas o que podemos fazer
é apenas adicionar algumas
dessas peças para terminar
esta parte aqui, porque isso é cortado como você pode ver e
não está bem. E eu realmente não tenho
a parte cortante. Estes, eles
realmente não funcionam com isso. Então, temos que fazer o nosso próprio e
vamos usar este. Então, o que vou
fazer, você pode ver aqui, se eu selecionar isso e
adicioná-lo em cima disso, como aqui, você pode
ver que estou excluindo meus blocos atuais e isso
não é algo que queremos fazer. Lembre-se, tínhamos camadas com as
quais podíamos trabalhar. Assim, você pode criar uma nova camada. E vamos chamar isso de uma marca. E com essa camada frontal, agora
podemos selecionar esses
blocos aqui, por exemplo. E, por exemplo, neste
lado, você pode ver agora que você pode clicar e adicioná-lo e não excluir os blocos que você fez antes. E isso é porque agora você está pintando nesta camada frontal. Você não está pintando mais
nesta camada base. Lembre-se de selecionar
esta camada frontal e pintar sobre ela aqui em cima. E também selecione
esses azulejos aqui, apenas os três aqui embaixo. E vamos adicioná-lo em cima daqui. E você pode ver
isso meio que funciona. É melhor do que nada. Então agora temos as toalhas
fechando que cortam aqui. E vou
selecionar o próximo, adicioná-lo em cima dele e selecionar a
parte inferior para acompanhar esta. Agora posso ver que
temos uma plataforma. Poderia ser melhor se tivéssemos os títulos de fechamento,
mas está tudo bem. É apenas para praticar. Ok, então a próxima coisa que você pode adicionar aqui é o plano de fundo. E o que podemos fazer é
adicionar outra camada. E, na verdade,
vou chamá-lo de céu. Eu vou usar
essa camada apenas para o céu e colocá-la, você
pode clicar nessa seta,
lembrar, e colocá-la
na parte de trás porque
queremos que isso seja um plano de fundo para esse cara. Lembre-se agora que estamos dentro
das telhas normais. Você quer mudar
para o plano de fundo. Novamente, você pode clicar neste
pequeno botão e
alternar entre o plano de fundo
e os blocos normais. Então, indo para o fundo, você tem este pequeno azul. Este é, na verdade, o céu. Então, basta clicar neste,
clicar em G para a ferramenta de preenchimento, ou você pode selecioná-la aqui. Lembre-se de que você pode selecionar
as ferramentas aqui. E então lembre-se de
clicar nesse cara primeiro. E aqui, você pode
clicar em cima da audição, ver você preencher a lacuna
e agora temos o céu. Agora, o que podemos adicionar aqui, é um pouco sem graça, então precisamos adicionar alguns itens de
fundo. Agora, você quer fazer uma nova
camada porque se você pintar, digamos que você queira
fixar esta grama e clicar em B para selecionar a ferramenta pincel e
anexá-la aqui você pode ver o céu está sendo removido porque você não pode
pintar em cima disso. Então, vamos criar uma nova
camada e deixe-me
chamá-la de fundo e de fundo
estreitamente. Estes são apenas adereços traseiros. Vamos chamá-lo de
fundo e vamos ver se precisamos
mudar o nome dele. Então, vamos tentar
projetar algo. Então, vou começar
com este prédio. Então, basta selecionar
todo esse edifício aqui e
colocá-lo em algum lugar aqui. Então, parece um pouco
interessante assim. Ok, então agora temos este
e você pode até adicionar um poste de luz aqui. Então, isso é apenas sobre
ser criativo, tentar fazer o que você quiser. Você realmente não
precisa me seguir aqui. Só estou tentando
criar coisas à medida que
vou e vou pular
um pouco à frente. Assim como antes. Basta selecionar o que você
quiser adicionar em algum lugar. Talvez você queira adicionar
este poste de luz aqui. Então tente fazer suas próprias coisas e eu te vejo
daqui a pouco. Tudo bem, então adicionei
alguns itens. Você pode ver meu mapa
se parece com isso. Agora, eu adicionei. Há uma grama aqui. Acabei de adicioná-lo
aqui ao lado. Então, parece um pouco
cortado e interessante. E eu adicionei esses
itens aqui, as flores e apenas o
lado que adicionei antes. Então, não gosto de adicionar
muito dentro do ambiente. Eu gosto de mantê-lo
simples porque ele será agrupado se você adicionar
muito ao ambiente
e
não ficará bem na minha opinião. Então agora temos esses itens
mínimos que inserimos dentro
de um ambiente. Agora o que eu quero que você
faça, eu quero preencher o fundo aqui para
que não seja muito azul. Quero preenchê-lo com
esses grandes planos de fundo. Então vá em frente e selecione
essa coisa grande aqui, assim e você pode
ver que pode colocá-la ao redor. Agora não queremos
colocá-lo em cima de nossos itens aqui. Então, vou adicionar
outra camada aqui, e vou
chamá-la de BG para o plano de fundo 01. Acredito que precisamos fazer dois
deles e você verá o porquê. Então, BG 0102, vou
passar de 0 para abaixo do 01. E este, em vez de
chamá-lo de fundo, vamos chamá-lo de adereços BG, então adereços de fundo ou
algo parecido. Então, clicando no primeiro, o plano de fundo é 01. Não quero adicionar a
coisa toda aqui assim. O que eu quero fazer é apenas, eu só quero adicioná-lo assim. Então eu só vejo a árvore
sem todos os, sem todo esse
edifício abaixo dela. Então, só vendo as árvores e preenchendo o
fundo com ela. Então, para o plano de fundo 01, vamos tentar ver se
podemos fazer com que pareça interessante,
algo assim. E de 0 a, acho que ainda não
podemos preenchê-lo com 01. Na verdade, podemos preenchê-lo aqui. Vamos realmente preencher 0 para primeiro, clique em 0 para, eu só
quero visualizá-lo melhor. Então, algo assim, talvez. Vamos tentar 01 novamente. A razão pela qual eu
não estou fazendo 02 novamente, porque lembre-se
que você não pode pintar em cima de suas camadas assim. Então, voltar para
0101 estava aqui. Então agora podemos pintar aqui
sem afetar nada. Então, algo assim. Acho que isso funciona,
isso, parece bom. Então, vamos voltar aqui. Estou apenas selecionando
a borracha para não ter que assistir tudo isso. Mas você pode ver aqui agora, se o personagem
está andando por aí, isso está parecendo bom, nosso
fundo está cheio. Você pode, claro,
eu não tenho nuvens, mas você poderia, claro, se houver para torná-lo mais
interessante nas nuvens aqui em cima. Mas acho que está tudo bem. É como quando
andamos por aqui, não
parece ruim
e parece interessante. Você pode até ajustar
seus adereços aqui, o plano de fundo solicita
que você coloca antes. Você pode ajustá-los
se quiser. E isso foi na verdade para
projetar o ambiente. Então, a razão pela qual eu
não adicionei nada aqui, ou talvez aqui ou aqui. Poderíamos usar alguns
desses pontos vazios para
adicionar portais mais tarde que possamos teletransportar para diferentes áreas e eu possa mostrar como fazer
um sistema de portal. E com isso dito, vamos
passar para a próxima lição.
10. Como remover o cintilação: Agora vamos voltar
ao nosso mapa de mosaico. Quero mostrar algo que você pode ver aqui quando eu me movo,
quando eu clicar com o botão direito do mouse
e deslocar-se, você pode ver que o céu está piscando e meus azulejos também estão. É muito sutil. Mas, por exemplo, você pode
ver aqui a linha aqui, ela está cortando minhas telhas. Então, às vezes,
os azulejos também estão cintilando. E queremos remover
essa cintilação porque isso também
acontecerá para você no jogo. Então, vamos fechar
este mapa de mosaico aqui. E o que você quer fazer é esses conjuntos de ladrilhos simplesmente clique com o
botão direito do mouse no conjunto de toalhas e clique na condição Textura do
Título XI. Agora ele vai criar
algo novo para você. Basta pressionar Enter e ele
criará isso para você. Então, estes são acolchoados, então ele automaticamente
absorve as toalhas para você. Então você pode ver aqui não parece
muito diferente
de antes. Mas as diferenças são se
eu voltar ao meu conjunto de azulejos, agora se eu clicar no meu bloco antes de selecionar o
bloco aqui nas laterais, mas você pode ver o motor automaticamente acolchoado
seus azulejos para que eles nunca cintilará
porque temos esses pares em
cada peça. A mesma coisa que fez para todos os outros
azulejos que você tem. Vamos fazer a mesma coisa
para o plano de fundo. Vamos clicar com o botão direito do mouse no
conjunto de toalhas e clicar na
condição toalhas, textura de
lençóis e
vamos clicar em Enter. Ok, então agora eu terminei de
pintar minha segunda textura. Demorou algum tempo porque era uma textura
tão leve e
quase parece que seu motor caiu, mas não caiu. Então, voltando ao ambiente e clicando no meu mapa de mosaico agora, você pode ver quando eu
amplio e me movo, você pode ver que a
cintilação desapareceu. E isso também
se aplica ao jogo. Então, removemos
essa cintilação. Portanto, sempre que você importar algumas
toalhas para adicionar para seus mapas, lembre-se de clicar com o botão direito do mouse
no conjunto de azulejos e clicar na textura da
toalha condição. E será automaticamente um
bloco dessa textura para você. E você removerá todos
esses problemas de cintilação.
11. Como colocar o mapa de azulejos em nível: Vamos agora colocar
nosso nível que
criamos aqui dentro do nosso mapa. Então, fechando isso, lembre-se de que fizemos um mapa aqui, um nível chamado principal. Então, clique duas vezes sobre isso para ter
certeza de que você está dentro daqui. Você também pode vê-lo. Aqui à direita, você está
dentro do mapa principal. Dentro daqui, basta ir ao ambiente e clicar
e arrastar seu mapa de mosaico. Portanto, não os conjuntos de toalhas
, mas o mapa de azulejos. Então clique e arraste e você pode soltá-lo aqui
no ambiente. Lembre-se de nossa navegação de antes que você possa clicar com o botão direito do mouse e segure WD é um a para se mover. E você pode ver que este é o mapa de
mosaico que adicionamos. Agora eu gosto de remover essa grade porque não
consigo ver o que está acontecendo. Então, clicando neste
mapa de mosaico no painel Detalhes, você pode descer e encontrar
aqui em renderização, mostrar por grade filho
quando selecionada, vou desmarcar
isso para que eu possa ver meu mapa. E este é o mapa
que criamos. O que eu gosto de fazer é
colocá-lo no local de
zeros, zeros 0. Então este é o meu mapa inicial. Gosto de começar em 000. É simplesmente isso. Criamos o mapa. E como este é um mecanismo 3D, lembre-se de que este
não é um mecanismo 2D. Você pode ver aqui se
você olhar para o lado do seu mapa
de mosaico,
estes são, na verdade, mosaico de camada. Então lembre-se dentro
do mapa de mosaico, criamos nossas camadas aqui. E assim você pode ver todas essas camadas se empilhando
aqui em um ambiente 3D. O que eu quero fazer,
quero separar essas camadas porque mais tarde, queremos ter
certeza de que não temos um problema quando o
jogador está se movendo. E eu vou
descer aqui e aqui, e essa separação por camada, vou aumentá-la para
algo extremo para que você
possa ver o que está acontecendo. Então, algo como 50
e eu vou economizar. Você pode realmente ver
essas camadas agora, elas estão separadas
umas das outras. Agora, o que eu gosto de fazer
aqui na separação, gosto de escrever dez e
quero mostrar a vocês
por que escrevo dez, ou você também pode escrever 15. Tudo bem. Isso realmente não importa. Mas eu quero mostrar a vocês por que
eu não vou,
por que vou com dez
em vez disso, por exemplo. Então, clicando aqui, você pode ver agora que
separamos a camada. Então você pode imaginar
como o personagem está parado aqui no
chão, nesses azulejos. Você está tecnicamente em
pé sobre isso, essa camada base que criamos. Há dez pixels
dessa camada aqui para
a camada frontal aqui. Então agora a separação, desde que escrevemos dez, a separação é de dez
pixels para cada camada. Então você tem a liberdade adicionar coisas entre
essas camadas. Então, por exemplo, se
você quiser adicionar um item na frente desses planos de
fundo, talvez, mas você quer editar atrás
do jogador andando por aí. Obviamente, você precisa selecionar o número que está
entre essas duas camadas. Então, quanto maior você
fizer essas camadas, mais liberdade
você terá em colocar itens ao lado ou
entre essas camadas. Então, acho que não
precisamos de mais de dez. Nunca precisei de mais de dez, então vou escrever dez
em vez disso para ter certeza de que meus blocos de chão estão em 0 porque isso facilitará para nós tarde, quando estivermos programando. Eu simplesmente quero empurrar
essa camada aqui. Estes são meus azulejos, dois na frente daqui,
então está no meio. Assim, você pode ver aqui
no ponto de pivô, quando você tiver a Ferramenta
Mover selecionada, quando você clica nela, você
tem a Ferramenta Mover selecionada. Você pode ver se você quer se
mover nessa direção, você tem que movê-lo por dez. E agora está realmente correto. Lembre-se, nossa ferramenta de encaixe está se encaixando a
cada dez graus, dez pixels, em vez de não graus. Então agora, na verdade, não está correto porque com o encaixe
chegamos a dez. Então você pode ver agora, agora o plano de fundo está em 000. Quando você escreve dez
aqui no y, você tem a dose,
dose novas telhas como 000. E isso
tornará muito mais fácil para nós tarde, quando estivermos
programando.
12. Volume do pós-processo: Tudo bem, então o problema
que temos agora em nosso nível é que a iluminação e as cores não
estão corretas. Então, como você pode ver
aqui, se eu abrir meu mapa de mosaico e se
eu ampliar aqui, você poderá ver a diferença
entre este mapa de mosaico, as cores corretas e
o que ele parece. E este é o nosso nível, então definitivamente parece errado e a iluminação
é muito forte. E é aí que entra o volume
pós-processo. Então, aqui em cima e adicione
rapidamente o botão. Vamos clicar aqui e
depois ir para efeitos visuais. E vamos adicionar esse
chamado volume pós-processo. Então, o volume pós-processo, o que é, é exatamente
como no Photoshop. Quando você coloca uma imagem
dentro do Photoshop, você pode editar os estudiosos da imagem, você pode editar a saturação, o brilho da
imagem lá. A mesma coisa acontece aqui
no Unreal Engine, usamos um volume pós-processo para alterar a iluminação e
as cores e assim por diante. Então, quase como a gradação de
cores. Portanto, temos o volume
pós-processo e o que queremos fazer
é rolar aqui para baixo. E queremos tomar essa
chamada extensão infinita. O que isso faz é que
afeta o mundo inteiro. Se você não pressionar isso, isso só funcionará sempre que
você estiver dentro dessa caixa. Então, por exemplo, só para
demonstrar isso para você, vou
aumentar essa floração. Então, indo para a intensidade
de dez, muito extremo. E se eu for aqui
dentro da minha caixa, você pode ver que a flor está entrando em vigor,
que os efeitos sonhadores. E se eu sair dessa caixa de volume
pós-processo, ela voltará ao normal para que
você possa ver a diferença. Ok, então em vez de
entrar nisso, não esta caixa aqui e talvez como tentar fazer essa
caixa se encaixar no nível. Nós realmente não precisamos fazer isso. Nós só queremos clicar neste
chamado extensão infinita. E isso afetará
o mundo inteiro. Portanto, não precisamos estar dentro
desta caixa para que ela entre em vigor. Ok, então o que queremos fazer, vou colocar esse volume
pós-processo em 000. Na verdade, não
importa, mas eu só gosto de fazer isso. E então vamos começar a
passar por todas essas configurações. E levei cerca de
seis a sete horas para realmente pregar isso com
todas as configurações corretas. Então aqui na floração,
vamos defini-lo para 0. Nós realmente não queremos
florescer dentro do nosso nível. Em seguida, vamos
até a exposição. E dentro da exposição, vamos tomar o brilho mínimo
e o brilho máximo. E vamos definir ambos
para dois. Então 22. E então
vamos até o Lens Flare. Vamos clicar na intensidade
e defini-la para 0. E nós realmente não
precisamos de um flares de lente. Em seguida, vamos clicar em efeitos de
imagem e
outros efeitos de dano. Podemos definir a vinheta para 0 antes de fazer qualquer classificação de cores. Vamos pular isso um
pouco por enquanto. Eles vão cair
e eu vou
encontrar a oclusão do ambiente. Mas a
oclusão ambiente que queremos
definir para 0, não precisamos disso. E o desfoque de movimento também, vou definir para 0. Ok, então não temos
mais configurações para
brincar aqui embaixo. Então, vamos voltar para
a gradação de cores. E novamente, passei
sete horas fazendo isso. Então justifique vir com números
aleatórios. Não é porque estou
supondo corretamente, é porque
tenho tentado encontrar os números
corretos aqui. Então aqui primeiro no
global, podemos clicar nisso. E vamos pegar
esse chamado saturação. Assim, você pode aumentar, você pode ver que pode aumentar e diminuir a saturação
da imagem. E para isso, 1.980 foi
o número perfeito. E vamos rolar um pouco
aqui nas sombras. Então, clicando nas
sombras
e tomando a saturação e o
contraste e a gama. Então, o que é saturação? Queremos ir com 0,9. E com o contraste, vamos com 0,9 para o Gamma, vamos com 1,01. E vamos descer agora. E nos tons médios, realmente não
temos nada além dos destaques, se clicarmos naquele, só queríamos levar este
chamado mínimo de destaques. Então, vou defini-lo para um. E então vamos
para diversos. Vou pegar esse
valor chamado Tone Curve e vamos
colocar isso para 0. Você pode ver que isso muda
muito em nossas cores. Então, descendo para
0, e isso deve corrigir todos os nossos problemas. Agora vamos clicar
no mapa de mosaico e você pode
ampliar e dar uma olhada. E você pode dar uma
olhada no nosso nível aqui, e você pode ver que eles parecem
perfeitamente iguais Agora. Eles são pequenos problemas agora, e nós resolveremos isso
na próxima lição. Como você pode ver,
eles são pixelados, mas você pode ver que
há algum tipo
de suavidade dentro do nosso nível, não muito pixelado. E isso é por causa da suavização que
temos que remover. Mas você pode ver
aqui, se você for para o modo ao vivo e for
para o modo desvinculado, é
assim que a
textura correta se parece. Então, isso é o que
parece sem iluminação. Então, se você voltar
ao modo lead, você pode tentar comparar os dois. Então é isso que estamos
tentando alcançar. Estamos tentando alcançar o modo elite da mesma
cor do modo sem iluminação. Muito perto um do outro. A única coisa é que
o modo ao vivo é mais suave por causa
da suavização de suavização. E vamos consertar isso
na próxima lição.
13. Como remover a Anti: Tudo bem, vamos mover
o anti-aliasing, que está causando
esse efeito suave dentro de todo o nosso nível. E não
precisamos de suavização quando estamos trabalhando
com pixel lot, queremos assistir
aos verdadeiros pixels. Então, vamos editar e vamos entrar em
nossas configurações de projetos. Dentro daqui, podemos rolar para baixo e vamos encontrar
essa chamada renderização dentro
da renderização do motor e dentro daqui. Agora, isso é anti-aliasing, mas isso é para dispositivos móveis e
não estamos fazendo um
jogo para celular agora, então isso não importa. Mas vou descer aqui. E queremos encontrar essas
configurações padrão enquanto estamos nela. Vamos realmente remover
algumas coisas que florescem. Já o definimos para 0, mas sempre podemos
desabilitar aqui também, a oclusão do ambiente também. Este, a exposição automática e também podemos remover
o desfoque de movimento. Então, todos eles foram removidos. E este é o importante,
o método anti-aliasing. Eu não sei se você pode
ver uma diferença se
eu colocá-lo aqui
ao lado e você pode ver se algo
acontece quando eu a desabilito. Então, essa
super-resolução temporal, se eu clicar em Nenhum, você
pode ver a diferença. Claro, você pode
mantê-lo ligado se quiser que seu jogo seja
suavizado assim. Mas para a verdadeira pixel art, você realmente não tem isso. Então, clicar em nenhum
verá os blocos verdadeiros, como eles são criados
no software pixel art. Então agora, se entrarmos no modo
sem iluminação e no modo, agora lembre-se
disso é o que estamos tentando alcançar,
as mesmas cores. Você pode ver que
não há diferença agora, e isso é o que queremos. Queremos que o modo Lit
seja o mesmo que o sem iluminação. E se você quiser ver a
diferença clicando
neste volume pós-processo
com o qual trabalhamos na lição anterior. Podemos clicar sobre isso
ativado para removê-lo, e você pode ver a diferença. Agora este é o modo OnLoad. Estas são cores verdadeiras. Esse é o modo ao vivo. E quando o
habilitamos, fazemos exatamente
como queremos.
14. Como adicionar colisão: Agora vamos habilitar a
colisão para nossos blocos. Então, quais são as colisões, são a coisa que realmente
torna esses azulejos caminháveis. Então você pode imaginar se adicionarmos
um personagem no futuro, o personagem
agora não pode andar sobre essas peças porque
eles não têm colisão. Então, o personagem realmente
seguirá os azulejos e
cairá pelo chão. Então, precisamos adicionar uma colisão que o personagem possa
andar sobre esses azulejos, e isso é muito simples de fazer. Então, vamos
até o conjunto de azulejos. Então, vamos para a estrada do dragão de
Tulsa. E dentro deste azulejo disse
lembrar que a única coisa que fizemos última vez foi apenas
definir o tamanho do ladrilho para 30. As bactérias
também podem adicionar colisão. Então, clicando neste botão
chamado blocos de colisão. Agora você pode ver
a colisão. Agora. Agora você não pode ver
nada porque
não temos nenhuma colisão. Então, clicando no primeiro
bloco aqui, e este, por exemplo, você pode
clicar nesta chamada caixa Adicionar. E agora você realmente
adicionou uma colisão. Então, se eu clicar em Salvar agora, e eu só queria mostrar
que isso realmente
adicionou colisão. Então, se eu clicar em, aparecer aqui e
clicar em colisão, agora você não pode ver
nada e isso ocorre porque dentro
do conjunto de blocos, você precisa se lembrar de
clicar em Atualizar mapas. Isso atualizará todos os mapas
de mosaico. E agora você pode ver isso
realmente adicionar colisão. Agora pode ver essas caixas aqui em cima. E esta é a colisão, nós apenas adicionamos e
temos que fazer isso para que o personagem possa realmente
andar sobre esses azulejos. Tecnicamente na programação,
esse personagem está andando nessas pequenas caixas, mas parece que o personagem
está andando sobre os azulejos. Então, voltando aqui e temos, infelizmente
não
há um método em que possamos selecionar tudo
e clicar aqui. Temos que fazer isso manualmente, mas queremos levar muito tempo. Então clique aqui, olhando para a caixa, muito simples. Estamos apenas adicionando
colisões a essas peças. E você tem que fazer
isso para todas
as peças que você usou. Assim mesmo. Por exemplo, não
precisamos adicionar colisão para esses blocos porque não os
usamos. Mas se você
os usou em seu mapa, você também tem que adicionar colisões
para eles. Portanto, não adicionamos colisões
para essas porque obviamente, o jogador não
vai andar sobre essas peças. Então, se eu salvar aqui
e atualizar mapas, você verá aqui que as
peças são aditivas, as colisões são adicionadas, e nós realmente não precisamos adicionar colisão aqui embaixo
, porque então o jogador
nunca vai vá para baixo aqui. Então, nós realmente não precisamos. Agora, eu quero fazer minha caixa de
colisão ser maior porque você pode imaginar quando o jogador
está andando aqui nessas caixas, há uma chance de que, lembre-se que este é um motor 3D. Há uma chance de o
jogador ser empurrado de uma forma em
que o jogador caia aqui para
o lado e
cairá do
chão, caindo das caixas de colisão. Então, apenas para eliminar esse risco, quero aumentar a caixa de
colisão é o comprimento. Podemos fazer isso dentro do mapa
de mosaico. Dentro do
mapa de azulejos aqui podemos ir para aqui na parte inferior, espessura de
colisão. Vamos definir que é 254. Agora, vamos clicar em Salvar. E quando minimizamos, você pode ver que as caixas de
colisão são muito mais longas e não temos a
chance de o
jogador cair do chão porque
isso está coberto agora. Ok, vamos adicionar colisão
ao resto. Acho que acreditamos, acredito que estamos perdendo essa parte aqui. Então, indo para o
conjunto de ferramentas e dentro daqui, vamos também adicionar colisão dois. Este é, na verdade,
estamos perdendo esses,
então, adicionando uma
caixa de colisão aqui, faça a mesma coisa com esta. Também precisamos adicionar
uma colisão aqui,
então, ao lado, então
clicando em Adicionar caixa, você pode ver aqui para o lado, nós realmente não precisamos de colisão todo o caminho se eu atualizar
o mapa para que possamos vê-lo. Agora ele adicionou colisão por
todo o caminho aqui. Nós realmente não precisamos disso. Só precisamos cobrir o ladrilho. Então, o que podemos fazer é
clicar neste e depois lamber, aspirar e selecionar
esses dois vértices. E podemos clicar e arrastar. Então, assim como nossa janela de exibição, talvez
eu
desabilite o encaixe. Vamos ver. Ou, na verdade, está tudo bem. Assim, isso é perfeito. Fazendo a mesma coisa aqui. Vou adicionar caixa de
colisão e pegar esses dois vértices e
reduzi-los assim. Então, agora você pode atualizar o mapa e ver como ele
se parece. Isso, o que parece. Então a colisão é duas aqui. E se acharmos que
isso é demais, sempre
podemos voltar
e torná-lo menor. Então, agora estamos perdendo este. Vamos adicionar uma caixa de colisão. E vamos
selecioná-los para movê-los para
mais perto da mesma
coisa aqui. Mova-os para mais perto assim. E, novamente, lembre-se de
clicar em Atualizar mapas. A última coisa é que estamos perdendo essa inclinação aqui porque
este também usamos. Então, vou clicar neste primeiro e vamos adicionar uma caixa. Agora este é um
pouco mais complicado, então vamos selecionar esses vértices. Este vértice aqui, clicando em Excluir no
teclado, o excluirá. E agora só temos
três vértices. Agora este, você pode
se mover para baixo assim. E vamos passar
para o próximo. Então este aqui,
clique na caixa Adicionar. Queremos mover este para baixo, talvez assim, e também mover este
para o lado. Nós realmente não precisamos de
colisão até aqui. E vou reduzir meu estalo porque não me
deixa movê-lo para cá
no meio. Então, vou reduzi-lo
para cinco em vez de dez. E acho que algo
assim funciona para mim. Agora vamos
clicar neste. Você pode ver que as inclinações são um pouco
mais complicadas de se trabalhar. Então, clicando neste
, queremos adicionar uma pequena colisão aqui para que
o jogador não caia. Então, clicando na caixa
Adicionar novamente, podemos selecionar este vértice, clicar em Excluir no teclado. Podemos pegar este
e movê-lo para mais perto. Então, se eu puder acertá-lo aqui, aproximando e depois
pegando este vértice e movendo-o para baixo
assim. E então podemos pegar o
próximo aqui e adicionar uma caixa. Podemos pegar esse vértice
e movê-lo para baixo. E este só podemos deixar ser. Acho que esta é uma boa curva. E o último,
há um pequeno inseto. Eu testei isso mais cedo. Também temos que adicionar uma colisão muito pequena aqui, caso contrário, o jogador realmente
vai, se eu atualizar o mapa
e eu puder mostrar, o jogador
ficará preso aqui. No topo. Há uma
lacuna muito, muito pequena que não podemos ver. E temos que adicionar
uma colisão aqui. E, obviamente, isso é porque
eu já testei isso antes. O que só queremos
fazer aqui é que queremos
excluir o vértice
aqui, como antes. Podemos movê-los muito de perto. Agora, para ver o
número específico para isso, você pode ir aqui. E os dados de colisão e
índice, descendo duas formas. Clicando neste índice e
assistindo a esses vértices. Você pode ver quando eu movo
esse vértice para cá, esse número de alterações. Então eu só quero que esse
número seja 14,9. Então você pode ver que, se
eu remover o encaixe, mais perto eu
o movo para baixo. O último número é
15, obviamente aqui. Então eu quero
movê-lo para um 5.9º, 14. E este também. Então, muito, muito perto. Este, se eu apenas movê-lo para ver qual
é, está aqui embaixo. 14.9. E não sei por que disse
15.914, assim. Então, ambos são 14,9. Então, há uma pequena
faculdade aqui que faz com que o jogador não
passe pelo chão. E isso porque
eu testei antes no meu projeto de preparação. Então agora temos todo
o conjunto de colisão. Só me lembro, lembre-se
sempre de clicar
no mapa de atualização e
clicar em Salvar, salvar tudo. E agora você está pronto para ir. Então você pode dar uma
olhada no seu mapa. Você pode ver que há
colisão aqui em cima. Talvez precisemos
reduzir este. Talvez esteja muito longe. E você também pode assisti-lo aqui. Mas geralmente temos que ter um personagem
para
correr ao redor do mundo e testar isso antes que possamos dizer com certeza. Mas agora temos a colisão
inicial feita e podemos seguir em frente para
criar nosso personagem.
15. Como criar sprites: Agora é hora de importar
os ativos do personagem. Então eu forneci
para você aqui novamente, dentro dos materiais do curso, há uma pasta
chamada caracteres. Então, clicando nessa pasta. E vamos começar com Serena. O que eu quero que você faça por
enquanto é apenas importar as animações ociosas, o salto e a
corrida. Então, primeiro, antes de fazermos isso, vamos para
a pasta de ativos. Vamos criar uma nova pasta
chamada caracteres. E então dentro daqui, vamos fazer um novo
novamente chamado Serena. E então aqui
podemos importar nossos ativos. Então eu quero arrastar o salto
ocioso e correr, arrastá-los para o seu projeto. E quando você solta, você
importa essas texturas. Então, na verdade,
vamos criar algo chamado
sprites e flip books. Então, vamos criar uma nova pasta e eu vou
chamá-la de texturas. E vou tê-los
dentro desta pasta. E todos os, todos
os flip books que
fizermos estarão aqui. Então, em vez de texturas, lembre-se de quando você importa
texturas e, novamente, se você
clicar duas vezes nelas e aumentar o zoom, verá
que o Unreal Engine está
suavizando esses pixels. E como eu te disse antes, você tem que selecionar todos eles. E se você quiser
selecioná-los assim, você pode clicar em
um turno de espera e
clicar no último. Ele selecionará todos os. E você pode clicar com o botão direito do mouse em ações
sprite e aplicar papel às configurações. Como antes, você pode
ver que ele remove a suavidade e você pode
ver os pixels com mais clareza. Agora você pode ver que a textura
vem com essa animação. Então você tem a animação, você tem a animação em execução, e elas são colocadas
juntas em uma textura. E agora você tem que criar
sprites a partir desses. Então, vamos começar com o ocioso. Você pode clicar com o botão direito
e inspirar ações. Você pode dizer extrair sprites. E aqui, você
tem que ir aqui para o canto superior direito e clicar
na grade em vez de auto. E então você precisa especificar
o tamanho da grade. Agora, eu fiz isso
no Photoshop, então eu sei que a grade é um
oitenta, um oitenta. E se você baixar
algo da Internet, eles lhe dirão o quão
grande é essa grade, um oitenta, um oitenta. E ele extrairá essas
animações como quadros únicos. Então, clicando em
Extrair aqui, você pode ver que ele os extrai para quadros
únicos e esses
são chamados de sprites. Sprites são imagens estáticas. Então, aqui em nosso nível, você não poderia arrastar uma
textura e soltá-la em cima
daqui porque você pode vê-la substitui o que
você está arrastando, arrastando-a por cima. Então, vou
clicar no Control Z. Mas os sprites são imagens
estáticas e
podem realmente arrastá-los
para dentro do nível. Então, se você tem algo
estático, por exemplo, um barril que nunca se move, você pode realmente adicionar isso
aqui dentro do seu nível. Mas nosso personagem
tem animações, por isso não queremos arrastar imagens
estáticas porque, na verdade,
são animações, mas trabalharemos com as animações mais tarde
no próximo vídeo. Então, vamos excluir.
Vou excluir esse material que ele criou sempre que arrastar essa textura sobre ela, assim mesmo. Agora, vou
renomear os sprites. Normalmente, eu excluo
isso na frente. Basta lembrar que você tem que prestar
atenção aos números. Então este é o número 0123. Então você tem que fazer isso em ordem. E aqui, o primeiro, vou
chamá-lo de S para Sprite está ocioso e 01 assim. Então, estamos um pouco mais organizados. Este é 02 agora e
0304. Assim mesmo. Então agora temos o ídolo. E vamos fazer a mesma
coisa com o salto. Você pode fazer isso sozinho apenas
para praticar, se quiser. Você pode clicar com o botão direito do mouse
aqui e ir para detectar ações e
extrair sprites. Selecione a grade aqui e, novamente, 180, extraia os sprites. E, novamente, preste atenção
aos números. Diz 0123. Então não pense que você pode
entrar aqui e ligar para isso 10, porque este
é o número três. Às vezes, o que eu faço é apenas
clicar longe da pasta. Então clique em outro lugar
e volte para a pasta. E você pode ver que ele
os classifica como você quer. Então este é o
primeiro, é r1, 01. E fazer a mesma coisa
com os outros. Portanto, leva um pouco de tempo para organizar suas pastas. Mas no final, quando
eles estiverem organizados, você terá um
tempo fácil trabalhando com ele. Agora o último é o salto. E este você pode ver que o
salto só tem uma animação. Portanto, não faz sentido clicar com
o botão direito do mouse e dizer extrair sprites porque você
realmente só tem um sprite. Então, o que você quer fazer é clicar com o botão direito do mouse e clicar em Criar Sprite em vez de extrair porque você
só tem um sprite. E vamos chamar isso de salto. Tudo bem, então agora
criamos nossos sprites. Vamos salvar tudo e vamos passar
para a próxima lição.
16. Como criar flipbooks: Então, agora que criamos
sprites para o nosso personagem, agora é hora de
animar esses sprites. Então, o que você quer fazer é, por exemplo, vamos
começar com o ocioso. Você pode selecionar todos eles. Então, qualquer um, você
pode segurar o Controle. Eu iria para três ou quatro. Ou uma maneira mais rápida de fazer isso
é clicar no primeiro, segurar Shift e clicar nos últimos
no número quatro. E selecionaremos a
coisa toda aqui na linha. Agora você pode clicar com o botão direito. E aqui em cima diz
criar flip book. Então, clicando em Criar flip book, ele criará um. E eu geralmente, em vez
de S e da frente, costumo escrever FB
para um flip book. Este é o flip book ocioso. Agora você pode clicar duas vezes
no flip book. E você pode ver agora
isso é animado, mas agora está
animado muito rápido. Então eu quero que você
altere os quadros por segundo aqui
para o canto superior direito. Então joguei Maple Story ontem e vi como a animação era
rápida, e eram cerca de dois
quadros por segundo. Então escrevendo para, e você pode
ver agora que está animado. Esta é a animação ociosa. Agora, vamos fazer a mesma
coisa para a corrida. Para executar o número um a quatro, ele pode clicar com o botão direito do mouse,
criar um flip book, chamá-lo de FP run. E você pode clicar duas vezes
nele novamente. E para a animação de execução, são seis quadros por segundo. Claro, você pode
torná-lo mais rápido. Por exemplo, se
você estiver, se quiser que seu personagem seja executado tão rápido, ou apenas que a animação seja
tão rápida, você pode fazer isso. Mas para mim, estou tentando imitar Maple Story
o máximo que puder. E parece que eles são
animações são cerca seis quadros por segundo,
assim. Certo, vamos fechá-lo. E o último
que temos o salto. Agora podemos criar um flip book
com isso e precisamos,
porque mais tarde, quando estamos
criando nossos personagens, o personagem quer e a
entrada de um flip book. Então, não podemos realmente
usar esse sprite de salto. Lembre-se, este é um sprite, este é um flip book. Temos que
transformar isso em um flip book porque o personagem mais tarde
precisa de um flip book. Então, mesmo sendo um quadro, temos que criar um flip book. Então, vamos clicar com o botão direito do mouse e criar um flip book
fora do salto. E vamos chamá-lo de
FB, pular, assim. E, obviamente, este
é apenas um quadro, então vou mudar
esse quadro por segundo para um e podemos fechá-lo e podemos ir em frente
e salvar tudo. Então, agora criamos
nossos flip books. Vou mover
esses flip books para fora
da pasta de textura. Então, vou movê-los para a Csarina aqui e
clicar em Mover aqui. Então agora temos esses flip
books e esses setores, nós realmente não
precisamos vê-los novamente. É por isso que criei uma
pasta Textures apenas para que seja mais fácil de olhar porque só
precisamos desses flip books.
17. Introdução ao Blueprint: Blueprint é a linguagem de
script visual no Unreal Engine. E quando você está escrevendo
plantas, acredite ou não, você é um programador.
Você está programando. Em vez de escrever linhas
tradicionais de código, você pode codificar todo o jogo simplesmente adicionando notas e
conectando-as juntas. Portanto, é uma linguagem de
script visual. Blueprint é tão poderoso quanto qualquer outra
linguagem de programação por aí, seja C
plus, mais C-Sharp ou qualquer
outra linguagem, você pode criar o que
quiser usando o blueprint. Neste momento, estamos criando uma
mini versão do Maple Story. Mas você também pode criar um anel
Fortnite, Metal Gear, Solid, ferrugem ou mesmo Aldon. Você pode programar qualquer
ideia com blueprints. Então, a única coisa
que está limitando você é a sua imaginação. Tudo o que você quiser programar, você pode fazer isso com o blueprint. E também é otimizado e
funciona bem com isso dito, vamos direto para aprender
os conceitos básicos dos projetos.
18. Cursos de Blueprint: Vamos agora falar sobre aulas de
blueprint. Então, aqui em qualquer pasta aleatória,
vou clicar com o botão direito do mouse. Eu só queria mostrar as aulas de
blueprint por enquanto. Você pode clicar com o botão direito do mouse e aqui, você pode clicar na classe
Blueprint. Você também pode encontrar isso
em Blueprints, este chamado classe Blueprint. Então, a mesma coisa, mas é
mais rápido apenas clicar aqui. Portanto, essas são as
diferentes classes que você pode criar
no Blueprint. E eu quero começar
com o primeiro. O primeiro que temos é um ator e você pode ver a descrição
aqui à direita. Diz que um ator é um objeto que pode ser colocado
ou gerado no mundo. Então, um
ator muito simples, por exemplo, pode ser uma mesa, pode
ser uma cadeira, pode
ser um martelo. Então, qualquer coisa que possa ser gerada no
mundo, apenas um objeto. O próximo é um peão. E sobre está um ator que pode ser possuído e receber a
entrada de um controlador. E o que isso significa está acontecendo, é algo que o
jogador pode controlar. Então, em outro curso que
fiz que você possa ver
aqui no site é que estou criando uma bola
ou uma esfera. Movendo-se. Essa esfera que está se
movendo está acontecendo porque eu queria que o jogador controlasse esse medo de se movimentar
com o teclado. Então n upon é um
ator que pode ser possuído e receber a
entrada de um controlador. Então você tem que fazer o que
quiser em uma lagoa. Se você quiser que o jogador
controle esse objeto, você não pode fazer um ator e quer que o jogador
controle esse objeto, que você precisa
transformá-lo em um ponto. Em seguida, temos um personagem. E um caractere é
um tipo de ****. Então você pode ver que
há um relacionamento. Então, um personagem está na verdade. Um personagem é um
tipo de **** que inclui
a capacidade de andar por aí. Então, sempre que você quiser
fazer um personagem, é só você pode
imaginar um humano com dois braços e duas
pernas andando por aí. Você tem que fazer um personagem. Mas se você quiser fazer seu personagem algo
como uma bola ou uma esfera rolando no
mundo sem que ele não tenha
dois braços, duas pernas. Você pode ir em frente
e criar um ponto. Portanto, essa é a
diferenciação mais fácil. Então, quando você tem um
personagem, dois braços, duas pernas andando, você pode ir em frente e criar
um personagem em vez disso. Então você tem algo
chamado controlador de jogador. E aplicar controlador
é um ator que é responsável por controlar
o usado pelo jogador. Então você tem que pensar nisso. Este não é realmente o controle
que você tem em casa, nem o controle
Xbox ou o controle PlayStation. Isto é, você pode imaginar isso como o cérebro do personagem. Então este é o cérebro
do personagem. Todos os personagens
que você gerar
no mundo terão
um controlador de jogador. E dentro daqui
você pode adicionar códigos como interfaces de usuário. Ou se você quiser fazer
um jogo para um jogador, você está criando movimentos
incríveis. Você pode fazer isso dentro daqui, mas estaremos trabalhando
com todas essas letras. Portanto, não se preocupe com isso. Esta é apenas a
explicação básica por enquanto. Então o último sobre o qual eu quero
falar é chamado de Modo de Jogo, e isso é quase
autoexplicativo. A base do modo de jogo define
o jogo que está sendo jogado, suas regras, a pontuação e outras facetas
do tipo de jogo. Então, por exemplo, se
tivermos um jogo de tiro, você capturará a bandeira. Você tem quanto tempo
você tem por rodada. E, por exemplo, em Maple Story, se quisermos fazer um evento, por exemplo, podemos definir quanto tempo esse evento
levará e assim por diante. Então, apenas as regras do jogo. Por exemplo, em
Capture the Flag, quando você captura o
sinalizador de uma equipe, ele lhe dará alguns pontos. E esses pontos também podem
ser anotados dentro
do modo de jogo porque são
as regras do jogo. Agora, já que estamos trabalhando
com 2D agora. Então, todos eles são 3D. Como estamos trabalhando com 2D, você precisa clicar nisso, este chamado todas as classes. E aqui você pode
procurar papel. Você pode ver que temos
muitas aulas e essas são apenas as básicas que
usamos o tempo todo. E você quase nunca entra aqui a menos que esteja trabalhando
com coisas avançadas. Por exemplo, um sistema de salvamento
e carregamento, que faremos
mais tarde, espero. Em todas as aulas aqui, você pode procurar papel. E o papel é apenas o pixel
lot 2D aqui no Unreal Engine. Então, por exemplo, em vez
desse ator aqui em cima, que é 3D, podemos criar este chamado ator sprite
Paper. Ou podemos criar
um ator de flip book se tivermos um flip book, lembre-se, flip books foram os sprites animados
juntos. Então, se você tiver uma animação, você quer usar um flip book. Se você tiver um item estático, você deseja usar um
sprite e, em seguida, você também tem um personagem. Então, em vez de usar
esse personagem aqui, porque este é um personagem 3D, temos que usar este
chamado personagem de papel. E este inclui
um flip book. Fizemos flip books para o
nosso personagem que
podemos colocar aqui dentro do
nosso personagem de papel. Então, essas são as
classes básicas que queremos usar, e principalmente não vamos
usá-las aqui em cima. Vamos adicionar
um controlador de jogador e o Modo de Jogo porque
eles não são necessários. Mas, para tudo isso
, principalmente funcionaria aqui em
nosso personagem de papel, sprite
de papel e nosso flip book
de papel.
19. Modo de jogo e controlador de jogadores: Vamos agora começar criando
nossos primeiros planos. Então, para fazer isso, vamos
na pasta de conteúdo. Você pode clicar com o botão direito do mouse
aqui e vamos criar uma nova pasta chamada blueprints. E dentro desta
pasta, e a propósito, você pode dar uma dose completa de cores. Portanto, se você puder
clicar com o botão direito do mouse aqui na pasta
Blueprints e clicar em Definir cor. Às vezes eu faço isso só
para me organizar, basta selecionar uma cor azul. Então eu sei que são plantas
assim, por exemplo. E você pode vê-lo
claramente dentro daqui. Você pode clicar novamente com o botão direito do mouse
e selecionar Classe Blueprint E vamos criar um modo de jogo. Cada jogo que você cria tem um modo de jogo e
um controlador de jogador. Essas são as coisas básicas com as quais
você começa em um jogo. Então, vamos criar um modo de jogo. E vamos chamá-lo de g, m como
um prefixo para o Modo de Jogo. E eu costumo chamá-lo
de nome do jogo. Então, a história de Maple para este. O próximo, novamente, mouse em Loop e classe. Clique no controlador do jogador e chame-o de PC para controlador de
jogador, novamente, chame o
nome do jogo. Então Maple Story. Agora, obviamente,
você tem que criar vários modos de jogo se você
tiver vários modos de jogo. Então, por exemplo, em
Counter-Strike, você tem algo
chamado match de morte. Você capturou a bandeira, você tem cinco contra
cinco jogadores. Então você tem modos de
jogo diferentes. E você pode criar
vários modos de jogo. Você pode, é claro, em vez de chamá-los de nome do jogo, você pode chamá-los para algum
dn, Capture the Flag. Então chamá-lo de nome
do modo de jogo. Mas para este só
temos um modo de jogo. Então, vou
chamá-lo de Maple Story. Agora, para que este
modo de jogo funcione em nosso nível, você precisa, vamos
primeiro salvar tudo. Então, o arquivo Salve tudo. E vamos para Editar. E dentro das configurações do
projeto. E nas
configurações do projeto, você pode clicar em mapas e modos aqui. Portanto, lembre-se, em mapas e
modos anteriormente,
editamos o
mapa de inicialização para nossa média de tapete. Então, agora o que queremos fazer
também é definir nosso modo de jogo padrão. Esta é a base
que o motor usa. Então, vou clicar nele
e, em seguida, clicar em
GM Maple Story, este é o nosso personalizado. Então eu quero que você clique
nesta pequena seta ao lado
do modo K. Agora você precisa alterar
as classes padrão. Então podemos ver aqui que diz a classe
do controlador do jogador,
acabamos de fazer uma. Então, clicando aqui e
mudando para a história do PC Maple. Também temos que definir
nossa classe de lagoa padrão, mas realmente não
temos ligado agora, então vamos pular isso por enquanto. E vamos fechar isso. Agora, dentro deste
mapa você está, você também precisa se lembrar de
ir para as configurações do mundo. Então, se você não tiver essas configurações
mundiais abertas, você pode clicar em Janela. E então você pode
clicar nesta chamada Configurações
do mundo para
abrir a janela. Mas aqui nas
configurações do mundo você também precisa se lembrar de mudar essa substituição
do modo de jogo. Então, clicando aqui, clicando
no GM Maple Story, e eu vou clicar
nessa seta apenas para
garantir que o
controle do jogador esteja correto. Exatamente o que eu defini
nas configurações do projeto. Então, história capaz de PCM. Você também pode ver aqui, se você clicar duas vezes no Modo de Jogo, você pode ver aqui à direita dentro dos padrões da
classe. Aqui à direita, você pode
ver se eu faço isso menor. Ele diz que o controlador do jogador
é PC, Maple Story. Ele disse isso automaticamente
porque fizemos isso dentro das configurações do
projeto. Ok, nós realmente não queremos trabalhar dentro daqui agora, então vamos fechá-lo. Então, agora criamos o modo de jogo básico e o controlador
básico de um jogador. Então, vamos seguir em frente
na próxima lição e
criar o personagem.
20. Blueprints para pais e crianças: Então, agora é hora de
adicionar o personagem. Assim como o que eu
te disse antes. Clique com o botão direito do mouse aqui e vá para classes de
blueprint ou classe aqui. Quando você clica em todas as aulas
aqui, procure papel. Agora, em vez de criar
esse personagem, lembre-se de que estamos trabalhando em 2D, então temos que criar
um personagem de papel. Então, clicando nesse
aqui e clicando em Selecionar. Agora temos que
chamá-lo de algo. E, por enquanto, quero
explicar a vocês o que são os
planos dos pais e dos filhos. Então, primeiro aqui, vamos criá-lo e
chamá-lo de base de caracteres. Agora temos uma base de caracteres aqui e vamos clicar com o botão direito do mouse nela. E agora pode ver que diz a classe
Create Child Blueprint. Então deixe-me criá-lo e
quero explicar a
vocês o que estou fazendo. Então, PPE, vamos
chamá-lo de base de jogadores bp. E vamos fazer outro
aqui a partir da base de personagens. Clique com o botão direito do mouse nele novamente e
crie a classe Blueprint filho. Vamos chamar isso de
uma base inimiga VP. Ok, então o que estou
fazendo aqui é me deixar realmente
salvar tudo primeiro. Então, o que estou fazendo
aqui é que
criamos um personagem base
e, a partir disso, cliquei com o botão direito do mouse
e criei blueprints filhos. Então, o que são
plantas infantis é quando você codifica algo
dentro do personagem, Hoje, esse código será transferido
automaticamente para a criança. Lembre-se que a base inimiga e base de
jogadores são
filhos da base do personagem. Então, o que eu codifico
ou faço dentro da base de caracteres também será aplicado a qualquer base
e reproduzirá uma base. Isso é
muito útil para que você não precise codificar a mesma coisa
repetidas vezes. Então, se eu, por exemplo, quiser citar algo aqui, e eu quero
que a mesma coisa esteja aqui, e a mesma coisa esteja aqui. Isso seria
muito trabalho e não
seria tão otimizado. Em vez disso, criei projetos
chamados. Então, o que eu fizer dentro
daqui também será automaticamente transferido para o inimigo e o jogador. E, por exemplo,
na base de caracteres, você pode clicar duas vezes nele. E temos algo chamado componentes
de movimento de personagens. Então, dentro daqui, por exemplo, você pode controlar qualquer
movimento do personagem. Por exemplo, quão rápido seu personagem
deve andar? E se eu escrever, por exemplo, digamos 200 em vez de 600. E a compilação está apenas economizando. Falaremos sobre isso
na próxima lição. Então, compilando e economizando aqui. E se eu minimizar isso e
abrir meu, digamos jogador. E eu olho para o componente de
movimento dos jogadores, você pode ver que ele
caiu automaticamente para 200. Porque lembre-se que é um
filho de caráter baseado. Então, o que quer que eu faça dentro
do personagem, ele será aplicado
ao jogador. Então, se eu voltar
aqui e clicar nessa pequena seta para
voltar ao padrão, e ela volta para 600. Agora, se eu for para o jogador, você pode ver no jogador que ele
também mudou de volta para 600. Então, isso é muito útil. E o que queremos fazer agora, dentro da base de jogadores,
queremos clicar com o botão direito do mouse aqui. E agora queremos
criar os jogadores, porque agora temos uma base para os jogadores.
Vamos clicar com o botão direito. E eu quero criar
este chamado Tsarina. E também temos outro
personagem chamado Luke. Trabalharemos com eles mais tarde, mas podemos criá-lo agora. Portanto, crie novamente o
Child Blueprint
do jogador e chame-o de BP Luke. Ok, então agora essas duas crianças, sempre que codificamos algo
na base de jogadores, por exemplo, o movimento, não
queremos codificar o movimento aqui
para o loop for. E então queremos codificar o
mesmo movimento para Serena, porque esses dois jogadores, eles têm o mesmo movimento. Eles estão correndo da mesma maneira. Eles estão pulando com
o mesmo botão. Por exemplo, clicar
no espaço para pular ou clicar nas
setas do teclado para correr. Não queremos fazer isso duas vezes. Só temos que codificar isso
dentro da base de jogadores. Agora, não faria sentido
codificar o movimento dentro
da base de caracteres. Porque lembre-se
que temos uma base inimiga e o inimigo não está realmente andando
como você como jogador, o inimigo não está
usando um teclado. O inimigo não tem um
mouse para olhar ao redor, então não faz sentido
codificar o movimento dos jogadores dentro do inimigo
porque é inteligência artificial. Ele realmente não tem um
teclado, não é um humano. Por isso, faria
mais sentido codificar o movimento dos jogadores
dentro da base de jogadores. Tudo bem, então agora
temos os planos de pais e filhos criados. E novamente, lembre-se, se você
precisar de alguma ajuda com isso, você sempre pode entrar no meu servidor Discord e eu estou mais do que disposto a
ajudá-lo com tudo isso. Então, vamos clicar com o botão direito do mouse agora
e criar uma nova pasta. E vou
chamá-lo de jogador. E estou fazendo
um novo chamado inimigo. Então, estamos nos mantendo organizados. Vou colocar essa
base inimiga em vez de inimigo. Vamos
criar ai mais tarde. E depois colocando Luke, a base de jogadores e
Serena dentro do jogador. Então, agora, com isso feito, vamos clicar em
Arquivo e Salvar Tudo. E vamos passar
para a próxima lição.
21. Visão geral do Blueprint: Continuamos, vamos ter uma visão geral do gráfico de
blueprint. Então, vamos para nossa
pasta Blueprints dentro do atlas de jogadores. Basta entrar nessa
chamada base de jogadores. Agora ele vai
abrir assim, mas você precisa clicar em Abrir editor completo, um editor de
Blueprint. E isso acontece
sempre que você ainda não tem nenhum código dentro daqui. Então, clicando aqui e você pode ver que este é o gráfico de blueprint. E dentro daqui você
tem o Event Graph. E dentro do gráfico de eventos, é aqui que você escreve
todo o seu código. Você pode ver aqui, o Unreal
Engine fornece eventos muito simples por padrão. E para navegar
dentro do gráfico de eventos, você pode segurar o botão direito do mouse
e pode girar assim e usar a
roda do mouse para aumentar e diminuir o zoom. Você também pode clicar com o botão direito
para adicionar funções. Mais tarde, vamos
usar isso para adicionar algum código, mas não se preocupe com isso. Isso provavelmente parece
esmagador para você. Há muitas
coisas que você pode adicionar dentro daqui, mas estaremos trabalhando com isso durante todo
o curso. Além do gráfico de eventos
em que escrevemos o código, também
temos uma janela de visualização. E dentro da viewport, é aqui que adicionamos nossos itens. Então você pode ver aqui
à esquerda,
temos algo
chamado componentes. E dentro desta guia de
componentes aqui, por exemplo, o sprite, vamos adicionar um
flip book aqui para que
possamos ver no painel Detalhes, assim como eu falei
aqui neste painel Detalhes, quando clicamos em coisas
aqui em nosso nível, podemos editar itens e
editar, por exemplo, a localização, a
rotação, a escala. Também podemos editar coisas
sobre a colisão. Isso é a mesma coisa aqui dentro da classe blueprint. Quando clicamos em um componente, podemos adicionar configurações sobre esse componente
dentro dos detalhes. Então, por exemplo, o sprite. Mais tarde, vamos
adicionar o personagem. E você pode ver quando clico
neste flip
book fonte, você pode ver, podemos ver as animações para o personagem que criamos
em uma lição anterior. Então, o mesmo de antes. Temos um painel de detalhes
onde podemos editar as configurações e, posteriormente,
vamos adicionar
mais componentes. E isso pode ser feito
clicando neste botão Adicionar. E você pode ver que você pode
adicionar muitas coisas. Por exemplo, um cubo, uma esfera. Você pode adicionar iluminação, áudio e muitas,
muitas coisas. Aqui embaixo. Podemos ver nossos eventos que
criamos em nosso Event Graph. Portanto, se você voltar
ao Event Graph aqui, você pode ver que o Unreal Engine
fornece isso por padrão. E você também pode ver esses
eventos chamados Begin Play, ator, começar a
se sobrepor e tomar, e você pode vê-los aqui. Mais tarde, quando adicionamos funções, você também pode ver
nossas funções aqui. Você pode ver as macros, ver variáveis, e vou
explicá-las em uma lição posterior. E depois disso, também temos
essa barra de ferramentas aqui. O mais importante é
esse botão chamado compilar. E sempre que você escreve algum código, então se eu escrever
algo por diversão, você pode ver aqui que ele lhe dá um ponto de interrogação e diz que
sujo precisa ser recompilado. Então, ele diz que
você tem que clicar neste botão sempre
que terminar de escrever seu código, eu tenho que clicar neste botão. E este botão é, ele apenas verifica se o código
que você escreveu é bom ou não. Então, se eu clicar nele e isso me
der essa marca de seleção, significa que não tenho
nenhum erro no meu código e estou pronto para pressionar
play e jogar meu jogo. Mas se você fizer algo errado, isso lhe dará uma
cruz e
dirá que você
fez algo errado. E quando você receber um erro, ele o dará
aqui e os resultados do compilador. Você pode ver aqui que foi bem-sucedido. No momento, não
temos nenhum erro. Mas se você tiver um erro, ele aparecerá aqui e dirá qual é o
seu erro. Agora vou
selecionar este nó agora, isso era
apenas para testes. Vou clicar em excluir. E novamente, aqui na barra de ferramentas, você pode salvar seu projeto. Claro, você pode
procurar por blueprints. Você pode ir para as Configurações de
classe, ir para os
padrões da classe e assim por diante. E estaremos trabalhando com tudo isso ao longo deste projeto.
22. Eventos e funções: Vamos dar uma olhada em
eventos e funções. Vou voltar
para minha base de jogadores bp. Então, dentro daqui como padrão, o Unreal Engine fornece esses eventos padrão e os eventos são sempre
marcados com vermelho. Então, vou passar o mouse sobre isso agora e vou clicar em Excluir no meu teclado. Não preciso deles agora. Mas você tem este, o básico chamado start play. Este evento. Ele diz o que devo fazer sempre que clico
aqui no jogo,
sempre, sempre que eu
começar a jogar meu jogo. Por exemplo, muito simples. Você pode arrastá-lo
desse pino de execução e
arrastar para fora e dizer imprimir. Então, procurando por impressão. Esta é a função muito básica que você aprenderá
desde o início, e apenas imprime algum
texto na tela. Então, clicando nesta função. Então esta é uma
função e você pode vê-la pelo f aqui em cima. Portanto, este é um evento, isso é uma função. Você sempre, sempre no Blueprint
precisa de eventos para disparar código. E o código
consiste em várias funções. Sempre precisando de um evento
para disparar o código, seu motor não sabe quando
você quer disparar esse código. Então, se eu tivesse isso desconectado
e você pode fazer isso segurando Alt no
teclado e clicando aqui. Isso os desconectará. Se eu fosse como
aqui, o motor, nunca
saberemos quando
disparar este código. Se você não tiver um
evento junto a ele,
vou arrastá-lo aqui para
a outra
caneta de execução e
conectá-lo , clicando em compilado. Lembre-se de fazer isso. Você também pode aqui, em vez de compilar e
economizar o tempo todo, você pode clicar nesses
três botões são pontos e dizer Salvar na compilação, apenas
sem sucesso. E o que isso significa é
sempre que você compilar agora, salvo
automaticamente para você
se essa marca de seleção aparecer. Então, agora o que acontece
é no Begin Play, minha tela vai dizer olá. Vou minimizar isso
um pouco e você tem que olhar aqui até o canto superior esquerdo. Então, clicando em jogar, e você pode ver que nada acontece. E isso é, na verdade, um
pequeno erro por mim. Então, vamos realmente
adicionar a base de jogadores. Lembre-se mais cedo, eu realmente
lhe disse que
queremos adicionar a lagoa. Então, vamos clicar
na cruz aqui. Vamos realmente fazê-lo agora
antes de esquecê-lo. Então, indo editar as configurações do projeto e nos mapas e modos
indo para cá novamente, lembre-se de que eu disse que
precisávamos adicionar isso mais tarde quando criamos um
personagem e temos um agora. Então, clicando aqui, e vamos fazer nossa
personagem Serena por enquanto. Vamos codificá-lo Serena. Portanto, não vamos criar
uma base de jogadores agora. Então, queremos gerar Serena para
o mundo mais tarde. Então, vou selecionar minha
classe de poema padrão, apenas Serena. Mas, mais tarde, teremos uma tela de seleção de
caracteres. E quando temos
isso, nós apenas chegamos a nenhum porque então
o jogador seleciona
o personagem e
ele vai aparecer como uma czarina ou Luke, dependendo do que
eles selecionaram. Mas agora não temos uma tela de seleção de
caracteres. Então, vou aparecer
como czarina por padrão. Vou clicar em Crosshair, ir para as configurações do mundo
e me certificar aqui e o modo geral de jogo que
Serena também é aplicado aqui. Agora, vamos clicar em Jogar novamente. E você pode ver minha
tela diz, olá. Agora caindo pelo chão. Você pode ver aqui que estou
puxando pelo chão porque eu não tenho
um jogador começar. E podemos adicionar um também, só para não cair
no chão indo aqui. E eles adicionam rapidamente o botão, indo para o básico e adicionando
o início do jogador. Então é aqui que
podemos começar aqui. E se você clicar em G, você pode se lembrar de mostrar
e ocultar os ícones. Este é o início do jogador. Vou colocá-lo
no meu mundo aqui, vamos fazer o y 0. Então está aqui na frente. E então podemos, vou torná-lo menor agora porque se você tiver essa cápsula está no meio
de suas telhas de colisão, isso vai dizer tamanho ruim. Vou reduzir a escala
aqui para 0,25.25.25. E então eu
vou arrastá-lo aqui perto do chão. Agora, quando clicamos em Play, você pode ver onde caindo
pelo chão, mas não estamos
caindo todo o caminho porque temos nossa colisão. Ok, então volte para as plantas agora
dissemos Olá e você pode ver aqui no canto superior esquerdo
que diz Olá na minha tela. Então o código está funcionando
agora e está passando por essa base de jogadores. Outros eventos que temos são
algo chamado tick de evento. Então você pode
procurá-lo aqui se você clicar com o botão direito do mouse no gráfico
como eu disse antes, você pode procurá-lo aqui. E se você acabou de escrever um evento, poderá ver todos
os eventos que podemos aplicar ao nosso código. Por exemplo, evento hit, ou se seu ator começar a
sobrepor algo, ou se seu personagem tiver saltado, você quer fazer alguma coisa. Talvez se você começar a
jogar o jogo, isso é o que temos agora. E talvez esse
chamado tick de evento, isso é o que eu
quero mostrar agora. Este é algo que
você nunca deve usar. E sempre que você usá-lo, isso provavelmente é porque você tem que usá-lo em algum momento, mas tente evitar isso, nunca use-o em seu jogo. O que quero dizer com isso
é porque este executa seu código 60
vezes por segundo. Então, se eu clicar no
Control X para copiar isso e o Control V para
colá-lo aqui. Se eu conectar isso aqui,
então o evento doente, você pode vê-la quando eu clico
em Jogar este lugar tantas vezes e ele joga
60 vezes por segundo. Então, pode imaginar se você
tiver algum código que está sendo jogado 60
vezes por segundo, seu jogo ficará atrasado. E se você tiver
vários desses, seu jogo vai
gostar mais e os jogadores sentirão a perna. Então tente nunca, nunca, nunca usar isso. Há sempre uma solução
melhor do que usar um evento seis. Vou excluir este. Nunca uso isso nos meus jogos. E há alguns momentos em
que você tem que usá-lo, mas isso é sempre que seu jogo é muito
grande e você entra em uma situação em que você realmente não
pode fazer
nada além de fazer isso. Mas eu diria que um jogo
muito grande, use isso apenas uma vez. Então nunca, nunca use isso. Tente excluí-lo. pense nisso, neste evento. E, como você pode ver,
há muitas funções que você
pode adicionar ao seu jogo. Temos tabelas de dados, então temos noivo, temos camadas e assim por diante. Então, muitas coisas que você pode adicionar provavelmente
usaremos 10% de tudo isso. Portanto, nem se
preocupe com tudo isso, mesmo
que pareça esmagador. Novamente, se eu for aqui e
escrever string de impressão, haverá outra
função chamada delay. Então eu posso atrasar aqui. Se eu escrever um atraso, poderemos atrasar em dois
segundos, por exemplo. E então podemos imprimir
outra string. E aqui vou chamá-lo terminado, algo assim. E você pode clicar nessa
seta para fazê-la jogar por mais tempo. Por exemplo, quero
reproduzi-lo por dez segundos na minha tela. Quero deixar a cor vermelha. Então você tem algumas variáveis
aqui que você pode mudar. E eu vou compilar, lembre-se de fazer isso. E então você pode clicar
em jogar no seu jogo. Posso dizer que diz olá
e depois de dois segundos, vai dizer terminado. Então, muito básico,
este é o Blueprint. Você pode ver que é muito
fácil trabalhar com ele. E depois de aprender o básico, você pode criar jogos
muito poderosos. Então, agora, na base de plantas, vamos realmente
excluir tudo, compilar e salvar,
e vamos seguir em frente.
23. Variáveis: Continuamos
configurando o personagem. Vamos falar sobre a última
coisa chamada variáveis. E este é o
principal princípio na programação em blueprints e qualquer linguagem que
você esteja escrevendo. Então, vamos para a base de jogadores novamente e para a esquerda,
como você viu antes, há algo
chamado variáveis. E eu quero que você
pense em variáveis como contêineres que contêm
algum tipo de informação. Eles podem, por exemplo, conter quanto
personagem mais saudável tem, que tipo de arma
seu personagem está segurando, sua velocidade de movimento, se você tem moedas suficientes para comprar um item na loja ou não. Então, um contêiner que contém
quantas moedas você tem. Portanto, as variáveis são contêineres que contêm informações
específicas, qualquer informação que
você esteja tentando armazenar. E para criar uma variável, você precisa clicar
neste botão de adição. E quando você cria uma variável, você tem que dar um nome a ela. E à direita, você pode ver
todo o tipo de variáveis. Por exemplo, crie um booleano. E vamos chamar isso de
booleano tem arma. E eu geralmente começo
meus booleanos com um b. E isso é porque isso
geralmente é o que é feito
em C plus plus. E quando você arrasta isso, você pode arrastá-lo para o gráfico. E quando você solta, você
pode optar por obter essa variável para configurá-la
para algo específico. Então, vamos pegar essa variável. Então agora temos essa variável
e, se você compilar, você pode ver aqui
no painel Detalhes, você tem algumas configurações que
você pode alterar para ela. Você pode alterar o tipo de
variável, você pode alterar o nome
que acabamos de dizer. Você pode adicionar uma descrição
e replicação. Vamos
tocar nisso mais tarde. Isso é multijogador. E agora diz, por favor,
compile os planos. E vamos
compilar aqui em cima. E isso mostrará
qual é o valor padrão. O que é um booleano,
é algo que pode ser verdadeiro ou falso. Portanto, pode ser
falso como este ou eu
posso pegá-lo e o
valor padrão será verdadeiro. Por exemplo, podemos verificar se o jogador tem a
arma ou não. E talvez possamos começar por
padrão a ser falsos. Então o jogador
não tem a arma, mas depois quando o
jogador pegar a arma, esta que vamos
definir como verdadeira. Ok, por exemplo, vamos dar um exemplo aqui. Vamos fazer o evento de
jogo inicial novamente. Então, se seus direitos começarem a
jogar vazando aqui. Agora, vamos pegar isso e
podemos dizer string de impressão. Agora, quando imprimimos essa string, o que você pode fazer em vez
de dizer olá, você pode arrastar isso
e conectá-lo aqui. E isso vai
te dizer, vou converter essa variável booleana
em uma string,
porque uma string é, na verdade,
uma variável também. Você pode ver aqui que há
uma variável chamada string. Então você pode arrastar
isso e ele irá convertê-lo em uma string, o que significa apenas em texto. E vou imprimir
esse texto na tela. Então, agora, quando você
conecta a variável, agora
você pode clicar em jogar. E vai dizer falso, e esse é o valor
do booleano. Então, mais tarde, digamos
depois de cinco segundos. Então, vou fazer o
nó de atraso e fazer cinco segundos. Então, depois de cinco segundos, eu realmente quero dizer que o personagem
pegou a arma. Então eu posso arrastar isso
e depois dizer set. Posso conectá-lo aqui
e configurá-lo como verdadeiro. Agora, vamos, vamos fazer
a string de impressão novamente. Então, vou clicar em
Control C, Control V aqui. E vou conectar
minha variável agora, o valor. E vai imprimir
isso na tela, compilar e clicar em jogar. Então, ele vai dizer falso. E depois de cinco segundos, vai dizer
verdade aqui em cima, ok? Então ele vai dizer falso
e então vai
dizer verdade porque definimos
isso como verdadeiro mais tarde. E é assim que definimos
variáveis dinamicamente. Primeiro, o jogador mais tarde
entra em nossa arma, vamos definir que tem
arma como verdadeira, por exemplo. Então, vamos excluir tudo
isso por enquanto. Então, temos esse booleano
que pode ser
verdadeiro ou falso e você pode
verificar as coisas com ele. Você tem
os outros, você tem um viés, você tem um inteiro,
inteiro 64 e um flutuador. Tudo isso para
nossos valores numéricos. Por exemplo, vamos tentar
criar um número inteiro. Vamos arrastá-lo para fora. Mais uma vez. Clique em Obter. Em vez de clicar em
obter e definir o tempo todo, você pode clicar e arrastar e
segurar Control no teclado. Isso o obterá automaticamente. Você também pode segurar Alt no
teclado e clicar e arrastar, e ele definirá
isso automaticamente. Então, em vez de arrastar e
clicar em definir, você pode segurar
Control ou Alt. Certo? Então, todos esses
valores numéricos, então o inteiro, inteiro 60 para o float, o byte, todos esses
são valores numéricos. E se eu compilar e
clicar nisso aqui, você pode ver que é um número, é preciso um número neste, talvez
possamos mudar
o nome dele, clicar em F2 para alterar o nome. E este poderia
dizer quantidade de moedas. Então, talvez estejamos
coletando moedas. E eu vou
compilar diz, por favor, compile a compilação do projeto. E aqui você pode ver
a quantidade de moedas. Então, começamos com 0 e,
à medida que
entramos em moedas, vamos adicionar moedas
a essa variável. Então, temos alguns operadores. E se você clicar
e arrastar disso, você pode salvar,
por exemplo, Plus. E você pode ver
que podemos adicionar moedas. Se você escrever menos, você pode subtrair moedas. Se você escrever o sinal dividido, você pode ver que diz dividir. Também temos a
multiplicação assim. Então, por exemplo, podemos
dizer mais assim. E em Maple Story você
pode coletar as moedas. Acredito que se chama micelas. Micelles, não tenho certeza. Não tenho certeza do
que se chama. Então, vamos chamá-lo de moedas. E por exemplo, posso acrescentar, toda vez que entro nele, posso adicionar dez moedas assim. Agora, se eu arrastar daqui
e escrever uma string de impressão, agora posso conectar isso
à minha string de impressão, e ele irá
converter o número inteiro uma string que
é uma variável de texto. Agora ele vai imprimir dez. Então deixe-me fazer a
duração muito mais aqui. Deixe-me fazer a cor vermelha. Esta compilação salva. E quando clico em Play, você pode ver isso diz dez
aqui porque eu tenho dez moedas. O número inteiro. Muito legal. Você pode escrever números. Podemos usar esses operadores
para modificar essas variáveis. E outro
tipo de variável é o flutuador, muito importante, podemos dizer, por
exemplo, integridade da camada. Isso é o que podemos chamá-lo. Podemos arrastá-lo para fora, segurando o controle,
obtendo-o automaticamente aqui. Então, se você compilar agora, a coisa legal do
nosso flutuador em comparação com um número inteiro é que um flutuador
pode conter casas decimais. Então, por exemplo,
posso escrever 50,5 aqui. E o valor padrão,
como para as moedas, se eu tentar escrever casas
decimais, por exemplo, 50,5, ele irá convertê-lo automaticamente
para 50 porque você não pode escrever casas
decimais dentro de um inteiro. Então, sempre que você quiser um
número com casas decimais, você precisa selecionar um flutuador. Este é o único, mas se você quiser
algo que seja um número completo sem
casas decimais, você pode escolher um inteiro ou algo que seja
maior e inteiro 64. Quanto à mordida, você
só pode definir o número. Se eu alterar a variável aqui. Quanto à mordida,
você só pode alterar o número para um máximo de 255. Então, para a
saúde do jogador, agora é um byte. Novamente, se eu escrever
casas decimais, não aceitará. É apenas o flutuador que
aceita casas decimais. E este só pode conter
o número 200 até 255. Então, se eu escrever 256, ele vai
mudá-lo para 255 para que eu possa escrever qualquer
número, os joelhos 255. Mas se eu escrever algo acima, ele não vai aceitá-lo. Então você pode imaginar
os usos desses. Por exemplo, se eu tiver uma
tela de seleção de personagens e tiver, digamos que eu tenha talvez 60
penteados e Maple Story, eu posso usar a mordida. Mas se eu tiver,
digamos que domingo eu tenho 600 penteados por algum motivo. Não posso
mais usar uma mordida porque só posso ter até 255 penteados. Ok, então esses são
os valores numéricos e também temos outros valores. Temos o nome, a string, o texto e pedimos o
nome. Vamos criar isso. E se eu arrastar o nome aqui, você poderá ver
todas as variáveis que criamos têm cores
diferentes. Então, se eu apenas criar variáveis
aleatórias aqui em cima, e eu mudar essa para
uma string, mude esta para um
texto, gritos, textos. E podemos arrastá-los para fora. Podemos, por exemplo, chamar
esse ID de conquista. Podemos, podemos chamar o
segundo nome de servidor, e podemos chamar a
última mensagem de bate-papo. Ok, então a diferença
entre eles você pode
tentar compilar e você pode ver quando você clica
nessas variáveis, são apenas alguns textos
que você pode escrever aqui. O mesmo vale para
o nome do servidor e o mesmo vale para o jogador. A saúde do jogador Ashley, precisamos compilar. Agora compile este
é o errado. Vou arrastar
este em vez disso. E você pode ver aqui
esse ID de conquista, ele não diz nada agora. Então, todas elas são variáveis de
texto e você pode escrever algum tipo
de texto aqui. A diferença entre eles
é que você sempre tem que escolher essa variável de nome
sempre que tiver algum tipo de texto que
nunca muda no jogo. Por exemplo, ID de conquista. Talvez uma conquista
que você tenha seja chamada ID 273 ou qualquer número
aleatório que você tenha. Este ID, você nunca
terá a necessidade de
alterá-lo no jogo. E é aqui que
você pode usar um nome, porque o que quer que você escreva aqui. Nunca pode ser modificado no jogo, mas esse não é o caso
do nome do servidor. Então, por exemplo, se eu
escrever Maple Story, melhor servidor, junte-se agora
ou algo assim. Agora, este texto que eu escrevo aqui, você pode modificá-lo. Por exemplo, um e exemplo que posso dar a você é um nome de servidor. Portanto, se o jogador escrever
isso como o nome do servidor, podemos realmente modificar o texto que o
jogador dispara aqui. Se você arrastar dessa variável de
string, e se você apenas escrever string, poderá ver todas
as funções que você
pode usar com uma string. Se você rolar para cima,
poderá ver que essa é a categoria chamada string. E aqui você tem
todas as funções que você pode usar
com essa string. Então, por exemplo, você pode verificar se o texto escrito aqui está vazio. Portanto, se a variável estiver vazia e se estiver vazia, você
poderá ver a vermelha. Lembre-se de que
na verdade é um booleano, então pode ser
verdadeiro ou falso. Por exemplo, se o nome do
servidor estiver vazio, você dará um erro ao jogador dizendo
a ele para escrever um nome de servidor porque você não pode criar um nome de servidor
vazio. Podemos arrastar novamente, podemos escrever string e
podemos verificar novamente. Por exemplo, você pode fazer todos os caracteres em
minúsculas ou maiúsculas. Ou você pode até dividir o
texto. E talvez alguns. O que eu uso é se o
jogador escrever uma palavra ruim, por exemplo, o interno, e eu não quero que o jogador escreva isso no nome do jogador. Posso arrastar aqui. E posso dizer achar. Há algo aqui
nesta string chamada
encontrar substring. E eu posso escrever para o interior. Eu realmente não quero fazer
isso aqui no vídeo. E ele vai encontrar essa palavra dentro do servidor
do jogador. Então, o que quer que o jogador
tenha escrito aqui, ele encontrará essa palavra. E se isso acontecer, você pode
fazer algo com ele. E nesse caso, podemos usar
o chamado substituto. Assim, podemos substituir também, podemos simplesmente fazer isso em vez disso,
encontrar a substring. Também podemos fazer isso. Então, substituindo o interior
por outra coisa e você pode simplesmente deixá-lo
vazio e ele mostrará que o substitui por nada, o
que significa que ela exclui a palavra e não coloca
nada dentro daqui. muito legais. Você pode modificar as
variáveis de string como desejar, mas não pode fazer isso aqui. Se você arrastar disso
e souber o nome certo, você pode ver no nome não tem muito o que pode fazer. Então você não tem o está vazio, você não tem a substituição. Portanto, você só pode modificar strings
e não a variável name. A última coisa que você tem
é o texto e o texto. A única coisa que eu
quero dizer sobre isso de forma diferente
da string é que,
uh, textos que você pode localizar, para que você possa
traduzi-lo em diferentes idiomas. Digamos que você queira
traduzir seu jogo alemão, japonês ou chinês. Seja qual for o texto que você
deseja traduzir, você precisa usar uma variável de texto, o que quer que você escreva em
uma variável de string. Isso não pode ser traduzido
posteriormente no jogo. Então, antes de começar a
fazer o seu jogo, pense, eu quero
traduzir meu jogo para o alemão? Quando eu terminar? Se eu quiser, qualquer texto que
você queira traduzir, você tem que escrevê-lo
em uma variável de texto. Quanto ao nome do servidor, não acho que precisamos
traduzir o nome do servidor. Por exemplo, digamos que
tenhamos terminado nosso jogo. Não faz sentido
traduzir um nome de servidor. Isso é exatamente o que, seja qual for
o direito do jogador. Mas quanto a uma
mensagem de bate-papo, digamos, por
exemplo, alguém diz, olá, como você está? Ou talvez um NPC dizendo isso? E agora queremos
traduzir essa mensagem para o japonês porque alguém do Japão precisa ver
o que isso significa. Então, vamos mudar
isso para japonês. Mas se você escrever isso aqui, aqui, você não
pode traduzi-lo. Você precisa escrevê-lo
em uma variável de texto. E então você pode
perguntar, por que
não estamos usando
isso o tempo todo? Por que temos que
usar isso ou isso? E isso é para otimização. O nome usa menos memória
e depois vem a string. E o que é mais
caro é o texto. Claro que isso não
afetará nada se você usar apenas
um ou dois em seu jogo. Mas se você tem um jogo grande,
você trabalha há
três anos e você só
usa isso o tempo todo. Claro que isso afetará seu jogo. Portanto, este usa a
menor quantidade de memória. Então, sempre tente ir com isso. Se você tiver textos que
nunca mudam, por exemplo, um ID de conquista, mas
use uma string depois disso. E, por exemplo, você também pode
usá-lo para o nome de um jogador. Como o nome do jogador, novamente, você precisa
modificar o nome. Se eles escreverem uma palavra ruim, você tem que verificar se há no nome deles. E como a última coisa, se você quer que seu jogo
seja traduzido e você tem alguns textos que
precisam ser traduzidos, então você tem que escrevê-lo, escrevê-lo em uma variável de texto. Tudo bem, então o suficiente sobre isso. Vamos excluir isso por enquanto. E, novamente, você pode criar
mais variáveis de valor. E os últimos que temos são o vetor, o rotador
e a transformação. Podemos usar isso mais tarde
no projeto. Eu não vou
cobrir isso por enquanto, mas para o vetor, muito, muito simples
se você apenas
criá-lo agora e
clicar em compilar. Você pode ver que ele vem
com três números. E geralmente para o que
usamos um vetor, geralmente o usamos aqui. Se você clicar em qualquer coisa aqui, você pode ver no local que
costumamos usar um vetor para alterar ou verificar se há um local porque o local tem três números. E geralmente usamos vetores para isso porque ele
tem três números. Por exemplo, podemos definir a localização dos caracteres sempre que
eles pegarem um portal, podemos configurá-lo para um local
específico. O mesmo acontece com o rotador. Se eu mudar isso para um rotador, ele terá três valores, assim como aqui
no painel Detalhes. Sempre que clico em qualquer coisa, eles têm uma rotação. Portanto, este é um rotador e você
pode definir ou obter uma rotação. E como a última coisa que
você tem uma transformação. E isso é usado
sempre que você está gerando coisas para o mundo. Então, por exemplo, você está gerando o personagem
no mapa. Então você tem que
definir o
local dos personagens onde
deseja gerar o personagem, qual rotação esse
personagem deve ter e a escala que o
personagem deve ter. Tudo bem, essas foram as variáveis mais importantes e eu vou excluir todas elas. Vamos criar
mais variáveis personalizadas. E eu quero cobrir essas coisas muito
básicas para começar, porque isso facilitará
muito para você mais tarde. Então, vou excluir
tudo aqui. Vamos compilar. Agora. Vamos seguir em frente para configurar
o personagem e você
aprenderá tudo isso passo a passo
durante este curso.
24. Como configurar o personagem: Para configurar nosso personagem, vamos primeiro voltar à nossa pasta Blueprints e
vamos configurar a Serena. Então, em vez de jogador, fizemos essa aula de blueprint
chamada Tsarina. Este era um personagem de papel e este era um filho
da base de jogadores. Aqui para a BP Tsarina, temos que adicionar esses ativos. Lembre-se, fizemos esses
flip books e podemos adicioná-los à nossa classe de
blueprint. Então, voltando para a pasta
do jogador aqui, clicando em Serena,
quando isso abrir, isso é porque está vazio. Então, o painel Detalhes está
preenchendo a tela inteira, então você precisa clicar em Abrir
todo o editor de Blueprint. E estamos dentro daqui. Você pode ver que realmente não precisamos codificar nada agora, então vou para a janela de exibição. Aqui. flip book da Serena
aparecerá. Depois de adicioná-lo. Você adiciona os flip books
aqui à esquerda. Você pode ver que temos um
sprite e podemos realmente adicionar o flip
book da Serena dentro daqui. Também temos
movimento de personagem onde podemos controlar o movimento mais tarde
, quando adicionamos movimento. Então, vamos clicar no sprite
e aqui no flip book, há duas maneiras de
adicionar um flip book. Você pode clicar
aqui e selecioná-lo. Essa seria a
maneira mais fácil agora. Ou se você minimizar isso um
pouco e torná-lo um
pouco maior. Você também pode ir para
sua pasta de ativos, e você também pode clicar e
arrastar e ver isso destaca isso para você e
você pode adicioná-lo a esse slot. Então, cabe a você se você quiser
adicioná-lo desta forma ou dessa forma. Posso ver que temos nosso flip book adicionado e
isso já funcionará. Então, se você acabou de testá-lo aqui, se você apenas clicar em
Compilar e Salvar. E, novamente, ele garante
que você não cometa um erro aqui nas configurações
do projeto. Assim como antes, quando
adicionamos o modo de jogo. Aqui. Lembre-se de que você também tinha a classe **** padrão para Serena, porque isso é o que
estamos testando agora, apenas para garantir que você
tenha seguido essa lição. Ok, então agora você tem que adicionar um jogador começar de novo para gerar. Então você tem essa arena também
pode verificá-la aqui nas configurações
do mundo para verificar a Classe de Peão Padrão para
garantir que seja a czarina. E também que você tem um jogador
começa aqui no nível. Então, clicando em Jogar agora, você pode ver que estamos gerando
dentro do nível, mas ainda podemos
ver o personagem, mas o personagem
está realmente lá. E isso ocorre porque
ele não sabe a visualização que você quer porque
você não adicionou uma câmera. Vamos voltar para a Csarina aqui. E nesse brilho, você pode clicar nele aqui e realmente clicar
na cápsula. Não queremos anexar
a câmera em cima daqui. Então clique na cápsula
e clique em Adicionar. E o primeiro que queremos
acrescentar é algo chamado mola em uma
mola sobre ele aqui. Você pode imaginar isso como
o suporte para a câmera, então ela está segurando a câmera. Podemos o braço de mola
e, em seguida, clicar novamente em Adicionar e clicar em uma câmera. Então aqui, câmera. Então, temos esse braço ardente e a câmera está dentro
deste braço de mola. Então, é um filho
do braço da mola. E você pode ver que a câmera
está um pouco errada, girada. Atualmente, estamos assistindo
o personagem assim. Então, temos que girar a câmera. E lembre-se, muitas pessoas cometem um erro
clicando aqui e girando a câmera
pressionando E no teclado. Você pode ver que você tem
essas ferramentas diferentes. Mais uma vez, assim como você
tinha na janela de exibição. Muitas pessoas cometem o erro
de girar a câmera aqui, mas você realmente tem que
girar o braço da mola. Então, clicando no braço da
mola e
gire, girando o z para que a
câmera fique na frente dele, então menos 90 graus. Assim mesmo. E
vamos compilar e salvar. Você pode clicar em Jogar agora
e ver o que acontece. Então, clicando em Play. Agora podemos ver, você
pode ver o personagem. Portanto, a câmera está funcionando, mas as
configurações padrão estão erradas, então temos que editá-las. Tudo bem, então vamos
terminar tudo isso. Então, o que você precisa fazer é clicar
no braço de mola aqui
na câmera e você
realmente precisa mudar a câmera
para perspectiva. Então, o que você tem que fazer
aqui na câmera, você tem que mudar isso para visualização
ortográfica porque não
estamos trabalhando com 3D. Estamos trabalhando com 2D. Então, clicando na visualização
ortográfica. E aqui para a largura do órtico,
você pode alterar o quão perto
você está da câmera. Então, quanto menor for, quanto menor
o número, mais próximo você está
do personagem. Você pode ver que isso
é muito grande agora. E quanto maior for, mais longe você
estará do personagem. Então você pode ver aqui, se você acabou de
experimentar um grande número aleatório, você vai se afastar mais longe. Então, o que você quer fazer aqui? Eu testei no Maple Story, joguei e testei o comprimento da câmera
e é cerca de 1304. Novamente, isso é algo que
eu olhei e quando
testei Maple Story, então talvez seja 201,250,
talvez seja 1300. Não posso dizer isso com
certeza no jogo real, mas parece que
é por volta de 1304. Tentei jogar o
jogo algumas vezes e testar a câmera. E, em seguida, o que queremos fazer é clicar no
braço da mola e desativar este chamado fazer
testes de colisão porque ele
irá incomodar a câmera. Então, tirando isso, clicando em compilar,
clicando em Salvar. Agora, quando você clica em Jogar, você pode ver que esse
é o personagem. E se você se lembrar, podemos clicar em FL1 para
maximizar a janela de exibição. Isso é o que parece. Agora mesmo. O jogador
não está começando no início do jogador e pode ter algo a ver
com nossa colisão. Então, se voltarmos aqui na Serena, temos esta cápsula aqui você pode ver esta
cápsula e esta é a cápsula de colisão,
este componente cápsula. Então, temos que fazer isso
menor para se adequar ao nosso personagem. Caso contrário, ele colidirá com as telhas e
não funcionará corretamente. Assim, você pode alterar esta meia altura da
cápsula e ela pode alterar o raio para
se adequar mais ao nosso personagem. Vou escrever 16 aqui. E o raio da cápsula, vou escrever 33 anos. Então, é um pouco menor e
se encaixa mais no nosso personagem. Agora clique em Compilar e Salvar. Vamos ver se esse
foi o problema. Então, estou clicando em Jogar agora. E era o problema, estava
colidindo com isso. Você pode ver aqui que temos dados de
colisão aqui, temos dados de colisão aqui. A cápsula é muito grande, está colidindo com
esses dois aqui. E está incomodando. Então, ele começa
aqui no topo. Mas agora que corrigimos nossa cápsula de colisão,
do tamanho dela, pelo
menos, agora podemos
clicar em jogar e você pode ver que o
personagem está aqui. Agora, o pequeno problema
que temos agora, você pode ver que os pés do
personagem estão atrás da grama e queremos ter os pés na
frente da grama. Esta é uma solução muito fácil. Lembre-se, temos nossos
azulejos aqui em 000, porque quando você olha aqui para cima, e novamente, você também pode
apenas um bom truque. Você pode clicar
nesta ferramenta de encaixe. E você pode aumentar o número. E aumentando o número para algo como, digamos 100. Você pode ver a linha do meio
aqui em que estou interessado, nesta linha intermediária. Você pode ver a medula e
atravessa os azulejos. Então essa segunda
camada que temos, que fizemos antes, e a segunda camada, lembre-se de que
temos um primeiro plano. Estes foram o primeiro plano. E a área do meio
que temos em zeros, zeros 0 são nossos azulejos. E agora, nossa desova, nossos jogadores começam tem a
localização de 0 no y, mas só temos que
empurrá-lo um pouco
mais adiante para que o personagem não
esteja atrás da grama. Então, o que vou fazer é que vou fazer isso. Vou escrever
um aqui no y porque 0 está basicamente no
nível desses títulos. Mas se você escrever um, tecnicamente estamos na
frente desses azulejos. Então, se você acabou de escrever um
para o ponto de lugar no Y, e você pode clicar em Reproduzir. Você pode ver agora que você está
na frente da grama. Então, agora que
configuramos nosso personagem, vamos avançar para o movimento
do jogador.
25. Movimento básico do jogador: Vamos agora criar o movimento
básico do jogador. Então, vamos voltar para
a pasta Blueprints
dentro do player. E lembre-se do que eu
disse antes sobre as plantas infantis e
as plantas dos pais. Então, a melhor maneira de fazer isso
é codificar esse movimento dentro da base do jogador porque se você segurar
o mouse sobre isso, você pode ver a classe pai
de Tsarina é o jogador, e a classe pai para
Luke é a base de jogadores. Então, se revestirmos o movimento
dentro da base de jogadores, Serena e a aparência herdarão
esse código porque eles são plantas infantis desta base
de jogadores. Ok, então vamos entrar na base de jogadores, codificar
o movimento. Então, clicando aqui. Agora vamos abrir o editor de blueprint completo. E agora estamos dentro
deste gráfico de eventos. E, novamente, você pode clicar com o botão direito, segurar, clicar com
o botão direito do mouse Agora, para codificar isso, vamos começar com
o básico, e é chamado adicionar entrada de
movimento. Este é o que
você sempre
usará em todos os projetos se
quiser adicionar movimento. Então clique com o botão direito do mouse e você
pode procurar movimento. Isso é algo que é
realmente útil às vezes quando eu codifico e não
sei como a função é chamada. E também fiz isso
quando eu era iniciante. Só estou pensando no
que eu quero fazer? Talvez eu queira fazer
algo com a localização, então basta clicar com o botão direito do mouse
e pesquisar o local. Então eu tento andar por aí. Às vezes, leva
muito tempo para deslizar isso. Mas então eu o encontro. Por exemplo, eu queria obter a localização
desses atores e
quero usar essas
informações para alguma coisa. E isso é o que você pode
fazer quando você é iniciante. Você realmente não precisa
saber como todos eles são chamados. Você pode tentar procurar
o que você está tentando fazer. Por exemplo, ele pode
resolver a busca por rotação se você estiver tentando fazer
algo com a rotação. Então, neste momento, estamos
tentando adicionar movimento. Então, procurando por movimento, você sempre pode
tentar percorrer, eu sei como é chamado, mas eu queria ver se
consigo encontrá-lo agora, o movimento é um pouco
difícil de encontrar aqui. Como entrada de movimento, isso é
o que estamos tentando encontrar. Então, clicando em Adicionar aqui,
adicione entrada de movimento. Agora lembre-se do que eu disse antes. Você não pode executar funções
se não tiver um evento. E queremos que o evento
seja as teclas do teclado. E então você deseja editar aqui e as configurações do projeto. E dentro das configurações de projetos, você tem essa chamada entradas, e é aqui que você
adiciona as teclas do teclado. Então, clicando nas entradas. Aqui no mapeamento de acesso, você também tem esse
chamado Mapeamento de ação. A diferença entre
o mapeamento de ação e o mapeamento de acesso é você pode pensar no
mapeamento do eixo como sendo contínuo. Um clique contínuo, um movimento
contínuo. Então, todos os movimentos
estarão aqui em baixo. E, por exemplo, clicando em
W para avançar, clicando em D para mover para
a direita e assim por diante. Você tem, esses são mapeamentos de
acesso. No entanto, se você quiser apenas um evento com um clique, por exemplo, pressione a barra de espaço para pular ou pressione o
botão do mouse para atirar em sua arma. São
mapeamentos de ação, movimentos, mapeamentos de acesso
e eventos com um clique. Eles estão em cima nos Mapeamentos de
ação. Aqui sempre adicione os movimentos
aos mapeamentos de acesso. Então, queremos adicionar,
por exemplo, mover para a
direita e para a esquerda. Então, como este é um jogo 2D, estamos nos movendo para
a direita e para a esquerda neste jogo de plataforma. E aqui você
tem que atribuir chaves ao que deseja usar para mover
para a direita e para a esquerda. Você pode clicar aqui e clicar aqui e encontrar a chave. Mas outro
método útil é clicar neste botão e clicar
na tecla do teclado. Então, vou clicar em D
no meu teclado. Isso moverá o
personagem para a direita, e eu vou
clicar neste botão de adição, olhando neste
teclado e clicando em um no meu teclado
para mover para a esquerda. E você tem que definir a escala
para menos uma para a esquerda. Então você pode pensar nisso como
duas direções diferentes. Portanto, é mais um quando
você se move para a direita e é menos um quando
você se move para a esquerda, assim como um gráfico
com os eixos x e y. Tudo bem, então vamos fechar as configurações do projeto
e vamos voltar aqui. Agora, quando você adicionou
o mapeamento de eixos lá, agora
você pode clicar com
o botão direito
do mouse aqui e escrever o mesmo nome que o chamou nas Configurações do
projeto. Então eu chamo isso de mover para a
direita e para a esquerda. E você pode ver aqui, eu
posso ver os eventos do eixo. Portanto, você deseja adicionar
este chamado Access events, não os valores do eixo. E você pode ver que os eventos sempre
têm esse ícone também. Então eu posso clicar nele. Mais uma vez. Os eventos são sempre
marcados como lidos. Então você sabe que isso é um evento. Agora você pode conectá-lo
à entrada de movimento aqui. A próxima coisa que você
precisa aprender sobre funções é esse alvo. Eles são muito importantes. E você pode ver aqui
que diz aqui em cima, o alvo é ****. Então, ele quer adicionar
movimento a um peão. E lembre-se do nosso personagem. Estamos dentro do personagem
aqui, a base de jogadores. E esse projeto que fizemos, é um personagem, é um personagem de papel. E assim como antes do que eu disse aqui na Classe Blueprint, um personagem é um tipo de lagoas. Portanto, na verdade, é
um tipo de telefone. Um criará um personagem que já temos
o alvo correto. Você pode ver que diz si mesmo. Self significa esse projeto. Você já está, então você está
tentando adicionar movimento ao blueprint em que
já estamos, então isso está correto. E quanto à direção à
qual queremos adicionar movimento,
você pode clicar com o botão direito do mouse aqui e
dizer Obter rotação de controle. Então, estamos tentando obter a
rotação do nosso controlador. E então podemos dizer “
get forward vector”. E agora podemos conectá-lo
aqui à direção mundial. Então, estamos tentando obter a direção para frente
do nosso controlador. Agora, quanto ao valor da escala, você pode conectar esse valor de
eixo a ele aqui. E agora você tem o movimento. Então, vamos compilar e salvar,
e vamos tentar nos mover. Então, clicando em Jogar agora, vou para a pessoa D mover-se para a direita, clicar em
idade e passar para a esquerda. Então você pode ver que temos o
movimento ajoelhado agora.
26. Salto do jogador: Vamos agora adicionar o
salto para os jogadores. Então, clicando de volta aqui
na base de jogadores. E lembre-se de que precisamos de um evento. Então, volte para as configurações
de edição e projeto dentro daqui em entradas. Agora, como o salto
é um evento com um clique, vamos adicioná-lo aqui
no mapeamento de ações. Lembre-se de que são apenas
movimentos que adicionamos nos Mapeamentos de acesso. Aqui, clicando no mais
para o mapeamento de ações. Vamos adicioná-lo aqui. Vamos chamá-lo de salto. E vou adicionar minha
barra de espaço a ela aqui. Você pode adicionar outro
botão se quiser. Vou fechá-lo. E agora podemos
clicar com o botão direito do mouse e dizer salto. E aqui você pode
vê-lo aqui em baixo nos Eventos de Ação dizendo saltos. Então clique aqui, e agora temos nossos eventos. Em seguida, você já
tem uma
função integrada dentro do Unreal
Engine chamada jumps. Assim, você pode arrastar dessa caneta de
execução e escrever salto, e você já tem essa
função chamada saltos. Então, clicando nele. Agora, compile save. E você pode clicar em jogar. E você pode ver quando eu
pressiono o espaço, você está pulando. Obviamente, temos que adicionar
a animação Slater, e também temos que
editar os movimentos. Então, quanto estamos pulando
e qual é a gravidade,
o que é isso para mais tarde. Então, vamos voltar
agora e quero mostrar algo
para otimização. Então, vou adicionar
uma string de impressão aqui. Então, ele vai dizer Olá
toda vez que eu clico em pular, se eu clicar em Jogar agora
e clicar no espaço, você pode ver no canto superior esquerdo, está dizendo Olá toda
vez que clico no espaço, agora estou clicando em espaço
em tudo o que posso agora. E você pode
vê-lo. Posso clicar no espaço e pular
mesmo estando no ar. E eu não quero fazer isso
por causa da otimização. Não quero executar
o código o tempo todo. Eu só quero executar
o código uma vez. E quando eu pouso no chão, permito que o jogador
pule novamente. Porque se eu permitir que o jogador pressione o espaço o tempo todo, você pode ver que podemos
gastar o código. Isso não é realmente otimizado, então eu só quero que o jogador execute esse código
sempre que o jogador puder, quando o jogador estiver subterrâneo. E temos algo
chamado está caindo. Portanto, se você pegar este Componente de
Movimento de
Personagens, você pode clicar e
arrastá-lo para este gráfico de eventos. E você pode ver que isso também
é uma variável. Lembre-se antes de aprender
essas variáveis muito básicas. Mas esta também é uma variável se você arrastá-la aqui. Então, agora podemos fazer algo
com o componente de personagem. Você pode se arrastar para fora dele
e você pode dizer que está caindo. E agora podemos verificar se isso está verificando se o
jogador está no ar. E lembre-se que a
caneta vermelha aqui é um booleano. Assim, você pode arrastar deste
booleano e clicar em b, e ele pode fazer com que
este seja chamado de ramificação. Uma ramificação é, é apenas verificar se esse valor é verdadeiro ou falso e você pode fazer
algo com ele. Então agora você está dizendo que está tomando o movimento do
personagem, você está verificando se o jogador está caindo e se é verdade, sim, o jogador está caindo. Não queremos pular porque o jogador
já está no ar. Mas, no entanto, se o jogador não
está mais caindo, então está verificando,
o jogador está caindo? Diz que não, o jogador não
está caindo. Ok, então você pode pular porque você
está no chão. Então agora você pode ver
se eu compilo e clicar em jogar, na verdade, vamos adicionar uma corda de impressão
aqui para que você possa ver que o jogador está caindo
e não podemos realmente pular. Na verdade, isso é aqui embaixo. Esse é um exemplo melhor. Então, só vai dizer
olá onde quer que pulássemos. Então, vamos clicar em pular.
Agora. Clique no espaço. Você pode ver que eu não posso
gastar meu espaço. Só posso executar o código
sempre que estiver no chão. Então, isso é otimizado. Então agora esse código
está otimizado e o jogador não pode executar
o código o tempo todo. No entanto,
para facilitar a leitura, posso excluir isso e
posso desconectar segurando Alt e clicando
neste pino de execução. Agora, em vez de fazer isso aqui, eu quero tê-lo
como verdadeiro porque posso lê-lo melhor se eu tiver essa
função definida como true. Mas agora temos que fazer
outro booleano aqui. Então agora está dizendo, o personagem
está caindo? O que queremos dizer se o
conectarmos ao verdadeiro, o personagem não
está caindo? Se isso for verdade, então o
personagem não está
caindo, os personagens no chão. Podemos pular para fazer isso apenas
para fazer isso o oposto. Podemos arrastar aqui e dizer nozes. E você não pode ver
este não é igual, temos que usar
este NÃO booleano. E o que isso está dizendo é, se o jogador está louco caindo, se isso for verdade, então vá em frente
e você pode pular. E eu acho que isso
é muito mais fácil ler do que ter isso como falso. Tudo bem, então a última
coisa que quero te
ensinar é
criar funções. Então, antes que você possa ver, temos muitas
funções que
podemos adicionar que são pré-fabricadas, mas você também pode fazer
suas próprias funções. E eu quero transformar este em
uma função e você
pode encurtar esta. E geralmente fazemos isso
para limpar o código. Você pode clicar com o botão direito aqui. E você pode dizer
colapso para funcionar. Então, em vez de você ir aqui e
criar a função, ele realmente a
criará para você. Então, selecionando todos esses três, clicando com o botão direito do mouse e dizendo
recolher para funcionar. Agora você pode ver que ele
fez uma função e geralmente eu escrevo F como um
prefixo para funções. Vamos chamar isso. Não está pulando. Então, isso é o que é. Está verificando se você está pulando. Só está dizendo que agora
você pode clicar duas vezes. A propósito, talvez
eu tenha feito isso muito rápido. Você pode clicar duas vezes
nesta função criada. E agora você pode ver a
função aqui. Começa. Vou arrastar isso aqui
para baixo para que fique mais organizado assim. Portanto, esta é a função. Começa aqui, termina aqui e dá um valor de retorno. E o valor de retorno, se você voltar ao Event
Graph, virá aqui. Este é o valor que
está sendo verificado aqui. Então, isso é um pouco mais organizado. Você está ocultando esse
código dentro
dessa função e somente
essa função aparecerá. Agora lembre-se, você tem
que adicioná-los à
caneta de execução porque no blueprint, você realmente não pode fazer
assim porque
você desconectou, uma
função desconectada e isso vai nunca corra se você
tiver assim. Então, a melhor maneira
seria fazer isso como aqui e depois executá-lo
através do código. No entanto, você pode fazer
isso um pouco melhor. Sei que lhe dei muitas informações dentro
deste vídeo, mas quero ensinar-lhe
o melhor método de codificação. Aqui você criou
agora essa função e ela está sendo executada corretamente
pelo código. Então você pode ver se
eu clico em Play, nada está realmente
errado com meu código. Posso pular e está
funcionando perfeitamente. Mas você realmente não precisa conectá-lo aos pinos de
execução aqui. Porque geralmente
nessas funções azuis, você pode ver que temos funções
verdes e temos funções azuis. As funções verdes
apenas fornecem algumas informações que você
pode usar para alguma coisa. Por exemplo, aqui
temos a rotação de controle. Temos o vetor para a frente, então a direção para a frente. E então estamos recebendo
essa informação e estamos usando-a como
nossa direção mundial. Portanto, funções verdes são
usadas para obter informações. E, no entanto, as funções
azuis são usadas para definir informações. Então, definimos funções
e temos funções obtidas. Por exemplo, a
função de salto está definindo o salto. E aqui não estamos
realmente vendendo nada. Então, se você clicar
nessa função que fizemos, não está
vendendo nada, só está recebendo se o
jogador está caindo ou não. Então, está recebendo informações. Portanto, não faz
sentido tê-la sendo luz azul aqui
e você pode mudá-la. Então, podemos clicar nesta função e você pode clicar
nesta chamada pura. Então, clicar em puro significa que estou recebendo informações
dessa função. Eu realmente não preciso defini-lo. Não estou definindo nenhuma informação, só
estou recebendo. O jogador está caindo ou não. Então, voltando ao
gráfico aqui, agora, você pode conectá-lo
assim e ver que ele está
mais otimizado. Agora. Você está apenas ficando se o
jogador estiver caindo ou louco, e se o jogador não
estiver caindo, se isso for verdade,
você pode pular.
27. Animações de movimento para jogadores: Agora estamos prontos para adicionar as animações de movimento
para o personagem. Espero que você esteja
totalmente acordado porque tenho muito a
ensinar nesta lição. Então, se voltarmos ao nosso jogador
e dentro da base de jogadores. Então, queremos adicionar
as animações aqui, então estamos adicionando o movimento, mas também queremos
adicionar a animação. Mas agora está ficando um
pouco mais complexo, mas porque agora estamos recebendo
um multiplayer real. Se eu minimizar isso
antes de fazermos qualquer coisa, quero ensinar-lhe
sobre enumerações, vamos clicar com o botão direito
aqui e vamos criar uma nova pasta chamada
enums para enumerações. Você pode entrar
nesta pasta, você pode clicar com o botão direito do mouse
aqui e blueprints, você pode criar essa
chamada enumeração. enumeração é, é apenas
uma lista de qualquer coisa. Então, se você fizer isso
e eu puder mostrar, geralmente começo enumerações, prefixos escrevendo E, e vamos chamá-lo de Estados de
movimento. Estamos criando uma lista
de estados de movimentos. Então, uma enumeração é
apenas uma lista de qualquer coisa. Você pode clicar
neste botão aqui. Você pode ver toda
vez que clicar nele, adicionar uma lista ou adicionar
um item a essa lista. Portanto, uma enumeração é apenas uma lista do que você
quer fazer uma lista. Por exemplo, mantimentos. Você pode escrever sua Apple, laranjas ou pepino ou
o que quiser escrever. Você pode escrever carros, por exemplo, uma lista de carros. Você pode escrevê-los aqui e
talvez os modelos dos carros. Você pode escrever uma lista de armas
e uma lista de qualquer coisa. Vou listar os itens. Mas, por isso, estamos escrevendo uma lista
dos estados de corrida ou movimentos aqui. O primeiro que
vou chamar de ocioso. Então, temos uma animação ociosa
e, em seguida, temos uma animação de direitos de
execução. Temos uma animação à esquerda
e, em seguida, temos
uma animação de salto. E também temos
uma animação de outono. E, na verdade,
não temos uma emissão decaída
porque só fizemos, vamos voltar ao Caráter de
Ativos. Fizemos uma animação ociosa,
uma animação de corrida. Mesmo que seja chamado de corrida, nós dois corremos à direita
e ao redor da esquerda. E então temos a animação de
salto aqui. Mas realmente não
temos uma animação de outono. Mas em Maple Story, a animação completa é a
mesma que o salto. Então, vamos
usar esse salto como nossa animação completa também. Então, vamos clicar em salvar tudo. Agora fizemos
nossa enumeração, fizemos a lista. Agora vamos voltar
para a base de jogadores. Agora aqui você pode adicionar
a enumeração. Então, se você criar uma variável e vamos chamá-la de Estados de
movimento. E você pode alterar
a variável aqui. E para encontrar sua variável
personalizada, você pode chamá-la do que você chamou, o arquivo de enumeração. Então, como prefixo e você
pode escrever movimentos, data, e você pode ver, você pode
ver sua enumeração aqui. Eles geralmente são essa cor verde
escura. Então este único movimento E afirma que
esta é a nossa enumeração, clicando nela, e agora é
uma variável que você pode compilar. Se você quiser ver
o que parece, você sempre pode obtê-lo
aqui e clicar em, Obter isso como obter
as informações. Você pode olhar aqui, clicar em set e ver
que pode configurá-lo para todos
esses itens de lista diferentes que você definiu
aqui na lista. Então, se você adicionar mais uma
coisa e clicar em Salvar, você pode ver aqui essa coisa nova na verdade, eu preciso compilar
aqui, Compilar e Salvar. Agora posso clicar
nele e você pode ver o novo item da lista
que foi adicionado. Então é assim que você adiciona
coisas à esquerda. Você também pode excluí-lo aqui. Podemos salvar, novamente,
Compilar e Salvar. E agora você pode ver que esta é
a lista que temos. Certo? Então, basicamente, o que queremos fazer é pegar esse valor de eixo. Agora deixe-me
imprimi-lo na tela eu
possa mostrar
o que está acontecendo. Então, agora vamos imprimir. Se você arrastar esse valor de eixo e estiver conectado
à cadeia de impressão. Agora ele vai imprimir esse valor de
eixo sempre que você executar. Então, se você clicar em
jogar e correr, você pode ver que é
um quando me mudei para a direita e é menos um
quando eu me mudo para a esquerda, lembre-se disso é o que escrevemos dentro das
configurações do projeto e do entradas. Um para se mover para a direita. Eu só quero me mover para a esquerda e
quando estamos parados, é 0. Certo? Mas essa informação
que temos agora, estamos ficando muito
mais inteligentes agora. Então, quando é, quando isso é igual a 0, você está
parado, está ocioso. Então, retirando isso e
escrevendo o sinal de igual, ou você pode escrever
igual se quiser. Você pode fazer com que esse operador
aqui diga igual. Portanto, se esse número for igual a 0, e eu puder arrastar aqui novamente
e escrever b ou uma ramificação. Se esse número for igual a 0, se isso for verdade, o que queremos
fazer? E, em última análise, o que
queremos fazer. Queremos definir este item da
lista como ocioso porque agora sabemos
que o jogador está ocioso porque o jogador
está parado, o valor do eixo é igual a 0. Mas se não for igual a 0, isso significa que você está se movendo. Sim, você está se movendo. Mas se eu apenas copiar colar
este controle C controle V. Você
está se movendo para a direita ou você está se movendo para a esquerda? Então, isso também temos que verificar. Então, por exemplo,
você pode arrastar
desse valor de eixo e você pode dizer, quanto maior sinal assim,
isso é maior? Então você pode escolher este. É esse valor de eixo, é maior que 0? E podemos arrastar este ano, eu seria para o ramo. E gritos, ele diminuiu o zoom. Não sei o que está
acontecendo assim. Portanto, se esse valor x
for maior que 0, isso significa que estamos nos
movendo para a direita. Então, vamos conectar
este do falso. Então, agora o que estamos dizendo é
esse valor x igual a 0. Se for, então está ocioso. Se não acontecer, vá
em frente e verifique este, então aqui embaixo, o que estamos verificando é, é o excesso de valor
maior que 0. Se for maior que 0, você está se movendo
para a direita. No entanto, se você estiver
se movendo, se for menor que 0, então você está realmente
se movendo para a esquerda, assim
porque é menos um. Tudo bem, então esse é
o princípio principal. Agora temos que fazer um
pouco mais de trabalho para fazê-lo funcionar no multijogador. Vou mover esse salto,
pular função IF aqui, saltar a lógica aqui. Então eu tenho mais espaço aqui em cima. Então este eu realmente
quero transformar em uma função. Então, vou
aqui e vou clicar com o botão
direito do mouse. E você também pode, você viu aqui se
você escreveu eventos, você poderia selecionar
um evento para adicionar, mas você pode fazer
seus próprios eventos. Então, se você escrever fantasia, você pode ver que você pode
adicionar um evento personalizado e você pode chamá-lo do
que quiser. Vou chamar isso de
um
estado de movimentos definidos porque é isso
que estamos tentando fazer. Então defina o estado do movimento e agora
temos esse evento. Ok, então eu quero
pegar um desses, então vou clicar em Control X para cortá-lo e
colá-lo aqui. Agora, alternativamente, o que
eu quero que você faça é definir meu estado de movimentos
aqui e o evento. E uma coisa legal que
você pode fazer aqui. Você viu, você poderia
adicionar variáveis aqui, mas também pode adicionar
variáveis às funções. Pode ver todas essas funções
pré-fabricadas. Todas essas são,
na verdade, variáveis. Assim, você pode clicar
nesses eventos personalizados. Você pode adicionar uma nova variável, mas também pode ser facilmente
adicionada arrastando esse pino e soltando-o sobre
sua função personalizada. Você pode ver que ele
cria automaticamente essa variável para você. Se você quisesse
adicioná-lo manualmente, você sempre pode
clicar no mais aqui e dar um nome a ele. Então, por exemplo, nome. Você pode ver isso muda de nome aqui e você pode selecionar novamente E. Movimentos permaneceram e você poderia
tê-lo selecionado assim. Só vou
excluir este. Eu só estava te mostrando. Então compostos Salve agora. Então agora o que você pode fazer aqui em cima. Então agora, em vez de ter
essa enumeração escrita, você pode tirar
isso e escrever o nome do evento
que você escreveu aqui. Então, é assim que você
chama um evento personalizado. Define estados de movimento. E você pode ver chamada função aqui, definir o estado dos movimentos. Agora, em vez de ter essa
enumeração em execução diretamente, ela realmente
executará esse evento que define essa variável como o que
você estiver selecionando aqui. Então, essas informações que você está escolhendo aqui estão
passando por aqui. E está configurando
sua variável para qualquer informação que ela esteja
passando aqui. Tudo bem, coisas
muito, muito legais, mas temos que fazer um pouco mais porque estamos
no multiplayer. Este não é um jogo para um
jogador. Isso teria funcionado
perfeitamente em um único jogador. Mas no multiplayer, geralmente
não definimos variáveis
nos clientes, então temos um cliente
e o servidor, e geralmente o servidor, que é o cara
que faz o jogo. Então, se eu jogar Counterstrike, crio um servidor. Sou o servidor. Imd, o verdadeiro jogo. Então eu tenho a
autoridade do jogo. E você ouve às vezes que
há truques ou hexadecimal, que é chamado de ataque
do lado do cliente. Então, o que costumamos fazer é
definir variáveis através do servidor porque o
servidor controla o jogo, você sempre tem
que lembrar que no Unreal Engine, servidor tem o controle do
jogo e o que quer que você faça, seja qual for a lógica
que você escrever, você tem que executá-la
pelo servidor. Os clientes são todas
as camadas conectadas. Então você fará o servidor, você é o servidor e todos os jogadores que se conectam
a você ao seu servidor. Eles são chamados de clientes. E se você não executar todo o
código através do servidor,
então, se você não verificar
o que está fazendo, por
exemplo, pulando ou fazendo
isso configurando uma variável. Se você não verificar primeiro, com o servidor,
o cliente terá um
tempo mais fácil de trapacear no jogo. Então, se você apenas executar isso
pelo cliente e definir
essa variável, o cliente tem uma maneira fácil de
trapacear dentro do seu jogo. Então lembre-se sempre, o servidor tem a autoridade do jogo, que o servidor
é o verdadeiro jogo. O servidor verifica se
você fechou a arma, então o servidor diz, sim, este cliente realmente
atirou na arma. Em seguida, vá em frente e aplique
danos a esse personagem. Portanto, o servidor sempre
precisa verificar essas informações para garantir que o cliente
não esteja fazendo nada ilegal. Então, outro exemplo, pouco
antes de continuarmos, por exemplo, o cliente, então a camada conectada. Dispara um RPG e RPG
mais distante que precisa
verificar através do servidor. O servidor verifica. Esse jogador realmente tem um RPG na mão e
atira na arma? Em seguida, o servidor
verifica e diz, sim, este cliente realmente tem um
RPG na mão e fechá-lo. Em seguida, ele
enviará essas informações volta para o cliente
que filmou o RPG. E isso dirá a
esse cliente que você permissão para atirar essa
arma porque sim, você tem o RPG na mão. Mecanismo de regras. Você tem essa
autoridade em que o servidor tem a autoridade e o
que quer que
o cliente precise ser verificado
através do servidor. Podemos simplesmente configurá-lo aqui. Isto é, você pode ver aqui este é o cliente
e você também pode verificá-lo aqui se você clicar com o botão direito do mouse
e escrever string de impressão. E lembre-se que a string de impressão é
tão poderosa, mesmo que
esteja apenas imprimindo uma string. Vamos compilar e salvar. E você pode ver o que estou dizendo. Agora, em vez de
clicar em jogar agora, vamos clicar nesses
três botões e vamos mudá-lo para
vários jogadores. Agora estamos dentro
do Multiplayer. Vamos escrever dois.
Aqui no modo net, clique neste chamado
play as listen server. Vamos clicar
nesses botões novamente e eu vou clicar
nesta nova janela do editor. Então é isso que
vou jogar agora. Não vou mais jogar na viewport
selecionada. Então, clicando na nova janela do
editor. Agora podemos ver que
temos o servidor. Você pode vê-lo no topo
aqui. Temos o servidor. Eu criei este jogo. E você pode ver o
cliente conectado ao meu servidor que
eu criei. Se eu clicar aqui, você pode
ver que posso me mover como o servidor, e também posso me mover como
cliente aqui. Então, agora estamos dentro
do multijogador. E como você pode ver aqui, o cliente olá e o
servidor também imprime olá. Isso significa essa informação. Isso significa que esse evento está sendo executado no servidor
e no cliente. Ambos estão dizendo olá. E quando defino variáveis, só
quero
configurá-las no servidor. Quero ter certeza de que
o cliente não está trapaceando. Então, nunca quero definir
variáveis no cliente. E vamos excluir isso. Então, vamos clicar com o botão direito aqui e dizer outros eventos
personalizados. Vamos adicionar um evento personalizado. Vamos chamá-lo de S RV por servidor. Eu costumo chamá-los de R V. E vamos chamá-lo do
mesmo nome que este aqui em cima. Diz estados de movimento. Assim mesmo. Agora, para fazê-lo rodar apenas
pelo servidor, você tem este no
multiplayer chamado replicação. Então, clicando aqui e
clique em executar em servidores. Então, só queremos executá-lo
no servidor e
clicar em confiável. Vou desconectar
isso segurando Alt, desconectando-os
e conectando o conjunto aqui com isso. E agora o que podemos fazer
aqui é executar esses eventos. Então, aqui em cima, executando
é o nosso v assim, e conectando essas
entradas assim. Ok, então agora está indo
corretamente, na verdade. Agora, o que estamos fazendo é verificar
se o valor x é 0, então o jogador está ocioso
se isso for verdade. E essa informação de ídolo. Agora estamos executando
esse evento chamado set movement state,
que é este. Então, estamos definindo essas
informações no Sul em marcha lenta. Essas informações estão sendo
impressas no servidor. E o servidor está
definindo essa variável para o que você escreveu aqui ou o que você
escolheu aqui. Ok, então este é o método
correto para fazê-lo. Então agora o que temos que fazer aqui, então vamos excluí-los. E, novamente, você pode
simplesmente escrever o nome
deste evento aqui para
chamar os conjuntos de eventos. Movimentos, estados
assim e selecione este, não este, então este aqui. E vamos copiá-lo,
colá-lo aqui embaixo. Portanto, se o valor do eixo
for maior que 0, significa que, se isso for verdade, significa que estamos
correndo para a direita. Isso é falso. Estamos correndo para a
esquerda, assim. Então, agora está mais
correto. Ok, então agora definimos a
variável o que agora? Porque você pode ver se eu compilo salvo
e salvo tudo, se eu puder clicar em Jogar agora, nada está realmente acontecendo. E isso está tudo bem. Porque essencialmente
o que você está fazendo agora é que você está
definindo essa variável, mas você realmente não
definiu o supervisor. Se eu voltar aqui, você não usou esse flip books. Lembre-se, você está apenas definindo essa variável para
qualquer informação que você está configurando aqui também. Então, para enumerações, temos algo chamado
switch on enumeration. Então, apenas como um teste, se eu arrastar essa
enumeração para fora, e se eu arrastá-la
aqui e disser switch, você pode ver um interruptor
na enumeração. O que é, basicamente, ele só lhe dá um pino de
execução
dependendo do que você escreveu
aqui na lista. E você pode fazer ações
diferentes. E você pode ver aqui,
quando estamos em marcha lenta, podemos executar este flip book. Quando estamos. Volto aqui. Se estivermos correndo para a direita, posso executar este
flip book run e assim por diante. Assim, podemos fazer ações diferentes
dependendo do que somos, para
o que definimos
essa variável. Ok, Então, dentro do
multiplicador novamente, você pode clicar em uma variável. E aqui no multijogador,
como antes, onde você tem
replicação no evento, dizendo que executar em servidores estão
sendo executados especificamente no
cliente. Também para variáveis, você
pode replicá-las. Então, como você pode imaginar, se você definir uma variável
no servidor aqui, o cliente precisa saber sobre
essas informações de alguma forma. E é isso que você usa
esse garfo de replicação. Porque se você definir essa
variável no servidor, como o cliente anotaria? Porque o cliente não tem chance saber o que
você disse isso também, porque você é o servidor. Você definiu as
informações no servidor, mas precisa enviar essas informações de volta ao cliente para
que o cliente saiba para que o servidor as
configurou. E é aí que entra a
replicação de variáveis. Então, se eu clicar nisso
e clicar em replicado, você poderá ver essas
duas esferas aparecerem. Isso significa que estou configurando a
variável no servidor e agora estou
enviando essas informações para
o cliente para que o cliente saiba qual é o valor
para essa variável. Isso é o que o replicado faz. Agora um pouco complexo. A última coisa que quero te
ensinar antes de explodir seus miolos é
essa chamada Rep, notificar. E isso cria uma
função para você. Então, se você clicar em retinas die, você pode ver aqui
que ele
cria automaticamente essa função de desembrulho. E o que isso faz
é executar essa função toda vez que
você definir essa variável. Então, toda vez que você
definir essa variável, ela executará essa função. Então, vou clicar duas vezes
nesta função. E eu vou
arrastar esse movimento ficou aqui segurando o Controle, soltando-o aqui, e
agora arrastando-o para cá, dizendo ligar enumeração. Assim mesmo. Toda vez que eu vou
executar esse código, execute-o aqui através do
servidor configurando essa variável. Toda vez que esse valor
for alterado, ele executará essa função. Então, o que eu quero fazer
com essa função é mudar o flip book. Porque lembre-se no sprite na verdade não aqui estamos dentro
da base de jogadores. Então, se eu for até
o jogador Tsarina, lembre-se nos sprites, temos esse chamado “flip books
fonte”. Portanto, é um flip book
que estamos mudando. O que temos aqui é algo
chamado sets flip book. E agora ele vai dizer
que é para o sprite aqui. E você vai
clicar Ok, Sim, isso é para o
sprite e ele
criará isso
automaticamente para você. Você também poderia apenas ter
clicado e arrastado daqui e dizer flip book, isso é a mesma coisa. Então, vamos definir este
flip book para o ídolo aqui. Quando estamos em marcha lenta, quando
estamos correndo para a direita, vou copiar colar isso, conectando isso ao
alvo, assim. Quando estamos correndo
para a direita, estamos executando a
animação de execução ou rodando flip book. Vou copiar colar
isso algumas vezes. A corrida à esquerda é, na verdade,
também a animação de execução. E o salto é a
animação de
salto assim, pular, lipídico
assim e a queda. Nós realmente não temos
uma nova animação, então vou conectar minha queda aqui e
usar o mesmo aqui, o flip book de salto. Certo, lembre-se de
tirar isso brilhante, você pode fazer
assim e se conectar a vários lugares ou
talvez às vezes
seja mais limpo apenas usar
vários como este. Você também pode fazer isso. Vamos fazer isso
por este aqui. Vou copiar colar
isso um pouco. E conectando o
último aqui. Vou deixar isso mais
limpo mais tarde, mas vamos trabalhar com ele agora. Salvar composto, clicando em Jogar. Agora, você pode ver aqui, se eu correr para a
direita, estou correndo. Se eu correr para a esquerda, veja, estou correndo Mas não estou correndo na direção correta
quando estou pulando. Saltando corretamente. E isso ocorre porque lembre-se de
que realmente não fizemos a animação de salto e
faremos isso logo
após esta lição. Mas vamos nos concentrar na corrida. Então, correr está funcionando, mas estou correndo na direção
errada quando estou correndo para a esquerda. E isso ocorre porque este é
um sprite e você precisa
girar sua imagem para
que ela seja executada corretamente. Então eu só quero girar esse
sprite quando estou correndo. Então, quando corro para a esquerda aqui, ele não está correndo na direção
correta. Então, o que você pode fazer
é pegar esse sprite aqui e você pode dizer rotação. Lembre-se, quando você não
sabe o que está fazendo, basta procurar rotação
e você pode tentar percorrer isso e
ver o que você quer fazer. E o que estamos usando
é a rotação relativa definida. Queremos girá-lo. Você pode minimizar
e clicar em qualquer coisa aqui. Por exemplo, este
jogador inicia e clica em E para a ferramenta de
rotação. E você pode ver
que você tem que girar o z. Então, se você quiser que algo
volte para o outro lado, você tem que girar o Z em 180. Então, vou clicar
no Control Z aqui. E o z, você tem que
girar o sprite em 180. E você pode ligar conectado aqui. Então, ele vai girá-lo
antes de definir o flip book. E lembre-se, para a corrida, certo, temos que
girá-lo de volta. Então, copiar colar esse
código está ficando confuso, vai se mover dessa maneira. Então, aqui vamos
girá-lo de volta. Então, definindo-o para 000 e
conectando a execução à direita, assim. Agora, ele deve funcionar
corretamente se eu compilar e, na verdade,
esqueci de adicionar um alvo aqui. Então, vamos copiar isso, colá-lo aqui assim. E você pode ver quando
você tem um erro,
ele escreve a seta aqui e diz
que você precisa de um alvo. Aqueles compilam e salvam. Assim mesmo. E agora vamos jogar e ver se eu me movo para a direita,
passar para a esquerda. Porque ele agora nossa animação
está funcionando perfeitamente. E agora estamos perdendo
a animação de salto, e faremos isso
na próxima lição.
28. Animações de pulos de jogadores: Vamos agora fazer a animação de
salto. Então, vamos voltar para
a base de jogadores. E aqui, no Event Graph. Aqui fizemos esse
movimento com a OIT, com a corrida à direita e o
que eles correm para a esquerda. O que realmente não
definimos o salto. E saltando ainda mais
se arrastarmos este chamado set movement
state novamente, então arrastando este aqui
para que o estado de movimento, possamos arrastá-lo duas vezes. Então, temos o salto
aqui e também temos a queda. Temos que verificar
se o jogador está pulando ou se o
jogador está caindo. É o mesmo. É a mesma animação
em Maple Story. Então, isso realmente não importa. Mas se você estiver criando
seu próprio jogo e você tem duas animações diferentes
para o salto e a dobra. Isso seria muito
bom saber. Então, novamente, assim como
antes aqui embaixo, na lógica de salto, você está verificando se o
jogador está caindo ou não. Então, temos que fazer o mesmo aqui. Se voltarmos
ao Event Graph, temos que fazer o mesmo aqui. Então, antes de irmos, vou segurar Alt e
clicar aqui para desconectar isso. Vou mover isso
um pouco mais longe porque agora
podemos adicionar o salto. Então, vou pegar o movimento do
personagem e verificar se o jogador está caindo. Então estamos recebendo, se eu puder
achar que aqui está caindo,
recebendo este. E vamos criar um
ramo como esse. Agora, estamos verificando se
o jogador está caindo e se o jogador está
caindo, estamos pulando. Então, estamos no ar. E se o jogador não
está caindo, o
que significa que o jogador
está subterrâneo, então não estamos no salto. Nós só vamos executar esse código em execução
como antes. Mas aqui estamos pulando
se estivermos no ar. Então agora temos que verificar. O jogador está pulando ou
o jogador está caindo? Qual deles é? Podemos fazer isso se obtivermos a
velocidade desses atores. Então, vou
clicar com o botão direito do mouse e obter a velocidade, como aqui. E estamos recebendo a velocidade. E agora isso é um vetor. Agora você pode quebrar esse vetor. Mas porque o que estou
interessado agora, se tivermos o jogador aqui, estou interessado em saber se o jogador está pulando ou caindo. E novamente, este é o z, a seta azul aqui é o z. no eixo z. Eu quero ver, está indo
na direção mais, o que significa que
o jogador está indo para cima ou é o
avião indo para baixo, que significa que o z está realmente
no valor negativo. Então, vou acabar com a base
do jogador, essa velocidade. Posso pegar esse vetor
e posso dizer pausa. Você pode quebrar esse vetor
no x, y e z. Lembre-se de um vetor, se eu
puder mostrar aqui, quando criamos uma variável
vetorial, um vetor
consiste em três números, assim como a localização
aqui, três números. Então, se eu voltar,
deixe-me excluir este novamente. Então, estamos dividindo esse
vetor no x, y e z porque estamos
interessados apenas no valor z. Quero verificar se
isso está indo para cima, que significa que está no plus, ou descendo, o que
significa que está no menos. Então, vou pegar
isso e dizer maior. Então, isso é maior que 0? E criar uma ramificação
novamente assim. Então, se for maior que 0, isso significa que o jogador está
pulando porque você está indo para cima se
não for maior que 0, então está no menos significa que
você está caindo. E se o jogador não
estiver caindo, você apenas executará esse código
normal. Ok, então deixe-me mover
isso um pouco mais perto agora. Agora temos essa
lógica de salto e sempre podemos, geralmente dedicar uma lição inteira para uma limpeza tudo isso, então não se preocupe com
isso se parecer um pouco confuso. Mas aqui podemos apenas
compilar e salvar. E agora eu quero
explicar para você. Na verdade, basta clicar em
Play e ver o que acontece. Então, se eu clicar em jogar e saltar, você pode ver que estou pulando. Está funcionando. Incrível. Ok, então o que está acontecendo é que
você está verificando aqui e
depois mova para a direita, para a esquerda. Antes de executar
essa animação de movimento, você está verificando se
o jogador está caindo. E se o jogador está caindo, significa
que você está pulando. Certo, tudo bem. Então, sim, você está pulando. É verdade. Você está caindo. O que então? Aqui você pega a velocidade
desse personagem e está quebrando esse vetor porque estamos
interessados apenas no valor z. Estamos verificando se o valor
z está acima de 0. Se for, você está pulando. Se a velocidade estiver abaixo de 0, o que significa que você está descendo, isso significa que você está caindo. Ok, então o que acontece aqui? Você está executando
este evento e define para pular essas informações, você está sentado aqui, vamos
passar por esse evento porque
este é, em última análise, o
evento que você está executando. Definir movimentos Estados que você lembra que está
chamando esse evento. Então, ele está
passando por esse evento. Ele está colocando essas informações que saltam que
você definiu aqui, percorrendo o código. Ele está passando pelo servidor. O servidor está configurando
essa variável. E lembre-se, definimos essa
variável para uma notificação de representante. E novamente, se você não se
lembra de uma notificação, porque agora
você é o servidor e o servidor define a variável. Como o cliente
saberia o que
é essa variável se você não fizer
nada porque lembre-se, você está no servidor
e o cliente não pode
realmente ver o que você está configurando, a menos que você estão replicando
essa inflamação. Portanto, você está replicando as informações de volta para o
cliente para que o cliente possa ver o valor
dessa variável definida. Portanto, seja qual for a notificação,
ele notifica todos os clientes para
o que você configurou ele notifica todos os clientes para
o que você configurou e faz isso através desta função
Ribner OnReceive. Portanto, um representante notifica sempre que você definir uma variável para rip notificar, ele cria essa função de desembrulho. E dentro daqui,
seja lá o que você codificar aqui, todos os clientes
verão essa mudança. É por isso que estamos definindo
o flip book aqui. Porque queremos que
todos os clientes vejam que estou no
meu flip book ocioso. Quero que todos os
clientes vejam que estou no meu flip
book e assim por diante. Então você está enviando todas essas
informações para o cliente. Agora, as informações
foram definidas aqui, é pular, passou pelo servidor
aqui, definir a variável, e ela vai entrar na função unwrap
porque toda vez que você alterar uma variável de notificação de
repetição, ele vai executar
a função unwrap. E como você define esse
valor agora para saltar, ele só vai passar por
esse pino de execução de salto. Vai
ignorar tudo isso porque só vê que
agora você o definiu para pular. Então, ele vai executar
esse pino de execução, e vai
definir o flip book desse brilho para saltar. Portanto, quando você
clica no espaço e pula, ele definirá seu
flip book para pular. E para testá-lo. Você pode vê-lo, funciona. Eu posso vê-lo no
cliente também. Para garantir que ele funcione. Também preciso correr
como cliente e pular como cliente para ver se eu como
cliente e posso pular. Porque lembre-se,
o servidor verifica o que você está
fazendo como cliente. Então agora você pode ver que eu
posso pular como cliente. E também se eu levar isso
um pouco para baixo, você pode ver que o servidor
pode fazer tudo isso. Claro, o servidor, novamente, o servidor tem
autoridade para fazer qualquer coisa no jogo porque
o
servidor é o verdadeiro jogo, o servidor verifica todos os
clientes quanto ao que eles estão fazendo e o servidor
é capaz de fazer qualquer coisa. Então, é mais parecido com o cliente. Temos que verificar com
o cliente também. Se o cliente
puder fazer tudo isso e o cliente puder
fazer tudo isso também. Então, está funcionando perfeitamente.
29. Entrada de variável personalizada: Agora eu quero mostrar algumas entradas variáveis
personalizadas. Então, se voltarmos para
a base do jogador, e aqui dentro da sua função de movimento
não lido,
você pode ver aqui antes de
definir agora o inativo flip book, definimos o flip book de corrida, definimos o salto flip
book e assim por diante. Mas e se formos
aqui para olhar, agora? Se gerarmos,
olhe para o servidor. Então agora podemos ver que estamos
respondendo como czarina. E isto é, isso é ótimo. Mas e se gerássemos Luke? Luke realmente não
tem esse flip book. Olhe. Essa garota não é virada? Temos que fazer outro
flip book para Luke. E como usamos o flip book de
Luke em vez
de Serena aqui? E é por isso que quase
nunca codificamos coisas em jogos. Normalmente eu odeio
codificação assim. Isso é chamado de codificação
rígida ou apenas selecione uma variável. Em vez disso, basta clicar com o botão direito aqui e promover isso para uma variável. E agora você pode chamar isso de variável, algo
por exemplo, eu posso chamá-lo de
espaço ocioso, flip, não tão bom como esse. Vou virar o livro. Agora eu tenho isso
transformado em uma variável. Agora, se eu compilar, e você pode ver se eu
clico nessa variável, o padrão agora
é esse flip book, porque eu selecionei aqui, selecionamos
o flip book run. Agora, se eu clicar com o botão direito do mouse e
promover uma variável, ela vai
defini-la como padrão. Agora podemos remover isso
como padrão para este. Agora, vamos apenas
clicar em Limpar. Então, clicando no ocioso, vire uma variável
que você acabou de fazer. Você também pode vê-lo
transformado em um tipo flip book em papel. Você pode clicar aqui,
eu clico em Limpar. Agora, o padrão não
é nada. Certo? Então, a partir daqui, como
sabemos que flip book correr
para Serena e como sabemos
qual deles correr para o Luke? Agora, desde que você
transformou em uma variável. E lembre-se que estamos
dentro do baixo do jogador. baixo jogador é o pai para o loop for e para Serena. Então, esses são os pais. Todas as variáveis que você
fizer dentro
do pai também
aparecerão nas crianças. Então, se eu clicar na Tsarina primeiro, e se eu for para os
padrões da classe aqui à direita, você pode ver que eu tenho tanto
o estado do movimento quanto o flip book ocioso
porque na base de jogadores, temos os dois
movimentos de variáveis, estado e o flip book ocioso. Então aqui para Serena, por exemplo, posso escolher a animação ociosa
para o flip book ocioso. Mas se eu voltar para o Luke agora, e eu abri o editor de
blueprint completo para Luke. Se eu for para os padrões da classe, posso escolher outro flip books
ociosos. Neste momento eu realmente não, nós não importamos as animações de
aparência ainda. Mas posso selecionar uma animação ociosa
personalizada. E aqui eu poderia selecionar o livro inativo do
Luke
se eu o tiver feito. Então, em vez de codificar as variáveis de codificação aqui, geralmente
faço isso
em uma variável. E agora você pode definir essas animações constantemente
dependendo se você tiver, digamos que você tenha dez
personagens agora podemos clicar em todos os dez personagens e
defini-los como um flip
book personalizado aqui para o ocioso, você pode voltar novamente
e clicar com o botão direito aqui e promover isso para uma
variável para o salto. E então você pode definir
o livro de flip de salto para cada um dos personagens. Assim, podemos ver se eu clicar com o botão direito do mouse em
todos esses,
promove uma variável. E se eu clicar com o botão direito
do mouse aqui, se eu apenas promover todos eles para uma variável, você pode ver que eu recebo muitas
variáveis e você pode economizar espaço de todas essas variáveis
usando uma estrutura. É sobre isso que vamos
falar na próxima lição, vamos falar
sobre estruturas. Então, vou
excluí-los novamente aqui. Se eu apenas excluí-los, não quero fazer
muitas variáveis nessas animações. É chamado que você pode
criar uma variável com eles, mas você pode realmente
usar algo chamado estrutura que
é mais eficiente. E vou te mostrar como
fazer uma na próxima lição.
30. Estruturas: Mega estrutura. Agora vamos clicar com o botão direito do mouse e
criar uma nova pasta. Vou fazer uma
pasta chamada structs. Estas são para as estruturas
e clicando duas vezes nela e em vez de aqui, você pode
clicar com o botão direito do mouse dentro de blueprints. Você pode fazer com que este seja
chamado de estrutura. Então, criando isso,
mostrarei o que é isso. Vamos começar com o
STS, o prefixo. E para este, essa
estrutura vai conter todas as variáveis
para os jogadores. Vou
chamá-lo de informações do jogador. Então, todas as informações
sobre esse jogador. Agora, dentro da estrutura, você pode adicionar
quantas variáveis quiser. Por exemplo, o primeiro, vamos chamá-lo de animação ociosa. Sem espaço.
Na verdade, vou chamá-lo assim. Vou clicar em nova
variável e vou fazer uma
para
a animação de execução. E vamos trabalhar
com isso por enquanto. Então, aqui está a direita. Você pode alterar o tipo de
animação. E para
as animações, lembre-se, estamos trabalhando com 2D, então são flip books em papel. E se eu puder encontrá-lo aqui, se você apenas escrever papel, este livro flip de papel e
selecionar a referência do objeto. A mesma coisa com este
livro flip de papel. Agora, quando você cria
uma nova variável, ela a definirá automaticamente para pavimentar um flip book
porque isso é o que você selecionou anteriormente,
a animação de salto. Vamos adicionar a
animação de outono também. Ok, então temos
essas animações agora. Então antes, em vez de clicar com o botão direito do mouse e promover
todos eles para uma variável. E você vê aqui que tínhamos
muitas variáveis aqui em baixo. Você pode economizar
espaço se colocar todas essas variáveis
dentro de uma estrutura. Agora, a estrutura que podemos
usar é chamada de informação do jogador. Então, mais tarde, podemos usá-lo para algo como o nome do
jogador também. Se você tiver uma miniatura
para o jogador, podemos colocar a imagem aqui. Se você tiver alguns efeitos sonoros de
salto, também
podemos criar uma variável
para os efeitos sonoros. Portanto, todas as informações
do jogador estão dentro dessa estrutura. Agora, para usar uma estrutura, você pode voltar para
a base de jogadores. E dentro daqui você pode criar uma nova variável e
você pode chamá-la, vamos chamá-la de informações do jogador. Agora vamos mudar esse
tipo para o que você chama aqui
é a informação do jogador. Portanto, não são informações do jogador
e você pode vê-las aqui. Essa é a estrutura. Se você for Compilar e Salvar, agora
você pode arrastar
essa estrutura aqui, clique em Obter informações. E você pode
arrastar dessa estrutura. E o que geralmente, geralmente fazer
é clicar na estrutura de quebra. Ao quebrar essa estrutura, você pode ver todas as variáveis que você
adicionou à estrutura. E como uma coisa muito, muito legal, agora que você
tem essa estrutura adicionada, lembre-se quando você adiciona variáveis, agora deixe-me excluir este
flip book por enquanto, o flip book ocioso
que fizemos anteriormente aqui em cima, vou excluí-lo. Então agora temos isso apenas. Então agora o que você pode fazer, coisas
muito legais é que agora você pode
conectá-los ao ocioso. Então este foi o ídolo aqui, e esta é a animação de corrida. Então eu vou ligar a
corrida aqui, a corrida aqui. Esta é a animação de salto aqui. E a animação de outono
é a mesma que o salto, mas podemos simplesmente conectá-la aqui. Certo? Então agora eu posso ver que você tem
todas essas variáveis em uma estrutura e
parece muito melhor agora. E assim como o que eu disse
antes, você pode, quando você adicionar uma variável
à classe pai, a classe filho
também a herdará. Então, se você for para Serena agora, e você pode
clicar em padrões de classe, poderá ver essa infraestrutura de
jogador. E se você clicar nele, você pode ver todas essas
variáveis e você pode defini-las para qualquer flip book que
você deseja adicionar. Então, para Luke,
também podemos fazer o mesmo
sempre que adicionarmos loops, animações, podemos adicionar livros de papel de
Luke aqui também. Então, para fazê-lo funcionar, vamos
voltar para Serena e você pode clicar em ocioso aqui
para animação ociosa. Para toda a animação de execução, você pode selecionar executar, o salto, você pode selecionar Java. E para a queda, é o
mesmo que
esse salto como este. Então Compile e Save,
salve tudo. Vamos experimentá-lo.
Vamos clicar em Play. E agora, quando corremos, você pode ver todas
as animações estão funcionando e estamos
usando agora essa ruptura.
31. Como finalizar o movimento do personagem: Então, como a última coisa, vamos
finalizar o movimento para o jogador e seguir em frente. A partir daqui, vamos voltar para
o jogador, a base de jogadores. E o que eu quero fazer é apenas editar o movimento do personagem. Então, clicando nos movimentos dos
personagens, vamos definir a escala, escala de
gravidade para um. Então, agora, quando pulei, acho que meus personagens voam
um pouco alto demais. Então, é como se a gravidade
não fosse alta o suficiente. Então, vou aumentar
a escala de gravidade
aqui no
componente de movimento para 1,9. Lembre-se no
espaço pleural, quando você o mudar,
ele também se aplicará para Serena e para Luke porque eles são filhos
da base de jogadores. Então aqui na escala de cinza, 1,9 e S para a velocidade de movimento para
Maple Story, eu testei. Eu estava jogando o jogo
e penso em algum lugar cerca de 155 na velocidade de caminhada. E você pode ver se
eu clico em Play, agora estamos trabalhando muito mais devagar. E é mais como Maple Story. Essa é a velocidade que você
estará correndo com ele. Então, se eu aumentar,
você pode vê-lo aqui. Então isso é mais
como Maple Story, o salto, mas acho que devemos
pular um pouco mais alto. Então, vou voltar aos movimentos dos personagens da base
do jogador. E aqui embaixo no
salto Z Velocity, vou enviá-lo,
defini-lo para 500 em vez disso. Ok, então vamos compilar e salvar. E acho que é
isso para o movimento. Então, se eu clicar em Play e ver que este é o movimento
e ele pode pular. Então, agora, estamos
sendo bloqueados pelo personagem também. Temos
que remover isso para que você possa ver que está
incomodando nosso personagem, empurrado, nosso personagem bec. Mas, na verdade, vamos
voltar para a base do jogador e clicar nos componentes da
cápsula. Então isso está fazendo a colisão. E vamos rolar para baixo e você pode ver este
chamado colisão. Vamos clicar nessa
predefinição de colisão para ver o que está acontecendo, e isso é toda
a colisão. Então agora vamos realmente clicar aqui e clicar no traje
porque queremos editar isso. Então agora podemos ver as
pontes. Isso é o que é. Este é um peão. As lagoas
estão bloqueando umas às outras. E não queremos isso. Queremos que os pontos se
ignorem uns aos outros por enquanto, vamos apenas ignorar um ao outro. Vamos compilar e
vamos ver se esse trabalho. Então clique em Jogar
e correr por aí. Vejo que não consigo me
bloquear agora. Então, se eu pegar esse cliente, então isso está consertado agora, ok? Portanto, as lagoas não podem mais bloquear
umas às outras. Então é isso que queremos. E você pode ver
que tudo está funcionando bem. O salto, acho que estou
pulando alto o suficiente. Mas, novamente, este é o seu jogo. Se você quiser correr mais rápido, se quiser, a
câmera estará mais próxima. Lembre-se de que você poderia
editar a câmera se você fosse para a czarina e,
na verdade, adicionamos errado. Posso ver que adicionei a
câmera dentro da Tsarina, mas precisamos adicionar
na base de jogadores porque
Luke também precisa da câmera. Portanto, esta é uma solução rápida. Deixe-me excluir este braço de primavera. Exclua a câmera. Deixe-me ir
para a base de jogadores em vez disso. Clique na cápsula, adicione o braço da mola. Na câmera, assim, basta procurar a câmera. Então agora temos o
braço da mola e temos a câmera. E, novamente, clique na câmera, vá até aqui, mude-a
para visualização ortográfica. E lembre-se, você
pode mudar o quão perto e longe a câmera está
alterando esse valor. E foi no 130
para assim. Então agora Luke e
Tsarina têm essa câmera. Então, antes de terminarmos isso, vamos passar pelo código rapidamente porque eu quero
limpar as coisas para que não seja uma bagunça real. Então, apenas verificando aqui, isso é o que parece. E para limpar o código, você também pode
clicar duas vezes nesses pinos. Ao clicar duas vezes,
você criará esse nó de redirecionamento, redirecionará o pino. E você pode clicar duas vezes
aqui e fazer com que pareça um pouco mais limpo. E eu acho que isso está
bem e olhando aqui, talvez apenas, apenas
colocá-lo aqui em cima, assim. Outro truque é que você pode selecionar o que quiser
aqui e clicar em Fila. Isso endireitará todas essas notas que
você selecionou. Então, selecionando-os, Clicar em Q os
endireitará. Então, temos o salto e temos a queda aqui ao lado do outro. E vamos mover isso um
pouco mais longe. E também temos
a animação de caminhada. Eu acho que isso é, isso é bom. Agora, o que podemos fazer, eu
posso mover isso para baixo, e posso mover
isso para baixo também. Novamente, você pode
selecionar todos esses, clicar na sugestão para
endireitá-los assim. E você também pode potencialmente
fazê-lo com este. Ou acho que talvez assim e podemos
mover isso mais para baixo. Assim, isso provavelmente
parece muito melhor. E podemos fazer isso
mais longe para que eles
não estejam agrupados
uns sobre os outros assim. E talvez você possa mover isso
também em cima daqui. Como você também pode
criar neves de redirecionamento para pinos de execução,
se desejar. Mas acho que vou deixar que
seja assim, na verdade. Vou colocá-lo mais perto. Acho que isso parece um
pouco estranho como aqui. Ok, então agora
corrigimos isso. E outra coisa é que você pode passar o
mouse em todos esses nós. Você pode clicar em ver
para criar um comentário. Então clique em ver. Você pode chamar isso de movimento de
um jogador. Ela também pode ser mais
específica do que você quer dizer. Então, movimento Claire, vou
chamá-lo algo curto
apenas para o curso que os vídeos não
fiquem muito longos. movimento lento ERA, na
verdade, não é um jogo 3D, então à direita e à esquerda, por exemplo,
algo assim. E para este, esses também são o estágio de
movimento, para que possamos
incluí-los no comentário. Vou clicar e arrastar
o comentário para baixo assim. E agora aqui em baixo
temos o salto. Vou clicar
em ver e dizer salto. E coloque-o aqui em baixo. Ok, então está um pouco
mais organizado agora. E você também pode ir para
a função unwrap. Não se esqueça de que você
também pode acessar as funções e organizar essas funções. Então este parece um
pouco confuso por causa
dessas linhas, mas temos que
realmente fazer muito sobre isso. Portanto, não podemos realmente criar
mais estruturas como essa. Então eu acho que isso parece bom, mas você sempre pode
tentar
separá-los um pouco mais
longe um do outro. Tente colocá-los como embaixo
um do outro, assim. Ok, acho que isso
parece bom por enquanto. Você sempre pode, se
quiser tentar, você pode criar notas de redirecionamento. Se você quiser. Ouça um
clique duplo, tentei, eu posso até fazer
redirecionar as notas se você quiser tentar limpá-lo
o máximo possível. Mas acho que vou deixar que esteja aqui por enquanto sabemos o
que está fazendo agora. Você também pode fazer um
comentário se quiser. E vamos compilar e salvar. E agora tudo está funcionando. E clicando em jogar aqui. E está ficando escuro e sei por que esqueci de
girar a câmera. Então, voltando para a base de jogadores aqui primeiro na primavera,
eu sou novamente removido. Eles fazem testes de colisão. E nas viewports, vamos clicar no braço da mola. Vamos clicar em E para girar. E vamos girar esses
90 menos 90 graus, então está na frente, para que
possamos ver o personagem. E agora vamos clicar em Play. E agora tudo está
funcionando corretamente. Podemos pular, o
movimento está funcionando. E, novamente, você tem
que verificar isso no cliente também. Então, se eu fizer isso menor, você tem
que verificar com o cliente. E o cliente pode
pular e correr
também para que você possa
jogar juntos agora. E agora tudo está funcionando e vamos passar
para a próxima lição.
32. Como criar o segundo personagem: Agora estamos prontos para criar
Luke como o personagem. Agora eu tenho isso
importante para você dentro dos materiais do seu
curso. Novamente, se você for ao material do
seu curso, personagens Luke e
dentro de Luke, eu quero que você importe estes aqui. Então, vamos para
personagens de ativos aqui. Vamos criar uma nova pasta
e chamá-la de Luke. Agora vamos importar o que
estiver dentro dessa pasta. E você provavelmente terá
mais animações aqui. Vou adicionar
animações à medida que vou
junto com este curso. Então, arraste-os para o navegador de conteúdo e
você os importou. Como um exercício, o que
eu quero que você faça, tente fazer todo esse processo sozinho, porque esse processo é como o que temos feito anteriormente nas lições
anteriores. Então tente aplicar configurações 2D de
papel, tente extrair os sprites, tente fazer flip
books você mesmo. Tente importá-los para o personagem de blueprint
Luke, caractere de papel que criamos. E então tente fazer isso
sozinho e veja se você tem sucesso. E se você ainda
tiver dificuldade, vamos juntos aqui
e acompanhe, mas tente fazer isso sozinho. É uma
prática muito boa tentar isso. Isso não machuca ninguém. Você pode voltar aqui
e faremos isso juntos. Então, se você não
tem certeza de como fazer, ainda está, podemos
tentar fazer isso juntos. Então, novamente, vou
clicar em todos eles. Clique com o botão direito do mouse em produção,
aplique papel às configurações
e, em seguida, passe por cada uma delas. Então, o ocioso, vou
extrair os sprites. Vou ir um
pouco mais rápido porque temos feito isso
anteriormente agora vamos Tsarina. Então grelha subindo o
180 por 180 para extrair os
sprites assim. E novamente, vou
renomeá-los. Tudo bem, então eu
extraí todos eles em sprites aqui. E também
criei flip books. Portanto, lembre-se de que você poderia selecionar,
executar, por exemplo, clicar com o botão direito do mouse
e criar flip book. Então eu criei esses
três flip books e agora tenho que mudar os
quadros por segundo. E para a corrida ou
para o salto, vamos fazer apenas um
quadro por segundo. E para o ocioso, eram dois quadros por segundo. E para a corrida,
acredito que sejam seis. Só estou verificando
com a Tsarina aqui. Sim, seis quadros por segundo. Então, estamos fazendo a mesma coisa. Seis quadros por segundo como este. Agora, vamos fazer uma
nova pasta aqui. Então clique com o botão direito do mouse, crie uma nova
pasta chamada Texturas. E eu vou levar
todos esses aqui, tanto essas brights quanto as
texturas dentro daqui, só
temos os flip books. A próxima coisa que podemos fazer é ir para o jogador de blueprints, Luke. Agora vamos
adicionar o flip book. Então abra o editor de blueprint completo. E vamos para as viewports. E dentro daqui, clicando
nos sprites e depois
adicionando uma olhada aqui. Então, a animação ociosa aqui. Temos novamente que ajustar esta cápsula para que ela
não colida com nossos, todos os nossos azulejos. Vou me referir de volta à Serena para ver o que era dela. Ou talvez uma
coisa melhor que possamos fazer é fazê-lo na base de jogadores. Por isso, aplica-se a
todos os jogadores se você tiver mais jogadores. Então, 33 por 16, vou voltar ao padrão e apenas me lembrar
dos números 3316. Então eu vou fazer isso
dentro da base de jogadores, então não precisamos
fazer isso o tempo todo. Talvez adicionemos muito mais
personagens mais tarde. Então, clicando na
cápsula, escrevendo 33. E nós temos que mudar esse
número aqui, na verdade primeiro que isso
vai permitir que você. Então, 16 por 33. E quando compilamos esses projetos infantis
estarão todos nesse tamanho. Tudo bem, então isso deve ser feito. E lembre-se na base do jogador dentro da nossa função de desembrulho, adicionamos essa estrutura. Então lembre-se que você tem que
dar
uma olhada em quais animações
o personagem tem. E lembre-se, quando você fizer, quando você faz variáveis dentro de uma classe de blueprint pai, elas aparecerão
no padrão filho aqui em padrões de classe. Então aqui você tem que
selecionar exatamente como Serena, onde selecionamos
essas animações. Você tem que fazer isso
também, ou Luke. Então agora você pode ver
como isso é legal. Cada personagem podemos
ter nosso personalizado, ídolo, nossa corrida personalizada, nosso salto personalizado e nossa queda personalizada. Mais adiante. Vamos fazer isso. E para o salto, temos um
salto e para a queda também
usamos a mesma coisa aqui. Certo. Então, acho que não estamos
perdendo nada. Vamos tentar jogar e
ver o que acontece. E vamos primeiro às configurações do
mundo. Lembre-se de que selecionamos Serena como a classe
padrão
agora porque ainda não temos uma
tela de seleção de caracteres. Então, vamos clicar
aqui e alterá-lo para olhar para
que você possa testá-lo. E vamos clicar em Play. Agora os entrevistados olham e você pode ver que Luke está funcionando também. Tudo está funcionando bem. Então, nós dois olhamos agora e
temos a Csarina no jogo.
33. Como adicionar efeito de som de salto: Tudo bem, então, para o efeito de
salto, novamente, nos materiais do curso que eu
importei dentro do áudio. Eu importei
este chamado SF6 jumps. Então, temos o efeito de salto
e vamos criar uma nova pasta. Vou clicar
nesta pasta de conteúdo. E aqui, vamos fazer
um novo chamado áudio. E dentro daqui, vamos voltar para o áudio e vamos arrastá-lo para esta pasta. E podemos tocá-lo e
ver se é muito alto. Acho que o volume é bom. Então aqui, quando você importar um som, vamos
realmente tentar codificar essa coisa e eu
mostrarei como
fazer isso no multiplayer. Então, em última análise, o que você
quer fazer aqui no plano, Vamos voltar para o
jogador, a base de jogadores. Agora, se voltarmos
ao Event Graph, talvez você esteja
tentado a fazer isso. Então aqui para o salto. Agora, vou
fazer isso da maneira errada que você possa aprender com isso. Então, aqui no salto,
no single player, estou comparando single player e multi-player para que você possa
ver as boas práticas. Então, no single player,
o que você quer ele faça é como
aqui no salto. Quando eu apresentar salto, obviamente, faremos esse efeito
sonoro aqui, mas isso é errado
no multiplayer. E vou te mostrar o porquê aqui. Para fazer um som,
podemos dizer tocar som. E você pode tocar
som em um local ou reproduzir som para d. Então, se você quiser que
as pessoas ouçam o som, então qual é a diferença se você tocar um som em um local. Então, se você é um jogador, está de pé aqui
para este lado e salta, o som será ouvido
deste lado aqui. Então, se um jogador estiver parado aqui e aqui está o seu salto aqui, ele ouvirá o som
vindo desta área aqui. Mas se você reproduzir som 2D, então se você escolher o som de atraso 2D, ele não ficará em
um determinado local, mas será reproduzido
como um efeito 2D. Normalmente, usamos isso
como elementos de interface do usuário. E se você quiser que um som seja ouvido em um
determinado local, usamos o
som de reprodução no local. Tudo depende se você quiser que
as pessoas o ouçam pulando. E digamos que
queremos fazer isso. Então, em última análise, você quer que ele
reproduza som em um local. Você deseja selecionar o som. E em vez de selecionar
a onda sonora, vamos voltar
aqui para o áudio. Vamos clicar com o botão direito do mouse. E vamos criar uma fila. E vamos chamá-lo de C
para sinalização sonora e pular. Você pode clicar duas vezes
nele agora para abri-lo. E isso é um sinal sonoro, então você pode clicar
em Reproduzir aqui. E ele pode ouvir o som. Uma coisa muito legal é que se
você quiser variação aqui, você pode arrastar disso. Você pode ver que essas são as notas
sonoras que você pode usar. Você pode arrastar aqui
e dizer modulador. Você também pode ver
o modulador aqui. Então, clicar no modulador
e o que isso faz é que ele muda aqui o som
toda vez que é reproduzido. Então, escolhemos o tom, mínimo e o máximo aqui. Então, por exemplo, 0,9 a 1,1. E toda vez que você
clicar em Jogar agora, ele mudará
o tom do som para que soe como se fosse um som
diferente a cada vez. Então você pode ver que é um pouco de uma variação que você
pode fazer às vezes. Mas eu quero que
o som seja o mesmo, então vou
excluí-lo e fazer isso. Então eu acho que isso está bom por enquanto. E vamos fechar esse sinal de
som para baixo. Então aqui se desenrola no local. Vamos selecionar nossa dica de som. E qual é a localização? E é exatamente aí que
o personagem está. Então, vamos clicar com o botão direito do mouse e dizer que obtenha a localização do
ator assim
e conecte-se aqui. Então, estamos recebendo esse local de
atriz onde quer que você esteja e você está
tocando o som lá. Ok, então você está
tentando fazer isso, e então você clica em jogar e
pular aqui. Funciona. E esta é a maneira
errada de fazer isso. Porque lembre-se de que você está
no multiplayer agora. Então, sempre que você fizer isso, os outros não
vão ouvir. Portanto, lembre-se de que temos esse relacionamento com servidor
e cliente. Então você tem isso como servidor e tem
isso como cliente. E você quer
tocar o som e depois lançá-lo para
todos os clientes. Então, o servidor coloca o som e
o lança para o cliente. Então, vamos voltar aqui e de novo, assim como o que eu
disse antes, precisamos verificar tudo com
o servidor para que os
clientes não trapaceem. O servidor é o verdadeiro jogo. O servidor tem autoridade para fazer qualquer coisa
dentro deste jogo. Portanto, cada código que você faz
precisa ser verificado
pelo servidor e depois
replicá-lo para os clientes. Então, vamos ver um exemplo disso. Vamos voltar para o jogador. Vamos apenas excluir este. Então talvez você
também esteja tentado a dizer, ok, então antes de fazermos
esse movimento aqui, e passamos
pelos estados de movimento, então esse estado de movimento
passou pelo servidor. E o servidor definiu
essa variável. E ele executará uma função
on-ramp porque lembre-se que essa variável foi
replicada como uma notificação de representante. Portanto, com o servidor
vai notificar todos
os clientes sobre a
mudança dessa variável. Dentro desta função de desembrulho. Tudo isso será
replicado para todos os clientes. Então talvez você esteja
tentando dizer, ok, tudo isso está sendo
replicado para os clientes. Assim, posso adicionar o
som do meu lugar aqui e ele será replicado
para todos os clientes. Então, temos um salto aqui. Temos o livro flip jump. E talvez você esteja
tentando adicionar o som de reprodução no local
aqui. Você pode fazer
isso e vai funcionar. Todos os clientes
vão ouvir você pular. Então, se você é o servidor, se você é o
cliente, tudo bem. Todos eles vão
ouvir você pular. Isso também está funcionando corretamente. Mas há um pequeno
erro e vou te ensinar que esta é a
última coisa no multiplayer, e temos algo
chamado multicast. Então, se eu for ao evento
e vou dizer
a diferença entre uma função on-ramp
e um multicast. Então, sabemos que temos
algo chamado multicast. Portanto, se você clicar no evento
do servidor, nós o configuramos para ser executado no servidor. Mas você também tem algo
chamado multicast. Então, vamos tentar criar
o código primeiro e posso explicá-lo para você mais
facilmente depois disso. Então, vamos mover essa lógica de
salto aqui. E aqui vou
fazer novos eventos personalizados. Vamos adicionar esse
evento personalizado e vamos chamá-lo de MC para multicast. E vou
apenas chamá-lo de salto porque queremos fazer
o efeito sonoro de salto. Certo? Agora você pode clicar nesta replicação e
selecionar multicast e selecionar confiável. E aqui, vamos adicionar este chamado reproduzir um som no local. Vamos agora para esse som em vez de codificá-lo assim. Lembre-se de que adicionamos uma estrutura. Então, basicamente, a estrutura contém todas as informações
do jogador, para que possamos até adicionar
sons aqui. Então, nesta variável aqui,
posso clicar em Adicionar variável e chamá-la de um salto como efeitos
para o efeito de som de salto. E vamos adicionar um sinal sonoro,
porque, em última análise, isso foi
um sinal sonoro que criamos. Portanto, é um sinal sonoro. Vamos procurar por sinalização sonora. E está aqui, referência de objeto. Ok, então agora temos
um efeito sonoro de salto e podemos usar isso
da nossa estrutura. Então, novamente, você pode voltar para, vamos voltar para o
jogador. Para Luke. Desde que adicionamos isso, cada personagem pode ter seu próprio efeito sonoro personalizado, mas não temos
isso na Maple Story. Então, vamos adicionar esse efeito de
salto, ou Luke. Para Serena, vou
adicionar o mesmo efeito de salto
ou efeito sonoro aqui. Ok, então nós temos esses
adicionados agora na estrutura. E vamos voltar
para a base de jogadores. E agora eu quero
explicar a vocês o que é
um multicast
antes de continuarmos. Portanto, não foi errado
fazer isso aqui. Então, o servidor definiu essa
variável aqui e você volta para
a função unwrap e seguida, você adiciona o efeito
sonoro aqui. Isso funcionará como se os
clientes mais velhos ouvirão você pular. O servidor ouvirá você pular. Então isso funcionará. No entanto, a
diferença está entre uma função descompactada
aqui e a multicast. O multicast aqui,
faz a mesma coisa. Então, o multicast, você
pode imaginar como
se custasse todas as informações de
volta para o cliente. Portanto, as informações vão para o servidor e o
servidor define uma variável. E então você pode executar
um multicast para custar essas informações de volta
a todos os clientes para
que os clientes saibam
o que está acontecendo. Então aqui você pode
executar o multicast. Então, vamos clicar aqui e
adicionar um salto DMC aqui. E a
coisa mais importante a saber aqui é os eventos
multicast só podem
ser executados pelo servidor. Você não pode executar isso aqui, por exemplo, isso
não vai funcionar. Lembre-se, ainda estamos
em declínio a saber. Novamente, se você
quiser saber se você está atualmente no cliente
ou no servidor, você pode imprimir uma string simplesmente. Portanto, isso é muito básico
imprimir uma string. E whoops, eu arrasto
isso por engano. E aqui, vamos clicar em Play. Agora, agora você pode ver que tanto o servidor quanto o
cliente estão dizendo baixo. Então eu sei que não estou
apenas no servidor, mas também estou no cliente, então estou no servidor e
no cliente neste evento. Mas se eu imprimir a
string aqui, e como estamos executando
esse evento no servidor, é apenas o servidor
que vai dizer olá. Então eu imprimo string é muito útil para saber onde você realmente
está no momento. E um multicast só pode
ser executado pelo servidor. Você não pode executar um
multicast no cliente. Isso não vai funcionar. E isso também está
dizendo aqui em cima. Servidor. Então, isso só
funcionará se
for o servidor do qual você
está executando. Então agora podemos multicast o efeito de som de salto para todos os clientes para que eles
possam ouvir que estou pulando. Então, qual é a diferença entre isso e a função unwrap? Porque eles estão fazendo
os dois a mesma coisa. Este também está
funcionando como quando você adiciona o efeito de som de salto
aqui também vai funcionar. Então, qual é
a diferença entre este e este? A diferença é que, se
você estiver longe, digamos que você tenha um
grande mapa mundial aberto. Se você está longe e está tocando um multicast, esta é a maneira correta de
fazer isso aqui pelo som. Porque
quando o jogador que está longe
se aproxima de você, ele não ouvirá mais
o som porque você talvez tenha
saltado há dez minutos. Então, mas se você fizer isso aqui
na função de desembrulho e o jogador estiver
longe quando você pular, tudo bem. O jogador não pode ouvi-lo. Mas se o jogador
chegar perto de você, como dez minutos depois, o jogador ouvirá o efeito sonoro mesmo
que você tenha saltado há dez minutos. função Unwrap
atualizará o player. Mesmo que você tenha feito
essa coisa como uma hora atrás ou duas horas atrás
ou por mais tempo que seja atrás. E digamos que um jogador
ainda não tenha se conectado ao seu servidor e você pula, o jogador se conecta
dez minutos depois. Então aquele jogador que está
se conectando pode ouvir você pulando. Mesmo que você não esteja pulando, como se estivesse parado, mas você saltou para
dez minutos atrás, esse efeito sonoro de salto
será ouvido pelo player
conectado. E isso não está correto porque você saltou
para dez minutos atrás. Você não saltou agora. Isso acontece se você
adicioná-lo ao desembrulhado. Então, o que eu quero que você
tire disso é que a função unwrap é
usada para mudanças visuais. Então você pode ver aqui o flip
book em que estou, por exemplo, se estou correndo ou mensagens instantâneas, digamos dançar,
saltar, o que quer que seja. Todos os efeitos visuais
são feitos no desembrulho. Então, digamos que eu tenha
um semáforo e ele está mudando de vermelho para verde ou vermelho para amarelo para
verde, esse semáforo. Você quer adicionar. O efeito visual muda
dentro do desembrulhado. Porque se um jogador se conectar
cinco minutos depois, e digamos que você seja uma luz, leva cinco minutos
para mudar de cor. Digamos que vá
de vermelho para amarelo. jogador que
se conecta ao servidor pode ver que sua
luz agora está amarela. Mas se você adicionar
alterações visuais aqui, o multicast, essa cor amarela ainda
parecerá vermelho para o player
conectado. Porque o multicast só
atualiza para jogadores conectados. Ele só atualiza para jogadores
que estão perto de você. Então, se um jogador
estiver longe e a luz mudar
de vermelho para amarelo, esse jogador que está
longe se aproxima de você agora, e esse jogador
ainda verá a luz sendo leia porque você está executando
isso por meio de um multicast. Isso só é atualizado
para jogadores próximos a você e para jogadores
conectados ao servidor. Então, o que costumamos usar funções
não maduras para nossas mudanças visuais, porque isso deve ser atualizado visualmente
para jogadores que se conectam. Então, digamos que eu me
conecte dez minutos depois e dez meses depois, eu posso ver que você está no, digamos aqui
no estado de corrida, ou talvez você esteja segurando
uma arma diferente. Então, se tivermos mais
flip books aqui, mas eu não quero
ouvi-lo ou não
quero ouvir o efeito de salto que você fez há dez minutos, isso não faz nenhum sentido. Então, qualquer efeito sonoro,
qualquer efeito visual. Então, por exemplo, um efeito de
partícula, um efeito de fogo e assim por diante. Eu quero que todos eles
estejam no multicast. Esta é a
maneira correta de fazer isso. Todas as alterações visuais
são feitas no desembrulho. Então, aqui estamos
através do servidor, estamos executando o multicast. E, novamente, o multicast
só pode ser executado pelo servidor. E em vez de dar
o salto aqui, deixe-me conectá-lo aqui. Uma prática muito boa
no multijogador é executar essas variáveis todo o caminho de volta
aos eventos iniciais para
que funcionem corretamente. Então, arrastando esse som
e adicionando-o aqui, sustente aqui, então ele cria uma variável automaticamente para mim. Então, se eu clicar neste multicast, você poderá ver que ele cria
essa variável. E eu vou
chamá-lo aqui em vez de efeitos de salto de som S. E eu vou arrastar
esse local também, colocá-lo aqui e chamá-lo
talvez de localização do jogador. Então agora eu posso fazer o efeito
sonoro aqui. E lembre-se
pelo efeito sonoro, tínhamos nossas informações do jogador. Então, vamos arrastar nossa estrutura. E a partir daqui, digamos que quebre a caneta da estrutura para
que possamos ver as variáveis. Vou mover
isso um pouco que tenhamos mais espaço. Certo? Então, este aqui, vou clicar nesta
seta para ver minhas variáveis. Você pode arrastar desse efeito de som de
salto e ele reproduzirá
automaticamente o que você tiver. Insira aqui no
salto como efeitos para Serena e
quatro também. Então lembre-se de fazer isso. E voltando aqui. Agora, para aqueles que
você não está usando, você pode clicar aqui em
Ocultar pinos não conectados, e isso os esconderá para você. É um pouco mais
limpo para se trabalhar. E qual é a localização? Novamente, pega o jogador ou não pegue o
jogador, obtenha a localização do ator. E assim. Então, agora ele
vai funcionar corretamente. Então, agora que fizemos isso, vamos tentar compilar
e salvar tudo. E vamos clicar em Play
e ver se ele funciona. Tudo bem, então para completar isso, agora, em vez de
fazer isso aqui em cima, isso estará jogando constantemente porque agora isso é definido através
do estado de movimento, que coloca o tempo todo aqui. Então, em vez de fazer isso,
isso vai machucar seus ouvidos. Então, vamos pegar isso e vamos criar
um novo chamado servidor. Então, paletas personalizadas, salto do servidor. E isso vai ser executado
pelo servidor assim. E vamos nos conectar juntos. Portanto, o servidor
executará esses eventos multicast. E lembre-se que tínhamos
essa estrutura. Vamos tirá-lo e arrastar para fora disso e
dizer a estrutura de ruptura. Para que possamos ver os pinos. Aqui. Você pode clicar
nesta pequena seta. Vou mover isso um pouco para o outro lado para que possamos
ver o que está acontecendo. E agora posso arrastar esse salto como efeitos
para essa variável. E lembre-se, você tem que, na czarina nos padrões da
classe, você tem que adicionar o
efeito sonoro aqui para fazê-lo funcionar. Assim como para Luke, a classe usa como padrão o efeito
sonoro aqui. Apenas certifique-se de que eles sejam adicionados. Então, este também funciona. Para os pinos que você
não está mais usando, você pode clicar sobre este
e clicar em Ocultar pinos
não conectados. Isso será muito mais limpo. E a localização do jogador
novamente clique e arraste aqui e dizendo
obtém a localização do ator. Então, assim. Então agora você tem
este evento Jump, jump aqui. Agora você não está
executando esse evento em nenhum lugar. Então lembre-se que você não, você não tem muito
frio esse evento. Então phi e, na verdade,
antes de continuarmos, vamos clicar nisso. Replica confiável
antes de eu esquecer aqui, e apenas para garantir que
os outros corram perigo. Então, se eu clicar em Jogar agora, você pode ver que não
está fazendo um som. E isso é porque
nunca definimos isso. Nunca chamamos essa
função ou esse evento aqui. Então, para chamar esse evento, vamos chamá-lo
aqui no salto. Então agora podemos fazer isso. Então, salto no servidor. Então, agora, o que saltamos? Ele vai
passar pelo servidor e podemos derrubar isso aqui para que fique
mais organizado. Grupos. Vou arrastar
isso para baixo assim. Ok, então agora o que vai
acontecer é que eu vou
clicar em pular. O efeito de som de salto passará
pelo servidor. E então isso
vai passar. E, na verdade, eu gostaria de levar minhas variáveis
até aqui. Então, vou clicar em Control X para cortá-los e
colá-los aqui. E deixe-me
passar isso também, assim. Eu gosto de executá-los todo o caminho volta ao evento fonte aqui. Agora, podemos
selecionar nossas ações. Então, como, vamos conectar isso de
volta aqui, assim. Então agora isso vai
passar pelo servidor. O servidor vai verificar, você tem permissão para fazer isso? E se isso estiver correto, ele vai percorrer o multicast onde
custa as informações,
o efeito sonoro para
todos os clientes. E, em seguida, lembre-se, o multicast é para todos os clientes próximos de você já estão
conectados ao servidor. Para os jogadores que não
estão perto de você, eles não terão isso jogado mais tarde quando
chegarem perto de você. E para os jogadores desconectados, quando eles se conectam ao servidor, eles não ouvirão isso se você tiver feito isso há cinco minutos. Então, isso faz sentido. E, finalmente, os jogadores
que se aproximam de você, ou os jogadores que se conectam
dez minutos depois. Eles só verão
as mudanças aqui. E queremos que eles vejam isso. Queremos que eles vejam nosso livro
atualizado para virar. Tudo bem. Mas não queremos que eles ouçam um som que é reproduzido há
dez minutos. Então, isso é algo que
passamos por um multicast. Então, vamos clicar em compilar e apenas garantir que
tudo esteja correto. Vamos tentar clicar em Play
e ver o que acontece. E você pode ver que o
som está tocando bem. Tudo bem, vamos sair
deste jogo aqui. Vamos torná-lo um
pouco mais organizado. Então, para esse salto, vou incluir todos esses
nós aqui juntos. Porque agora tudo
isso está pulando. E para este aqui, vamos tornar isso
menor assim. Vamos compilar e vamos salvar tudo e vamos
seguir em frente com o curso.
34. Interface de Blueprint: Então, antes de passarmos
para a próxima seção, quero falar sobre Interfaces de
Blueprint. Interfaces de blueprint são usadas
para organizar seu projeto. E também é mais fácil
trabalhar quando você está falando sobre a
comunicação Blueprint. E o que quero dizer com a comunicação
Blueprint? O que quero dizer é às vezes aqui na
base de jogadores, por exemplo, se voltarmos aqui, às vezes dentro
da base de jogadores, você tem que usar algo dos modos
de jogo. Então, neste momento, não
fizemos nada
dentro daqui. E se eu for para o
modo de jogo e o abri, em algum momento estamos codificando
algo dentro daqui. Então, em algum momento
da base de jogadores, precisamos de algumas informações
armazenadas dentro do nosso modo de jogo. Essas informações que podemos acessar por algo chamado Comunicação
Blueprint. Então, esse ator de blueprint está se comunicando com
esse ator de blueprint. Então, esses dois projetos
estarão se comunicando juntos. E é aqui que entram as
Interfaces de Blueprint. Mas agora, não quero
falar muito sobre comunicação
Blueprint porque ainda não a
usamos. Mas vamos
classificar nossos eventos. Então, aqui na base de jogadores, o que fizemos anteriormente é
este estado de movimentos definido. Em vez de fazer
eventos personalizados como este, vamos seguir em frente e uma interface de
blueprint. Então, vamos clicar com o botão direito do mouse
aqui e vamos para blueprints e criar
uma Interface de Blueprint. Na verdade, preciso
criar uma pasta para, então vamos fazer uma pasta
chamada interfaces. E dentro daqui, deixe-me clicar com o botão direito do mouse em blueprints
e Interface de Blueprint. Normalmente eu começo com
int ou interface. E agora queremos fazer
um para a base de jogadores. Então eu costumo chamá-los de
nome do blueprint. Quero usá-los para. Quero usá-lo para
a base de jogadores. Vou abrir isso agora. E você pode ver que é basicamente
uma biblioteca de funções. Então, dentro daqui, no gráfico, você não pode realmente fazer nada. Você não pode arrastar isso. E você pode fazer qualquer coisa. Você pode ver
que você tem suas funções aqui para que você possa adicionar
uma nova função. E você pode ver os detalhes sobre essa função aqui. Então, basta começar, vamos criar este
chamado estado de movimentos definidos. Então, em vez de criá-lo
como um evento personalizado aqui, vamos para a interface
e vamos fazê-lo aqui definir estados de movimento como este, compilar e salvar tudo. Agora, para adicionar uma Interface de
Blueprint, você precisa ir para
esse blueprint, então vamos usá-lo e a base de jogadores indo
para as Configurações de Classe. E aqui você pode ver interfaces
implementadas. Vamos procurar por isso assim, e podemos escolher
a interface aqui. Agora vamos compilar e salvar. E agora
está dando um erro. E isso ocorre porque você
acabou de criar uma interface. Você pode vê-lo aqui, aquele que você
fez definir o estado de movimentos, e agora é porque
você tem dois deles, então está dando um erro. Vamos excluir este. Mas lembre-se aqui, se isso
não aparecer para você, lembre-se de voltar para a interface e
clicar em compilar. Muito, muito importante que você sempre compile seus projetos. Então, vamos até
a base de jogadores. Agora, vamos excluir esse
movimento definido Estados e compilar. E agora está
nos dando muito mais erros. E, na verdade, são esses porque temos que substituí-los. Mas não vamos nos preocupar com
essas flechas por enquanto. Agora, essa interface,
fizemos algum estado de movimento. Podemos chamar isso
clicando com o botão direito do mouse e dizendo que define estados de movimento. E agora podemos ver que temos esse evento é definir o estado de
movimentos. Então, se você clicar nele e
este ícone estiver no Pier, esse ícone significa que ele é
de uma Interface de Blueprint. Porque lembre-se
que fizemos isso dentro do estado de movimentos definidos aqui. Portanto, sempre que você adicionar a interface dentro
do seu blueprint, ela aparecerá aqui e você
poderá chamá-la como um evento. E você também pode ver aqui, não
podemos realmente arrastá-lo para fora. Então isso não funciona. Portanto, temos que clicar com o botão direito do mouse
e procurar o nome. O mais legal sobre interfaces
é que se você fizer uma nova, vamos chamá-la aleatória. Eu só queria te mostrar
quando é assim. E você volta ao
blueprint ou à base de jogadores, você pode ver esse evento
aleatório aqui. Se eu clicar com o botão direito do mouse e escrever
aleatoriamente
e encontrar os eventos, e você puder ver aqui,
evento aleatório aqui. Mas se eu, se eu colocar
uma saída aqui, então se eu clicar em aleatório
e adicionar uma variável aqui, então eu clico neste botão de adição e vamos apenas adicionar uma variável
aleatória aqui. Se eu compilar agora e salvar, e eu voltar para minha base de jogadores, agora
você pode ver que
não é mais amarelo. Então, se eu, se você adicionar uma
saída a um evento aqui, ela em uma função. Então, agora podemos realmente
clicar duas vezes este ano. E você pode ver que é
uma função, assim como quando você criou funções aqui em cima não
está pulando. Por exemplo,
criamos isso anteriormente. Você também pode criar funções dentro das interfaces
e usá-las. Então, quando você adiciona uma saída, duas funções dentro daqui, elas se tornarão funções. E se você não adicionar uma saída, eles se tornarão eventos. Muito, muito bom
lembrar disso. Os eventos são amarelos, as
funções são dessa cor, então vamos excluir essa aleatória. Nós realmente não precisamos disso por enquanto. Vamos compilar e salvar. E vamos voltar aqui e conectar esse estado de movimento definido. Agora nós tínhamos aqui o
movimento ficou. E assim como antes para
os eventos do cliente, não
podemos clicar e arrastar e adicionar a variável automaticamente. Então você pode ver aqui,
se eu clicar e arrastar, não
consigo adicioná-lo automaticamente, então eu tenho que fazer isso sozinho. Então, Interfaces de Blueprint, elas
demoram um pouco mais de tempo para serem configuradas, mas são mais otimizadas. Seu jogo será executado muito mais rápido. Então, vamos voltar para a Interface do
Blueprint. Clique neste e
vamos adicionar as entradas. E
chamava-se estado dos movimentos E. Então essa era a nossa enumeração. Então, vamos clicar aqui, e vamos chamá-lo de movimento de
Estados assim. E agora você pode ver que
não me deixa fazer isso. Então eu tenho que compilar
e deixar-me tentar novamente. Às vezes, ele se
incomoda assim. Provavelmente terei que fechar o projeto
e abri-lo novamente. Tudo bem, acabei de fechar
e abrir o projeto. Então, vamos tentar novamente, clicando
aqui, palco de movimento. Não me deixa
ainda fazer isso aqui. Acho que é porque na base
de jogadores já temos. Vamos voltar para uma base de jogadores. Vamos descobrir isso. Acho que é porque já
temos esse chamado estado de
movimento. Deixe-me excluir
todos aqueles assim. Talvez você possa tirar uma foto para
você para que você possa se lembrar do
que estava dizendo. Mas agora vamos
compilar aqui, salvar, voltar para a interface, e agora vamos tentar
alterá-la Estados do Movimento. E agora isso me levou, provavelmente
é por causa
das outras funções lá. Então, agora que o temos, você pode vê-lo adicionou isso
à nossa interface de evento. E novamente, assim como
antes, podemos conectá-lo. E agora podemos chamá-lo aqui. Então eu tenho que lembrar
o que estava aqui. Estava ocioso quando
o movimento era 0. Então, executar o nome
dos movimentos do evento estado aqui, então define estados de movimento. E você pode ver aqui, você pode chamar essa função
dizendo int player base. Então, chamando-o
da interface, eu posso fazer isso aqui em cima. Mas descobri quando estava
trabalhando que é muito melhor selecionar este
na base int player. Quando você o seleciona
pelo interior em vez da função de carvão, este é atualizado automaticamente. Sempre que você atualizá-lo
aqui na interface, ele lhe dará um erro se você selecionar o outro, apenas um atualizar automaticamente. Então eu sempre seleciono este. Então, o ídolo aqui, eu posso
simplesmente clicar e copiar colar aqui e sacos conectados. Então, foram direitos de execução
e depois correram para a esquerda. E aqui em cima foi pular. Então, quando não era mais,
era lixo e estava no outono. Então, assim. Então agora implementamos a Interface Blueprint e
temos a função aqui. E é muito mais limpo
e você pode ter todas as
suas funções para
a base de jogadores. Talvez você já tenha adivinhado. Mais tarde, vamos
criar mais
Interfaces Blueprint, uma para o modo de jogo, uma para o controle do jogador, e assim por diante, sempre que
matamos coisas lá dentro. Ok, então agora não consigo ver mais eventos personalizados
que fizemos aqui, então tudo está bom
e foi isso por enquanto. Então, vamos passar para
a próxima lição.
35. Introdução ao Blueprint do Widget: Agora é hora de falar sobre o sistema de desova
e começar, vamos falar sobre os blueprints de
widget
e o Widget Blueprint é
onde você cria a interface do usuário. Então, o que queremos começar, vamos criar uma nova pasta
aqui no conteúdo. Vou clicar com o botão direito do mouse em
criar uma nova pasta e vamos chamá-la de UI
para interface de usuário. Dentro daqui,
vamos clicar com o botão direito do mouse. E aqui na interface
do usuário, você pode criar um blueprint de
widget. Então, criando esse e selecionando o Widget
Blueprint aqui. Escrevendo WB para o plano de widget. E a primeira coisa que
vamos
criar é a seleção de
personagens. Então, Seleção de caracteres. Ok, então você pode
clicar duas vezes nele agora. E, para começar,
quero falar sobre a interface ou a visão geral
do que isso consiste. Em vez de aqui no meio,
você pode ver o gráfico. E, novamente, você pode
clicar com o botão direito do mouse e
mover para se mover no gráfico. É aqui que você projeta a interface do usuário. E a segunda parte disso
consiste em é o gráfico. Então você tem que o designer
projetará a interface do usuário. E, em seguida, você tem
o gráfico onde você adiciona funcionalidade à interface do usuário. Então você pode ver, isso
é familiar para nós. Estes, é aqui que codificamos. Aqui. Podemos ver nossas variáveis
e funções e assim por diante. Você também pode ver os
diferentes detalhes sobre, por exemplo, uma
variável em que clicamos. Isso é muito familiar para nós agora. E no designer, o que você tem aqui é o gráfico. Você tem os elementos que você
pode usar para projetar sua interface do usuário. E então você pode ver todos
os elementos que
você adiciona aqui. Novamente, você tem um
painel de detalhes onde você pode alterar detalhes
sobre os elementos. Por exemplo, você pode
alterar o estilo da fonte, o tamanho da fonte, a imagem
é estilo e assim por diante. Apenas para uma pequena prática
antes de terminarmos, vamos tentar adicionar algo. Por exemplo, você
tem um bloco de texto, então temos os ativos comuns e
comuns aqui. Você pode tentar clicar
neles e ver o que você tem aqui. Não fique à vontade para adicionar
coisas à interface do usuário. Você pode. É sempre bom experimentá-lo. Então, o que você pode fazer é
o que eu costumo
começar ao criar a interface do usuário, geralmente crio um painel de tela. Então, se você procurar por Canvas
aqui, você tem este painel de tela. Então você pode arrastá-lo para fora
e colocá-lo aqui embaixo. Ele o adicionará à
interface do usuário assim. E você pode ver que a
tela foi adicionada. Agora isso é uma coisa muito básica. Você adiciona uma tela, a tela, você adiciona elementos diferentes. Por exemplo,
podemos adicionar esse texto. Você pode
adicioná-lo clicando e arrastando-o
para baixo na tela. E você pode ver que o
texto foi adicionado. Ou você pode clicar e
arrastar e colocá-lo em qualquer lugar aqui dentro da
tela e colocá-la. Normalmente, o que eu
gosto de fazer é arrastar até aqui e
depois clico nele. Então, vamos excluir um deles clicando
em Excluir no meu teclado. Você pode clicar nesse
texto, por exemplo, e você pode ver
detalhes diferentes sobre esse texto. Assim, você pode alterar
a posição dele, para que ele possa clicar e arrastar e
alterar a posição. Por exemplo, podemos escrever
cento e
cem e o y. E você pode mudar a
cor do texto. Você pode alterar a fonte aqui, selecionando o
tipo de financiado, o tamanho do fundo
e assim por diante. Então você tem detalhes diferentes. Você pode mudar
sobre os elementos. Os
elementos mais comuns estão aqui. Em comum, você pode
tentar, por exemplo, arrastar um botão
e ver quais coisas você pode
mudar sobre um botão. Então, sempre bom
arrastá-los para aqui, uma imagem. Sempre usamos imagens para que você possa tentar se
familiarizar com elas. Você pode ver, você pode
escalá-los aqui com essas coisas
bonitas de montagem para que você possa clicar e arrastá-lo. Você pode clicar neste
pincel, por exemplo, para obter uma imagem e selecionar
o tipo de imagem que ela é. Por exemplo, clicando aqui, posso selecionar, Vamos
ver meu sprite. E você pode ver que o sprite
foi adicionado como uma imagem. E você pode alterar o tamanho
da imagem aqui. Você também pode alterar a
cor da imagem. Então você tem
muitas opções
com as quais
trabalharemos mais tarde. Outras coisas legais antes de
eu terminar isso aqui, você tem algo
chamado caixa horizontal. Uma caixa horizontal aqui, podemos arrastar isso aqui. E vamos, deixe-me excluir
todos esses por enquanto. Clique em Excluir. Então, temos essa caixa horizontal. Vou arrastá-lo para
cá e ampliá-lo. Então, nesta caixa horizontal, onde quer que eu coloque aqui
será colocado horizontalmente. Então, se eu pegar esse texto e
colocá-lo aqui na caixa, você pode ver agora que ele está dentro
dessa caixa horizontal. E se eu adicionar mais um texto
ou, na verdade, vamos adicionar
uma imagem em vez disso. Vamos adicionar uma imagem
na caixa horizontal. Agora você pode ver
que está adicionando coisas horizontalmente para que elas
não se sobreponham. E se eu adicionar outro texto, agora você pode ver que ele adiciona
elementos horizontalmente. Então agora eu adicionei, adicionei
isso por engano
aqui para poder clicar e
arrastá-lo para esta caixa. E você pode ver adiciona
elementos horizontalmente. Lá. A mesma coisa vale para
uma caixa vertical. Ele adiciona coisas verticalmente um
abaixo do outro. E se você quiser que as peças
se sobreponham juntas. Por exemplo,
temos um botão e temos uma imagem no botão. Usamos algo
chamado sobreposição. Então, posso adicionar uma sobreposição aqui. E deixe-me adicionar um botão. Então, se eu clicar no botão
ou procurar pelo botão, adicione-o à sobreposição. Você pode ver agora meu botão
está na sobreposição, e agora posso procurar imagem e colocá-la
no botão aqui. Então agora você pode ver que estou sobrepondo coisas
umas sobre as outras. Tenho um botão e tenho
uma imagem nos botões. Por exemplo,
posso escolher uma imagem aqui e você pode ver
agora que tenho uma imagem no meu botão para que você possa
ver que ela não fica ótima porque eu tenho que clicar na minha sobreposição e
redimensioná-la e assim por diante. Mas estaremos trabalhando
com tudo isso. Eu só quero apresentar
a interface do usuário. Sinta-se à vontade para apenas
procurar coisas aqui, tenta colocar essa barra de
progresso. Veja o que acontece se você
aumentar a porcentagem
assim e tentar
brincar com a interface do usuário, é sempre bom brincar. E quando terminar, vá em frente e exclua
todos aqueles, incluindo
o painel de tela e
compile e salve. E então vamos passar para a próxima lição e começar
a
criar a interface do usuário de
seleção de caracteres.
36. UI de seleção de personagens: Vamos começar a criar a interface do usuário de seleção de
caracteres. Então, aqui no
Widget Blueprint que criamos anteriormente, vamos clicar nisso aqui. Então, a coisa que queremos criar, fui em frente e
criei de antemão para poder mostrar o que
estamos tentando criar. E é sempre bom ver
esse objetivo que estamos buscando. Estamos com o objetivo de
criar esse personagem. E então temos dois
botões onde você pode gerar um loop ou Serena,
dependendo do que você pressiona. Então, essa é a coisa que
estamos tentando criar. E então temos um fundo
que está desfocado. Portanto, esse é o objetivo
que temos que criar. E é sempre bom imaginar isso em sua mente e
tentar quebrar isso. Então, novamente, falei sobre uma caixa vertical e uma
caixa horizontal na lição anterior. E, por exemplo, esses
dois botões estão dentro de uma caixa horizontal porque
estão atrasados um ao lado do outro. A imagem e o botão
estão dentro de uma sobreposição porque você sobrepõe as coisas umas
sobre as outras. Então, coisas muito básicas, muito boas para imaginar
o que você está tentando
fazer para saber quais
elementos você vai usar. Mas vamos analisar e
criar nossas próprias coisas. Então, primeiro, temos que
importar alguns ativos. Vamos primeiro aqui na interface do usuário,
clique com o botão direito do mouse e
vá para Nova pasta. Vamos fazer um
chamado fundos. Vamos adicionar outra
pasta chamada Botões. Vamos adicionar
outro chamado Fontes. E o último, vamos chamá-lo de imagens. Talvez precisemos de um ícone
chamado mais tarde, mas isso é para mais tarde. Então aqui nos fundos, eu forneci para vocês esses materiais do
curso aqui. Então, nos materiais do curso, vá em frente e encontre a interface do usuário. E também aqui essas
são as pastas. Então, nos planos de fundo, você
pode arrastar isso aqui. E para este, não clique com o botão direito do mouse e
aplique configurações 2D. Isso não é uma escolha, isso não é pixelado. Isso é basicamente apenas uma imagem. Então, vamos voltar e para
dentro dos botões. Aqui, vamos importar
todos esses botões. Portanto, não vamos
usar todos eles, mas você tem uma variedade
se quiser
usar cores diferentes em
sua versão do jogo. E então vamos às fontes, e vamos voltar aqui, ir para os fundos e
adicionar todos esses fundos. E então ele vai perguntar, você quer criar esses fundos aqui e
basta clicar em Sim, tudo isso criará
fundos para você. E a última coisa são as
imagens ou as imagens. E vamos voltar
e adicionar as imagens, que é um acaso e Serena. Então, adicionando-os aqui,
vou me candidatar a essas configurações porque elas
são muitas escolhas. Então clique com o botão direito neles e aplique
configurações de textura 2D de papel. Assim mesmo. Se você está se perguntando onde
você pode obter fontes como essa, você sempre pode
procurar fontes do Google. Eu uso isso para fazer
meus videogames. Tão divertido. O Google Fonts procura por isso. Dentro daqui você tem fontes
grátis incríveis e você pode usá-las comercialmente para lançar no
Steam ou em qualquer outra plataforma. Então, todos eles são de graça. O que quer que você encontre
dentro daqui, você pode tentar
procurar um fundo, tentou encontrar estilos diferentes
especificamente e assim por diante. Site muito legal,
se você quiser, vá em frente e
encontre-o nas fontes do Google. Claro, você pode comprar fontes por dinheiro e importá-las para
dentro daqui também. Então, vamos clicar em Arquivo
e salvar tudo. Agora que temos tudo, vamos voltar ao
Widget Blueprint e estamos prontos
para começar aqui. Então, primeiro o que eu quero
fazer é adicionar uma caixa vertical. Vamos procurar por vertical
e adicioná-lo aqui. E, na verdade, antes de fazermos isso,
na verdade, esqueci de
adicionar o painel de tela. Então, adicione o painel de tela
sempre como o primeiro elemento. E então vamos adicionar
a caixa vertical. Sempre precisamos de uma tela primeiro. Agora temos essa caixa vertical onde tudo estará dentro. Então temos, novamente, se eu levar isso de volta aqui, temos a
caixa vertical onde tínhamos esse título e embaixo dele
temos os botões. É por isso que estamos
usando uma caixa vertical. E primeiro ano,
precisamos centralizar esta peça no
meio da tela. E para fazer isso, é
aqui que você usa pontos de ancoragem. Muito importante
usar pontos de ancoragem e configurá-los para todos
os seus elementos. Então clique nesta âncora
e
defina-a para o meio da
tela assim. Agora, na posição,
se você escrever 00, você pode vê-lo se alinha
a esta parte superior aqui, mas queremos que ela
esteja no meio. E é aqui que você pode
brincar com o alinhamento. Você pode ver o alinhamento no x e
o alinhamento no Y. E parece que se
você escrever 0,5 em cada um, ele se alinhará no
meio, assim. Tudo bem, então vamos começar aqui. Vamos criar uma sobreposição
e colocá-la aqui nos bugs verticais porque agora uma sobreposição é onde
você sobrepõe itens. Então, quero sobrepor uma imagem
e um texto em cima dela. Então, vamos procurar imagens. Arraste-o aqui, coloque-o
na sobreposição e você pode
ver agora que temos uma imagem. Vamos selecionar qual
imagem queremos usar. Agora, este é apenas o plano de fundo
que você deseja usar. Só vou usar
esse botão chamado. Na verdade, este
botão plano, Black Square Flat. Então, usando este e vou fazer com que ele preencha
todos esses segmentos. Então você pode ver aqui que você tem alinhamento
horizontal e
vertical. Horizontalmente, quero
preenchê-lo para a coisa toda aqui. Então, agora, dependendo do
tamanho de suas caixas verticais. Basicamente, vou
preencher a coisa toda. Isso é o que os alinhamentos
verticais e horizontais são. Então vou usar algum texto, e vou soltar os
textos sobre a sobreposição. Aqui. Quero o
texto no meio. Então, vou alinhar esse texto ao meio
aqui, para o meio aqui. E vamos chamá-lo
aqui no texto. Selecione um personagem. Assim mesmo. Agora, podemos selecionar a
cor, acho que está tudo bem. Em seguida, podemos selecionar
coisas sobre a fonte. O que eu quero fazer é, vamos usar este
chamado Source Sans Bold. Então, usando este aqui. E vou
fazer 14 em tamanho. Normalmente, quando olho quando crio a interface do usuário, geralmente
é mais correto quando você tem o
Zoom Plus dois aqui, se você olhar para isso, então,
se você diminuir e diminuir o zoom,
geralmente é em torno do
Zoom Plus dois, mas às vezes eu
os corrijo depois de
adicioná-los ao jogo. Então selecione o personagem e
vamos fazer algumas sombras. Gosto de ter algumas
sombras no meu texto. Então aqui na cor
da sombra, você tem que atualizar alfa aqui o alfa é basicamente a
opacidade da sombra. Então, se você escrever um, você pode
ver que você tem sombra para nossas 0,5 opacidades como 50%, vou escrever 0,35. Então 35 por cento sombra e o deslocamento de sombra
vou escrever 22. Então, está um pouco mais longe do texto, algo assim. O que vou fazer
agora é também adicionar uma imagem
aqui apenas para estilizar. Então, vou adicionar uma imagem aqui em
cima sob sobreposição novamente. Então agora você está se sobrepondo um
sobre o outro. Vou selecionar
o azul agora, o botão, azul quadrado plano. Então, o que você pode fazer agora
é diminuir o tamanho aqui no y,
então ele o torna menor. E também quero preenchê-lo
horizontalmente assim. Vou fazer o tamanho apenas cinco pixels, assim. E se você quiser visualizar sua IU sem
essas linhas tracejadas, você pode clicar aqui. E acho que às vezes
é legal fazer isso para que
eu possa ver como minha interface de usuário
realmente se parece. Acabei de fazer isso por estilizar. Você pode clicar
nesta imagem aqui. Você também pode torná-lo menor. Então, se eu clicar
nesta imagem aqui, você pode diminuir e o y. apenas no caso de você
achar que isso é muito grande, eu vou fazer
algo assim. Agora, esse texto não parece estar
totalmente no meio,
porque quando você o
torna menor, você pode vê-lo quase atinge essa linha mais rápido do que aqui embaixo. Então, voltando para 61, vou empurrar esse
texto um pouco para baixo. Então, aqui em cima, no preenchimento, podemos empurrar as coisas para os lados. Então, do topo,
vou empurrá-lo. Você pode imaginar que alguém
o está empurrando do topo. Posso empurrá-lo para pixels. Então você pode ver, se eu escrevi dez, você pode ver que está diminuindo. Alguém está
empurrando-o de cima. Aqui à direita, alguém está
empurrando-o da direita. Então, isso é o
que significa. E o emparelhamento aqui da banheira, eu só queria
empurrá-lo para pixels, então está mais abaixo assim. Tudo bem, em seguida, vou fazer uma caixa horizontal para que eu possa ter esses dois
botões aqui. Então, procurando por horizontal. E vou deixá-lo em
cima dos meus dólares verticais porque eu queria sob essa
coisa aqui que eu criei. Então, essa caixa horizontal, eu queria ter dois botões. Vamos criar nosso primeiro. O botão consiste em
um botão e uma imagem. Então, vamos fazer uma
sobreposição primeiro porque queremos sobrepor dois
elementos um sobre o outro. Queremos um botão, primeiro botão, e vamos colocar
esse botão na sobreposição. E então precisamos de uma imagem
em cima do botão, assim como esta aqui. Então colocá-lo até a sobreposição. Então, temos dois elementos que se
sobrepõem um ao outro. Então, clicando no botão, vamos selecionar o estilo. Então aqui no
estilo, no normal, vamos selecionar o botão e eu quero usar o botão
azul aqui, botão, quadrado azul, este. Agora, algumas configurações
que podemos alterar. A tonalidade é ótima. Não quero que ele faça isso. Então, vou mudar
a tonalidade para totalmente ampla para poder usar as cores
verdadeiras do meu botão. E então, em vez
de bugs arredondados, você pode ver que há uma
linha estranha ao redor do meu botão. E isso ocorre porque
é uma caixa arredondada. Em vez disso, vou
mudá-lo para uma caixa. Posso ver que parece uma
resolução um pouco baixa, está embaçado. E isso pode fazer isso, você pode fazer isso aumentando a margem para que
pareça mais clara. Portanto, 0,5 é a
margem máxima que você pode fazer. Então, ele vai entre 0,10123450. Então 0,5, o melhor para usar. Nesse caso, se eu diminuir
um pouco assim, é
assim que o
botão se parece. Preciso fazer a
mesma coisa aqui
pelo Hubbard e pressionado. Então, em vez de ir aqui e encontrar esse mesmo
botão repetidas vezes, como um pequeno truque, você pode clicar com o botão direito do mouse e
copiar isso, e então você pode clicar com o botão direito do mouse
e colá-lo aqui. Um atalho para isso.
Você pode ver se você mantém pressionado Shift no teclado e
clique com o botão direito do mouse, você pode copiar. Então mantenha pressionada Shift,
clique com o botão direito do mouse
e copie e mantenha pressionada a tecla Shift e E você pode colá-lo aqui.
Então ele pode fazer isso com isso. Você pode fazer isso com
a cor da tonalidade também. Então clique com o botão direito do mouse em
Shift e clique com o botão direito do mouse para
copiar Shift e clique com o botão esquerdo para Para isso. A mesma coisa com as margens
é um fluxo de trabalho muito rápido aqui. Quanto à tonalidade quando eu pairo. Então, quando alguém passa
o mouse sobre o meu botão, eu quero que eles fizessem, eu queria
mudar um pouco de cor. Então, algo assim. Ok, quando você estiver
feliz com isso, você pode clicar em Ok. E aqui deprimido, quero ter uma cor um pouco mais escura quando
alguém pressiona o botão. E agora temos o botão
aqui e aqui para esta imagem, vamos colocá-lo aqui no meio
do botão assim. Vamos selecionar a imagem. E o que eu
quero usar está aqui
nas imagens que queremos
usar Serena para esta. Eu vou, você pode encontrar
a Csarina aqui
nas imagens como esta ou
você pode clicar e arrastar. Às vezes, é uma
maneira mais rápida como este ano. Certo, então temos a imagem aqui. Vou empurrá-lo
um pouco para cima porque você pode ver que
temos isso
aqui em baixo e preciso
empurrá-lo um pouco para fazer parecer que está
no centro do botão. Então, novamente, o que eu
ensinei sobre preenchimento, estamos pressionando-o de
baixo, a partir do botão, eu posso pressioná-lo para pixels para
cima, assim mesmo. O que eu quero fazer aqui, quero clicar
nesta caixa horizontal e quero clicar em Preencher. Então agora eu posso ver que
a caixa horizontal está realmente preenchendo
a coisa toda. E a mesma coisa
com a sobreposição, quero clicar
em preencher o buraco. sobreposição preenche
toda a área aqui embaixo. E até este botão aqui, vamos clicar nele
e vamos clicar em
Preenchê-lo horizontal e
verticalmente, assim. E então precisamos
de algum espaçamento entre esses dois. Você pode ver que eles estão
juntos e nós não queremos isso. Então aqui você pode
procurar por espaçador. Isso, eu quero colocá-lo entre a orelha e a caixa vertical, entre a sobreposição e a caixa
horizontal aqui. E você pode ver que está entre
esses dois elementos agora, selecionando isso, e este
é o x e o y, e está no y,
precisamos de algum espaçamento. Vou fazer
dez, assim. E você pode ver agora que temos
algum espaçamento entre eles. Você pode pensar,
por que preencheu a coisa toda aqui embaixo? E eu gostei que minha IU fosse dinâmica. Então, o
que quero dizer com isso é que se eu clicar nessa caixa vertical
agora para redimensioná-la, você pode ver minha interface de usuário
redimensionar dinamicamente. Redimensionar eu faço aqui. Então, em vez de definir, se eu clicar no botão, em vez de definir o
tamanho por essa imagem. E depois descubro que
gosto que isso seja maior. Em vez de ir aqui
e redimensionar as coisas, eu gostaria de clicar no meu elemento superior e apenas redimensioná-lo e
fazer com que pareça bom. Então é uma semana que temos que fazer. E eu acho que também é
mais limpo fazer isso assim. Temos esse botão agora
precisamos de outro botão. Então, se eu clicar nesta sobreposição
e clicar em Control D, ou você pode clicar com o botão direito do mouse
e clicar em duplicar. Isso é a mesma coisa. Então agora temos dois botões. Agora, para esta imagem, quero usar o botão vermelho. Este,
botão vermelho, quadrado vermelho, clique com o botão direito do
mouse enquanto
pressiona Shift para copiar, clique com o botão esquerdo enquanto mantém pressionado
Shift para colá-los. Ok, então agora eu tenho isso
e para esta imagem, preciso mudá-la. Então, vou dar uma
olhada nessa imagem agora. Vou adicionar um espaçador
entre esses dois botões. Então, um espaçador entre essas
duas sobreposições, assim. E agora esse espaçador está no x. vou subir
15 para este. Então agora eu tenho dois botões e eles estão bem juntos. Agora posso arrastar isso para fora
e torná-lo maior. Também posso redimensioná-lo aqui. Acho que algo assim
seria muito adequado para mim. Agora, se você clicar
na caixa vertical, verifique se ela está no meio. Você pode ver que não está
totalmente no meio. Agora, vou
mudar essa posição
no x e y para 00,
assim. E agora está dentro
do meio. Então, vamos compilar e
salvar tudo. Então, a última coisa que precisamos fazer aqui agora que
temos nossos botões, precisamos adicionar um plano de fundo. E isso é
simplesmente uma imagem. Então, se você minimizar isso aqui, e se eu arrastar uma imagem
aqui atrás de tudo, quero que ela preencha toda
a tela. Novamente, você pode
clicar na âncora e clicar nesta para
preencher a tela inteira. E agora podemos escrever
0 nos deslocamentos aqui, 00. Agora ele preenche toda a tela e você pode alterar
o plano de fundo. Então, dentro da pasta do meu
plano de fundo, posso arrastar meu plano de fundo. E agora ele está preenchendo toda
a tela aqui. Agora eu quero desfocar a
imagem. E você pode fazer isso. Se você escrever desfoque aqui e tiver esse
chamado desfoque de fundo, vou colocar isso
aqui e você tem que especificar
a quantidade
de desfoque novamente, você tem que clicar
nos pontos de ancoragem, faça com que ele preencha toda a tela, direita 00 e os deslocamentos. E você pode escrever o
valor para desfocá-lo. Agora podemos escrever
dez por exemplo, e você pode ver que
nada está acontecendo. E isso ocorre porque o desfoque de
fundo precisa estar abaixo da imagem para estar em
cima dela, assim aqui. Então agora podemos ver o borrão. E é assim que você desfoca imagens. E acho que um borrão de dez está
funcionando bem para este. Então, agora o que eu
aconselharia você a fazer, você pode, por exemplo, clicar neste texto aqui. Se estou fazendo um projeto sério, estou mudando os
nomes de todos esses aqui. Porque se você for para
o gráfico, você pode ver, você pode realmente ver os
elementos que você criou. Assim, você pode ver todas as imagens e os dois botões
que você criou. Então, vamos, por exemplo,
para este botão se você
clicar nele aqui, e você também pode selecioná-lo aqui, você pode alterar esse
botão para btn. Eu costumo usar isso
como prefixo para botões. E eu chamo isso para Serena. E eu clico no
outro e chamo de n. Olha, isso é muito bom para fazer porque se você for
ao gráfico agora, podemos realmente ver quais são
esses elementos. Este é o botão para loop. Este é o botão para Serena. Não faço ideia do que são se eu não
lhes der um nome, então é impossível
para mim saber o que são. E às vezes não
precisamos de variáveis. Assim, você pode ver que essas
são, na verdade, variáveis que você pode usar aqui
no Gráfico de eventos. Mas às vezes não
precisamos deles como variáveis. Por exemplo, esta caixa de
título aqui, nunca
mudaremos nada sobre ela. Então, eu realmente não preciso
que seja uma variável. Então é aqui que você pode desmarcar essa chamada é variável. Então ele pode desmarcar. Eu
posso fazer a mesma coisa com este aqui em cima é variável. E acho que
também podemos fazer isso com isso. Vamos realmente fazer isso. Então segure Control,
selecione ambos, remova essa variável,
Compilar e Salvar. E você pode ver
no gráfico agora nós removemos todos esses. Agora temos uma única
imagem que resta. Podemos tentar adivinhar essas imagens e esse é
provavelmente o plano de fundo. Então, se você olhar para ele aqui, imagem 1026, chama-se
a mesma coisa, 1026. E também não
precisamos mudá-lo. Então, vou remover
isso é variável. E isso faz com que a
coisa toda pareça muito mais limpa. Então eu gosto de ficar limpo
dentro dos meus projetos. E provavelmente são
apenas os botões que precisamos como variáveis porque vamos usá-los para quando o jogador
pressionar os botões. Então, foi isso pessoal para a tela de seleção de
personagens. Espero que você tenha se divertido
criando essa interface e vamos
para a próxima lição.
37. Como adicionar UI ao Viewport: Então, vamos em frente e adicione
nossa interface de usuário à tela. Então, fizemos essa tela de
seleção de caracteres e queremos adicioná-la
aqui à janela de exibição. Então, quando clicamos em Jogar
agora , nada realmente acontece. Estamos de volta aqui
com nosso personagem, mas queremos adicionar a tela de seleção de
caracteres. Então, para fazer isso, geralmente
adicionamos uma interface do usuário
no controlador do player. Então, vamos para as plantas, e agora vamos usar
nosso controle de jogadores. Acredito que ainda não
o usamos, então ele ainda está vazio, aberto o editor de blueprint completo. E dentro do controlador
do jogador é onde adicionamos UR é muito
importante lembrar. Vamos excluir esses eventos
padrão. Sempre podemos
adicioná-los se quisermos. Agora, muito importante entender,
a interface do usuário é algo do lado do cliente. Portanto, é só você como o jogador que vai
ver sua própria interface do usuário. Então, todos os jogadores
no jogo como uma interface do usuário. Então, talvez você tenha um bar
experiente aqui. Você tem algum
nivelamento aqui em baixo. Eu não sei, alguma interface aleatória. Portanto, toda a interface do usuário que você
tem é do lado do cliente,
portanto, não está do lado do servidor. Portanto, toda a interface do usuário é individual
para cada jogador. Então, vamos voltar para o controlador
do jogador aqui. E a primeira coisa, vamos fazer eventos personalizados. Então, vamos criar um evento personalizado e chamá-lo de inicializar widgets. E novamente, eu disse antes, em vez de fazer
esses eventos personalizados, é bom usar uma Interface de
Blueprint, mas vamos fazer
isso primeiro e depois
alterná-lo com uma
Interface de Blueprint depois disso. Então, vamos fazer outro, outro evento personalizado
e eu vou
chamá-lo de CL, inicializar widgets. Então, este
será um cliente do
lado que não usou
um lado do cliente. A única coisa que usamos se voltarmos à base de
jogadores agora, a única coisa que usamos
até agora é um lado do servidor, então executando no servidor. Mas para a interface do usuário, eles estão
sendo executados no cliente. Então, clicando em Executar no
cliente proprietário e, em seguida, confiável. E agora, para criar UI, dizemos que cria widgets. A interface do usuário é chamada de widgets. Criamos widgets.
Então crie o widget. E é assim que você cria
uma interface do usuário dentro do Blueprint. Então, vamos conectá-lo aqui em cima. E agora você precisa selecionar
qual interface de usuário você deseja criar. E, obviamente,
não temos muito. Só temos essa seleção de
caracteres. Então, este é o que
queremos adicionar. Então, agora que você adicionou,
é sempre bom clicar com o botão direito do mouse aqui e promovê-la
para uma variável para que você possa usar essa
variável mais tarde quando quiser ocultar ou
mostrar a janela novamente. Então, promove uma variável. Vamos chamá-lo de WB,
esse é o meu prefixo. Você pode escolher
o que quiser. E vou
chamá-lo de seleção de caracteres. Portanto, esta é a variável de blueprint do
widget de seleção de
caracteres . Agora, para a janela de exibição,
então ela está visível. Você pode ver aqui se
eu clicar em Jogar agora, nada acontece e
isso é porque você precisa adicioná-lo à janela de exibição. Então, se eu voltar aqui, tenho que arrastar
da variável e dizer adicionar duas viewports. E você pode ver
este chamado Adicionar ao Viewport. Assim mesmo. Então, agora, se você clicar em jogar e nada
vai acontecer porque lembre-se que você precisa ligar para o mecanismo de LCD de eventos não
sabe o que está fazendo. Então, correndo
desse evento personalizado, talvez você já tenha adivinhado. Temos que chamar nosso evento
do lado do cliente aqui. Então, os widgets inicializados por CL. Vai de um evento
normal que vai para a execução no cliente. Então, a partir do cliente,
você está criando a interface do usuário e ela será exibida. Mas é claro que também temos que
executar esse evento porque o mecanismo não sabe o que quando você
quer executar este evento. E eu só quero executá-lo
aqui no início do jogo. Então, sempre que clico em
jogar no jogo, quero mostrar minha seleção de
personagens aqui. Então, vamos chamar esse evento aqui, inicializar widgets
assim. Então, agora, quando eu clico em Jogar, ele vai executar este evento. Este evento executará esse evento
que é executado no cliente. E, em seguida, vamos criar a interface do usuário e
adicioná-la à janela de exibição. Vamos salvar tudo. Vamos clicar em Play. E você pode ver quando
clico em Reproduzir, agora minha interface do usuário está na tela. No entanto, você pode ver que
posso passar o mouse sobre os botões, mas meu mouse não está visível. Isso ocorre porque no controlador
do jogador, você tem os padrões da classe. Você tem que clicar neste
chamado Mostrar cursor do mouse. Então, clicando aqui, vamos compilar e salvar e
ver o que acontece. Agora eu posso ver meu cursor, e você pode ver agora eu
posso ver minha interface do usuário e
clicar nos botões. Você vê que temos um
pequeno bug aqui. Posso passar o mouse sobre o botão que você
pode ver as mudanças de cores. Mas se eu passar o mouse sobre a imagem, não
posso mais passar o mouse. Você pode ver o
efeito de passar o mouse desaparece. Isso ocorre porque minha imagem
está bloqueando meu botão. Temos que consertar isso. Então
, volte para a interface do usuário aqui, e isso é muito importante. Esta imagem está
bloqueando esse botão, então não consigo pressioná-lo. E vamos selecionar essa
imagem e essa imagem. Vamos descer e você
tem que mudar este. A visibilidade em
seu comportamento. Deficiência,
mude-a para nenhuma, pressione testável. E isso significa que não importa que
essa imagem esteja lá. Eu só quero ignorá-lo. Então o mouse
vai ignorá-lo. Você pode ver aqui jogando agora, e eu pairo sobre a
imagem, não importa. Ainda estou pairando
sobre o botão. Então, você tem que definir
elementos como testáveis não atingidos se você não quiser que eles bloqueiem sua interação com
botões e com o mundo. Ok, então antes de terminarmos, em vez de fazer esses widgets inicializados de
eventos personalizados, vamos realmente transformá-lo em uma interface de Blueprint
e, em seguida, você também pode ter alguns exercícios
disso. Então, vamos minimizá-lo e tentar fazer você mesmo,
se quiser. Esse é o mesmo
método que fizemos antes de ir para a pasta
interfaces. Agora nós tínhamos feito um
para a base de jogadores, então temos que fazer um novo
para o controlador do jogador. Então, vamos clicar com o botão direito do mouse, vá para blueprints aqui e selecione Interface de
Blueprint. E, novamente, costumo
chamá-lo
de nome do blueprint em
que quero usá-lo. Então, queremos usá-lo no controlador
do player
assim e clicar nele. E agora vamos dar
um nome a essa função e chamá-la novamente, inicializar widgets
assim. Compile e salve. E vamos voltar para
o controlador do jogador. Lembre-se, novamente, lembre-se de
compilar aqui, muito importante, compilar salvar. Vamos voltar para o controlador do
jogador. E dentro daqui,
vamos para Configurações de classe. E aqui nas interfaces, vamos adicionar nossa interface
para o controlador do player. E agora você pode
vê-lo aparecer aqui. Em seguida, você pode escrever widgets de
inicialização. E você pode ver o evento
inicializar widgets aqui, e ele vem de uma Interface de
Blueprint. Isso é o que o ícone significa. Agora podemos conectá-lo aqui em cima. E também podemos chamar o evento
aqui, inicializar widgets. E, novamente, vou
selecionar este no controlador int player,
assim mesmo. Então, agora está funcionando perfeitamente. Mais uma vez. Se eu clicar em Jogar, agora, ele funcionará como deveria.
38. Funcionalidade de seleção de personagens: Então, vamos agora
voltar ao nosso widget. Vamos na interface do usuário e
no blueprint do widget. E, dentro daqui, agora queremos adicionar funcionalidade à interface do usuário. Portanto, para adicionar funcionalidade
à interface do usuário, lembre-se, este Blueprint de Widget é
dividido em um designer e um gráfico. E o gráfico é onde
adicionamos nossa funcionalidade
para os botões. Então, clicando no designer, você pode clicar em
um dos botões. Então, vamos começar com Serena
clicando nesse botão. E se você descer
para o botão, você pode ver que você tem alguns
eventos que você pode adicionar. Por exemplo, o que deve acontecer se eu clicar neste botão? O que deveria acontecer se eu passar o
mouse sobre o botão? O que deve acontecer se
eu descobrir o botão? Portanto, temos eventos diferentes
que podemos adicionar para o botão. Agora, eu quero usar
este por enquanto, o que deve acontecer quando
clico no botão? Então, clicando no plus e você adicionará este evento aqui. Agora, você pode excluir
esses, se quiser. Esses são os padrão. Podemos adicioná-los se quisermos. Então, selecionando-os, clicando
em Excluir no meu teclado. Então, eu só vou
ter este por enquanto. Portanto, o fluxo de trabalho, antes de começar, o fluxo de trabalho com o qual
vamos trabalhar
é quando você quiser
gerar o player, você vai pressionar esse
botão. Este botão irá
levá-lo a um evento no controle do
jogador. Portanto, temos que ter um evento aqui e o controlador do jogador para desova está
selecionando o personagem. E quando você seleciona
o personagem, ele passará
pelo modo de jogo. E muito, muito
importante lembrar que o modo de jogo só
é executado no servidor. Portanto, você não pode vir aqui e criar um evento personalizado e
configurá-lo no cliente run-on. Isso não funciona. O modo de jogo só existe no servidor. E isso é muito bom
porque podemos usar o Modo de Jogo para verificar
o que o cliente está fazendo. Mais uma vez, lembre-se,
no Unreal Engine ou apenas multijogador em geral, o servidor verifica
o que os clientes estão fazendo, então evitamos trapaças. E o modo de jogo é muito
bom para isso porque ele só é executado
pelo servidor. Assim, podemos percorrer
as coisas aqui e, em seguida, geramos um jogador no modo de jogo nos
permite gerar o jogador. Então, vamos voltar ao Blueprint
do Widget. Tendo um evento no controle
do jogador, o controlador nos
jogará para o modo de jogo. O modo de jogo, quando
ele vê que, Sim, você tem permissão para
gerar o jogador, ele vai jogar essa informação de volta para
o controle do jogador. Você pode perguntar, por que não
estamos adicionando isso, esse código aqui? Por que estamos adicionando-o ao controlador
do jogador em vez
da base de jogadores? Porque este é o
jogador que queremos
gastar um jogador e
é específico do jogador. Como não
temos um plenário em, lembre-se de que estamos
gerando o jogador. Portanto, esse código não
existe quando você está aqui na tela de seleção porque você ainda não
gerou o jogador. Portanto, você não pode adicionar código aqui. Não funcionará porque
isso ainda não existe se você
não gerou o jogador. Então você não pode, não podemos fazer
o código dentro daqui, então temos que fazê-lo no
controlador do jogador,
porque o controlador do jogador
aparece
sempre que o player
se conecta ao servidor. Então, se eu estiver jogando Counter-Strike ou se estou jogando Maple story, quando eu me conecto ao servidor, ele cria automaticamente um controlador de jogador
para cada jogador. O controlador do jogador
existe mesmo que meu **** ainda não tenha respondido. Então, vamos para o blueprint do
widget. E dentro daqui,
queremos, na verdade, vamos começar
com um controle de placa. Acho que será
mais fácil para você aqui. Então, aqui, vamos fazer um novo evento, fazer um aqui e
vamos chamá-lo. Vamos chamar o Select Character. Agora, às vezes, quando fico confuso de como
devo fazer um mecânico, costumo começar pela parte de trás, então isso às vezes
acho que é muito bom fazer. Às vezes você pode
começar pela parte de trás. Então, o que você está
tentando alcançar no final? O que estou tentando alcançar é esse chamado ator de spawn. Este é o que
vamos usar. Em última análise. Queremos gerar um ator, você quer gerar o personagem. E aqui, esse é o
personagem que queremos gerar. E deixe-me fazer um evento
aqui chamado camada de spawn. Este é o evento final
que queremos acabar com um resultado. Então você pode começar por trás. E em vez de começar aqui, às vezes é
muito mais fácil de entender. Então ir, voltar é
muito mais fácil às vezes, novamente, gerar o jogador. Isso deve vir
do modo de jogo, porque como eu disse antes, quando você clica aqui, ele vai para o controle
do jogador aqui, o controlador
do jogador vai nos
jogar dentro
do modo de jogo, e o modo de jogo vai nos
jogar aqui, responderá ao jogador. Vou arrastar Is
variáveis no evento aqui. E em vez de classe, vamos mudar o nome dele,
chamá-lo de jogador e
gerar transformação. Podemos simplesmente chamá-lo de
transformada de geração, tudo bem. Então, temos o evento de
jogadores de spawn aqui. Isso virá
do modo de jogo. Então, vamos voltar
ao modo de jogo agora. Então, estamos trabalhando para trás
indo para o modo de jogo agora, vou excluir este
evento para que você possa começar a jogar porque não
precisamos deles agora. Compound save, e
vou fazer um novo evento aqui, eventos personalizados. Vamos chamá-lo de camada de geração de
solicitação. Assim,
solicita um jogador de títulos. E ele vai executar nosso jogador
Spawn a partir do controlador
do jogador. Mas agora não temos, não
temos uma variável
para o controlador do jogador, então não posso chamar esse evento aqui. Lembra? Agora está ficando um pouco
mais avançado porque
precisamos usar este jogador de geração de
eventos, que está no controle
do jogador, precisamos usá-lo
no modo de jogo. E isso é chamado de comunicação
Blueprint, como eu disse antes, usamos
Interfaces Blueprint para isso. Mas agora, o que podemos
fazer é clicar nisso mais podemos adicionar o controlador
do jogador. E então, como variável, podemos selecionar o
controlador do jogador e chamá-lo de PC. Acho que PC Maple Story, chamamos isso de sim,
um PC Maple Story. E então vamos criar na verdade, a partir do controlador
do jogador. Agora, se você arrastá-lo, porque agora que a variável é essa classe de blueprint aqui, agora
podemos chamar
essa camada de geração. Então, se você arrastar disto
e disser camada de geração, Ok, agora podemos chamar
esse evento aqui. E assim como antes, vou
arrastá-los de volta novamente. Então, arrastando o jogador de volta
para cá porque esta solicitação gera um jogador, vamos
chamá-lo aqui do controlador
do jogador novamente. E S4, a localização. Eu costumo quebrar isso. Então lembre-se de uma variável de
transformação, se eu fizer uma e
mostrar aqui, uma variável de transformação é uma variável onde podemos ver
a localização, a rotação e a escala, assim como
em nossa janela de exibição aqui, quando clicamos em algo, podemos ver a transformação. Esta é a variável de transformação. Então, sempre precisamos disso para definir onde o jogador deve aparecer, como o jogador deve ser
girado ao desova, quão grande o jogador
deve ser uma desova. Então, deixe-me excluir
este por enquanto. E em vez de ter
a transformação inversa, você pode arrastar para fora daqui
e clicar neste, fazer isso, vamos dividi-la
nestes três. Então, a localização, a
rotação e a escala. E eu geralmente deixo
isso estar no modo de jogo. É também assim que você
prefere como programador, algumas pessoas fazem isso de forma diferente, mas eu costumo fazer, eu costumo fazer o transformador e quebrá-lo assim. E então eu apenas conecto o local aqui porque a rotação é a mesma e a escala é a mesma. Então, isso é o que parece. Também podemos, em vez
de localização, podemos chamá-lo de local de geração. Só para que você não fique confuso
mais tarde sobre o que é isso. Ok, então agora eu tenho esse
chamado jogador de geração de pedidos. Agora, aqui
no player selecionado, é aqui que vai
estar porque
um jogador selecionado nos jogará aqui. E para se comunicar
com um modo de jogo. Novamente, eu disse antes, o modo de jogo só
é executado no servidor, então você tem que executar
isso no servidor. Então, sabemos como fazer isso agora. Então, vamos fazer um
evento personalizado e chamá-lo S RV, selecionar personagem. E já daqui de cima, podemos executar esse evento. Então, o SRB selecione o caractere e lembre-se de
executá-lo no servidor, este, selecione o
caractere e clique em confiável. Então, agora temos esse personagem
selecionado. Ele vai ser executado
pelo servidor. E lembre-se,
vamos chamar o jogador de geração de pedidos. E, novamente, precisamos
nos comunicar com nosso projeto. Precisamos usar o modo de decaimento aqui dentro do controlador
do jogador, vou ensinar-lhe como comunicar quais Blueprints. Isso é algo que
não tocamos antes. Para se comunicar com
o modo de jogo. Você tem que dizer, obtém o modo de
jogo. Muito básico. Agora, obtenha o modo de jogo. Este não é o seu modo de jogo aqui. Este é apenas um modo de
jogo geral no motor. Quando você diz obter o Modo de Jogo, você tem que definir. Você pode ver aqui, se você
segurar o mouse sobre ele,
ele diz que retorna à base
atual do modo de jogo. Agora, quando você obtém o modo de jogo, você tem que definir qual
modo de jogo você está falando, porque este é apenas
o modo de jogo geral. E temos algo
chamado elenco. Então, se você arrastar isso para
fora e disser custo para custar dois meios como o
qual, de qual Blueprint eu falo. Estou falando sobre
TM Maple Story. Então, custo para Maple
Story, este aqui. Certo? Agora, como Maple Story, isso significa que agora
posso usar tudo o que está dentro
desse projeto. Agora, por exemplo, posso usar ou posso chamar esse player de geração de
solicitações. Então, se eu arrastar para fora e disser o jogador de geração de
solicitação, você pode ver que posso
chamar esse evento agora. Ou digamos que se eu fiz um evento chamado uma
variável chamada hello, e é uma transformação, eu posso voltar ao meu
controlador e dizer: Olá. Eu posso ver agora que posso obter
essa variável também. Então é assim que você
se comunica entre blueprints para que eu possa obter
o Modo Geral de Jogo. E eu digo, estou falando
especificamente sobre história do
GM Maple porque às vezes em jogos você
tem vários modos de jogo, então você não
tem apenas um às vezes. É disso que estou falando. Quanto ao controlador do jogador, o que você pode fazer aqui é
dizer obter controle do jogador. E você pode ver, você pode obter o controlador do jogador,
mesmo princípio. Então você pode ver, agora este é um controlador geral do jogador
e você pode ver o custo também, porque eu estou falando especificamente sobre esse BC Maple Story. Bordos Bc. Você pode ver que é assim que você se comunica
com blueprints. Agora, esse bom controle de placa
é para um jogador. Vou explicar isso
a você daqui a pouco. Então, vamos excluir este aqui. E em vez de custar, então agora você sabe o que é o custo. Em vez de custar, gosto de
usar Interfaces de Blueprint. O problema com o elenco
é que ele cria referências
difíceis e vai
atrasar seu jogo, muitas delas. Então, se você tem um
jogo grande, você trabalha
há um ano e você tem um monte de elenco como você causa
a isso, você custa para isso. E você está fazendo isso
mil vezes em um jogo, vai
desacelerar seu jogo. Agora não estou dizendo
que é ruim usar. Eu uso isso às vezes e você
deve usá-lo às vezes. Mas sempre que você puder usar
uma Interface de Blueprint, eu recomendo que você use uma Interface de Blueprint
para que você não crie essas referências difíceis, o que diminuirá seu jogo. Então, primeiro você tem que
pensar sobre o que você
está tentando fazer referência? O que estamos tentando fazer
referência ao modo de jogo. Então, podemos realmente
usar esse evento aqui. Ok, então, para o modo de jogo, temos que realmente criar uma nova Interface de Blueprint
para o modo de jogo. Agora, vamos para interfaces, criar uma nova
Interface de Blueprint aqui
e, em seguida, chamá-la termina o modo de jogo. Agora este aqui, a função que queremos fazer
é chamada, eu vou fazê-lo. Então eu posso te mostrar do
que estou falando. Acho que é muito mais fácil. Então, vamos chamá-lo de
obter o Modo de Jogo ref. Então, estamos tentando obter a referência
do modo de jogo. E isso é uma função, então estamos criando uma saída. Aqui. A variável que você
deseja selecionar é o que você está
tentando fazer referência. Tentando fazer referência
à minha história da GM Maple. Então, meu modo de jogo, e
vamos chamá-lo de modo de jogo. Ok, então agora eu tenho a
função e vamos adicionar novamente. Ele saiu para
o nosso projeto de camuflagem, a interface para um
jogo ou planta. Então, vamos para
Configurações de classe e selecione. Ele veio aqui
e compôs Save. E, novamente, você pode ver a
interface aparecendo aqui. E como o Modo de Jogo. Agora temos que definir
o que é esse modo de jogo. E eu só vou
arrastar e dizer a si mesmo, o que eu quer dizer, seja qual for o
plano em que estou. Neste momento, estou dentro
da GM Maple Story. Então agora ele conhece o modo g, m, k, ou este modo de jogo
significa GM Maple Story. Então, isso é o que eu significa. Então eu só significa o
que, em que classe Blueprint
eu estou agora. Ok, agora que
criamos isso, agora podemos voltar
para o controlador. E em vez de fazer o casting, agora
podemos chamar essa função aqui chamada Get Game Mode áspero. Então, vamos arrastar daqui
e dizer Obter o Modo de Jogo ref. E como funções quando
diz mensagem, isso significa que ela vem de uma Interface de Blueprint e
esta é a correta. Portanto, sempre veja se ela diz
mensagem antes de selecioná-la, se ela vier de uma Interface de
Blueprint. Então, selecionando-o aqui. o modo de jogo agora e podemos fazer o que quisermos, como
antes, por
exemplo, chamando essa variável de saudação
aleatória. Então, dizendo olá, você pode
ver agora que funciona também. Então, apenas para explicar rapidamente, o que acontece é que você obtém
o modo Ok geral, e então você diz
obter o Modo de Jogo rref. E esta é a função
que criamos aqui. E ele sabe o que
é o Modo de Jogo porque dentro daqui, definimos a variável Modo de Jogo
como a auto-referência, que significa que ela sabe disso. Gm Maple Story. Portanto, esta é a GM Maple
Story que estamos usando. Tudo bem, então esse é o
modo de jogo ref que agora queremos usar. Na verdade, vamos excluir essa
variável antes que eu esqueça. Vamos chamar isso chamado
Requests spawn player. Então, aqui, solicite o jogador de
spawn. E eu tenho que definir meu jogador. E eu não quero fazer isso ainda. Eu quero definir meu jogador
aqui porque quando eu
clico em Tsarina, meu jogador vai
ser czarina. E quando clico no botão, Luke, quero definir a aparência dos
meus personagens. Então deixe-me arrastar
isso e continuar aqui. E quanto ao local, também
podemos continuar
e arrastá-lo para cá. E então você pode
vê-lo aqui. Selecione o personagem,
vou
continuar conectando-os lá. Agora podemos chamar esse
chamado Select Character. E é aqui que eu quero
chamar o Blueprint do Widget. Agora, o Blueprint do Widget, tenho que chamar esse caractere de
seleção. Então, agora vamos
praticar novamente com nossa Interface de Blueprint. Então, no Widget Blueprint, você pode dizer que recebe o personagem
do jogador. Agora, isso é bom para usar no single player porque você pode ver o jogador e
esse índice é 0. Mas você, à medida que você se conecta como jogadores e o jogo
no multiplayer. O jogador para se conectar
deve ser planejado X1. E então o terceiro cara
se conecta ao servidor, e está planejado x2
e 3406 e assim por diante. Assim, à medida que mais jogadores se
conectam, eles terão índices
diferentes. Portanto, não podemos realmente usar
isso no multijogador. Isso é apenas para um
jogador e multi-player. Usamos Get Owning Player. E se você passar o
mouse sobre ele, ele diz, obtém o controlador do player
associado a essa interface do usuário. Ele vai conseguir esse controle de
jogador,
seu controlador de jogador, você como o player que
você conectou, ele vai conseguir o controle
do jogador, que está
associado a essa interface do usuário. Então agora temos o
controlador do jogador e, novamente, temos que dizer obter o controlador de
jogador ref, e quem ainda não fez isso. Lembre-se anteriormente que fizemos uma interface para o controlador
do player. Podemos usar isso clique aqui. E assim como antes, vamos
clicar em Adicionar função e dizer que obtém o controlador de layout ref. E agora podemos adicionar uma saída. E assim como o que
eu disse antes, o que você está tentando
fazer referência? Isso é o que você deve
ter como variável que estou tentando referenciar
meu controlador de player, PC. Chamamos a história do PC Maple aqui e chamamos de controlador
de jogador. Ok, então agora lembre-se de entrar
no controle e você tem que definir o controlador
do jogador. Então, assim como antes, arraste do ano e diga a si mesmo. Portanto, o controlador do jogador é definido como este PC Maple Story. Agora, o que podemos
fazer no widget, podemos obter o Jogador Proprietário. Então agora temos o controlador
do jogador, e agora tenho que
especificar qual
controlador de jogador você está
falando especificamente? Estou falando e
fizemos este chamado get
player controller ref agora aqui. Então agora temos o controlador do jogador e o que queremos
fazer dentro daqui, queremos chamar esses eventos selecione jogador, selecionar personagem. E podemos chamá-lo
aqui selecione personagem. E você pode ver que podemos
selecionar o personagem. Então, quando você clica em Tsarina, queremos que
o personagem seja Serena. Quando clicamos em Luke, queríamos ter uma aparência prazerosa. Aqui, em vez de usar o Select Character,
tem o evento normal, assim como o que eu
disse antes, vamos realmente transformá-lo em
uma interface de Blueprint. Então, voltando, este é
o controlador do jogador. Então, indo para o controlador
do jogador, vamos fazer uma nova função aqui, chamá-lo de personagem selecionado. E vamos criar duas
novas variáveis. Um é o jogador e o outro é
o local dos títulos. Então, vou excluir
este aqui por enquanto. Vou compilar. Vamos para o aqui,
para a interface
e o Select
Character que acabamos de criar. Vamos fazer um ator aqui. Então a variável é ator, e é uma referência de classe porque é algo que
vamos gerar. Então, uma referência de classe, e vamos chamá-lo de jogador. E o outro é o local de desova
e é um vetor. Então, a localização do intervalo do vetor,
assim. E agora podemos
acabar como controlador, chamá-lo dizendo select character. E está aqui vindo de
uma Interface de Blueprint. E podemos conectá-lo juntos. Agora, como temos este, agora
podemos voltar para o Widget Blueprint
aqui e
chamá-lo novamente selecione o caractere. Muito bom para praticar. Normalmente, não faço
isso diretamente dentro
do controlador do player ou
na interface porque
quero te ensinar
a diferença. Então, vamos fazer este. Então, como personagem, esta
é a função aqui. Assim mesmo. E você seleciona
Serena como personagem. Ok, então agora volte
para o designer. Clique em Luke, o botão aqui, volte para baixo, clique
em desclicado. E como Luke,
vou copiar colar todo
esse código
novamente, copiar colar. E vou defini-lo
para olhar aqui. Então, quando clicamos em loop,
ele vai gerar um visual. Quando clicamos na
serina, isso vai patrocinar arena. Então, vamos passar pelo código. Então, quando clico, vou
selecionar meu personagem. Vou executar essa função. Esta função está no
final, o controlador do jogador. Então eu vou executar essa
função, este evento aqui, selecione o personagem vai
passar pelo servidor. Os servidores, em seguida,
passarão pelo modo de jogo. E ele vai
solicitar um jogador. E novamente, quero
transformar isso em uma função Blueprint
Interface, como você pode ver aqui
no modo de jogo, esta é apenas uma
função normal por enquanto. Assim, podemos ver que leva
um pouco de tempo para criar as funções de
interface, mas muito bom fazer isso e mantém seu projeto
otimizado e limpo. Então solicite o jogador de geração, vamos voltar para
a função ou interface de interface do modo de jogo. Vamos chamá-lo de jogador de geração de
pedidos. Assim mesmo. E para este que adicionamos, vamos voltar ao modo de jogo. Adicionamos o controlador do jogador. Adicionamos o ator
como jogador. Adicionamos os locais de desova. Então, deixe-me excluí-lo por enquanto, compilar salvar e vamos voltar. Só estou
excluindo-os antes de
fazê-los para que não fique escutado. Então, aqui vamos criar três variáveis
diferentes. Um era o controlador
do jogador, o outro era o jogador. E o terceiro foi
o local de desova. No local do spawn há um vetor e o
jogador era um ator. E é a referência da classe porque queremos
gerar o jogador. O controlador do jogador
é o nosso PC Maple Story. Agora, esta camada de
geração de uma solicitação, vou
chamá-la aqui de camada de
geração de solicitação , Indie Game Mode. E agora podemos
reconectá-lo assim. Portanto, o alvo é o controlador do jogador e
este no local. Certo? Então, antes de clicarmos em Serena, ele vai
passar pelo modo de jogo. Aqui está o
controlador do jogador, desculpe, essa carga
elétrica vai passar
pelo servidor e agora precisamos
chamar a correta aqui. Se eu excluí-lo, precisamos chamar o player de geração de solicitações
porque acabamos de fazê-lo. E vou selecionar
esta mensagem. Lembre-se de selecionar a mensagem quando for uma função de interface. Você também pode ver esse ícone quando ele atinge uma função de interface. E, novamente, reconecte esses. E agora você tem que definir
o que é o controlador do jogador. Porque mesmo que
no modo de jogo você tenha chamado o
controle da placa aqui e chame essa função aqui. Você realmente não definiu
o que é o controlador do jogador. E vamos voltar. Agora. Isso está vazio agora. Então, vamos arrastar disso. Lembre-se de que estamos dentro
do controlador do jogador. Podemos simplesmente arrastar e dizer a si mesmo. Estamos falando de controlador de
exibição aqui. Então, ele vai
passar por esse evento. E, em seguida, no modo de jogo, solicite o jogador de geração,
ele vai embora. E nós o executamos
pelo modo de jogo porque não queremos que
o cliente traia. Estamos verificando tudo isso e ele vai voltar para
o reprodutor, para o controlador do jogador. Vai gerar o jogador. E isso
gerará um jogador aqui. Agora, em vez de um pequeno
player, novamente, podemos transformá-lo em uma função de
interface. Então, ele contém o jogador como a
transformação do ator e da geração. Indo excluí-lo, vá para a interface
do controlador do player. Eu sei que há muitas
coisas acontecendo, mas se você derrubar isso, tente assistir a este vídeo
duas ou três vezes, você terá um like, você
será um especialista nisso. Então tente praticar e
sei que é difícil, mas uma vez que você vê isso
duas ou três vezes, isso ficará muito mais fácil. Eu tive um momento difícil quando
comecei a fazer tudo isso. Então, vamos fazer o jogador de spawn. E nós tínhamos, agora quase esqueci, tínhamos o jogador como ator e também tivemos a transformação de
desova. Então isso foi uma transformação e
o jogador era um ator, e era uma referência de classe. Ok, então vamos voltar ao controlador
do jogador e seis
eventos de camada de spawn layer bond layer. E agora podemos conectá-lo aqui. Eu conecto a dose e
conecto isso aqui. E lembre-se que isso
vem do Modo Jogo. Então você também tem que alterá-lo nos modos de jogo,
provavelmente vai para o bug. E lembre-se, também é das funções
da interface. Então precisamos disso,
esse ícone aqui em cima. Então deixe-me
excluí-lo e dizer spawn. Na verdade, deixe-me arrastar
da camada de
geração do controlador do jogador. Agora posso clicar nesta mensagem de
um jogador de geração. E vamos
conectá-los aqui, assim. Então, vamos
gerar o jogador. E vamos voltar para o controlador do jogador e ele
vai gerar o jogador. Ok, então quando geramos um jogador, temos que fazer uma última coisa. Temos que usar algo
chamado processo porque você
gerou o jogador, mas você não disse ao
motor que deseja controlar esse jogador e isso
é o que chamamos de possuir. Então, vamos
fazer referência à base de jogadores. É isso que precisamos, porque precisamos nos referir
a um ator. O que você está tentando controlar? E estamos
tentando controlar isso, esse ator gerado que é uma base de jogadores
agora porque agora nós o geramos. Aqui. Agora temos a
referência à base de jogadores. E acredito que não
fizemos uma interface para isso. Na verdade, temos
uma base de jogadores. Vamos entrar daqui. E
vamos fazer um novo novamente. Digamos que obtenha representante de camada. Então, estamos recebendo a referência
do jogador exatamente como o que fizemos com o
controlador do jogador e o modo de jogo. E estamos tentando fazer
referência à base de jogadores bp. Aqui, vamos chamá-lo de camada. E novamente, lembre-se de
voltar para a base de jogadores, voltar para o jogador, base de jogadores. E dentro daqui, encontraremos o Get Player ref. Assim como antes,
o que é o jogador? O jogador é eu mesmo. Então, seja qual for o projeto em que estamos. Agora, o que estamos tentando fazer é aqui no controlador do
jogador. Então, precisamos fazer referência
à base de jogadores. Então obtém a camada REF. E isso ocorre porque agora
este é o jogador, este é o ator,
mas você tem que
definir isso, pois este
é o jogador. E como jogador, eu quero possuir
essa resposta jogadores. Então você tem que fazer isso no Blueprint para poder
informar o mecanismo. Sim, eu gerei o ator, mas na verdade quero
controlar esse ator também. Ok, então agora
fizemos tudo isso. Então, muito código neste vídeo, peço desculpas por
torná-lo muito longo. Sei que às vezes fica agitado, mas não conseguimos
torná-lo mais curto na verdade. E tentei explicar
tudo o que passei. Mas agora que clicamos
em jogar e
clicar no botão, você está
realmente gerando. Mas essa interface do usuário ainda
permanece na tela. E vamos passar
para a próxima lição em que removemos essa interface do usuário.
39. Como remover a IU do Viewport: Agora que terminamos
nossa seleção de caracteres, vamos prosseguir e remover
a interface do usuário de seleção de caracteres. Então, quando clico
no botão agora você pode ver que a interface do usuário
ainda está ficando aqui em cima. Então, vamos remover isso primeiro. Vamos até a interface do usuário e
o blueprint do widget aqui. Então, quando clico em Serena, quando seleciono meu personagem, quero remover a interface do usuário. E isso é muito
fácil de fazer porque agora configuramos tudo. Eu posso pegar este controlador de
jogador, o que estou
tentando fazer. Lembre-se, adicionamos
o widget aqui. Adicionamos widget inicializado. Adicionamos o widget de
seleção de caracteres. Em vez de adicionar duas viewports, há algo
chamado removido dos pais e é isso
que estou tentando fazer. Então, preciso obter uma
referência para essa variável dentro
do Blueprint do Widget. Então, já temos
este e temos a camada get control
nossa referência. Então, já temos a referência
do controlador do player, para que possamos
chamar essa variável facilmente. Temos acesso a
esse blueprint. Agora, se eu arrastar para fora
disso e disser WB, e você pode ver que
temos essa variável que tínhamos aqui, obterá a seleção de caracteres WB. A única coisa que preciso fazer
é dizer remover dos pais. É assim que você remove a
interface do usuário da janela de exibição. Tão muito fácil, muito curto vídeo. Vou copiar colar
isso para Luke também. Então, copie colar aqui em baixo. E vamos
conectá-lo assim. Então agora estamos movendo Dui. Vamos ver o que acontece. Se eu clicar em Jogar agora, seleciono o personagem. Você pode ver que estou
realmente gerando. Nós realmente não definimos
um ponto de desova ainda. E se eu abrir minha
outra tela aqui, o cliente, e se eu
clicar em loop, por exemplo, você pode ver que eu também desova como Luke e eu criei
como czarina aqui. Agora, o local
para, como você pode ver, os pés estão escutados e isso
é porque ainda não definimos um local de desova. E você também pode ver que nós geramos
como o personagem aqui. E isso é porque agora
temos que
ir novamente, já disse antes, nas configurações do projeto e
nos mapas e modos
e no modo de jogo. Agora que temos uma tela de seleção de
caracteres, podemos remover essa classe de ponto
padrão. Não queremos gerar
como nenhum personagem. Só queremos selecionar Nenhum. E selecionamos nosso próprio personagem na tela
de
seleção de personagens. Portanto, não queremos gerar
com um personagem pré-fabricado. Vamos fechá-lo
e vou
salvar tudo para ter certeza de que está funcionando. E eu vou para as configurações
do mundo e apenas me certificando nas configurações
do mundo que o Modo de Jogo também não
diz nada aqui. Agora, quando clico em
jogar e gerar como olhar, por exemplo, você pode ver que não temos
um personagem aqui, mas como não estamos
surgindo lá por padrão, agora isso está funcionando. E a próxima coisa que queremos fazer é criar um local de desova, porque agora não
temos um local de desova. Estamos apenas
gerando do nada aqui. Então, queremos adicionar
um local de desova, e isso é o que
faremos na próxima lição.
40. Como criar a localização do spawn: Então, para este
local e queremos gerar o jogador no início
do jogador. Então, antes de funcionar, porque definimos essa cláusula ON padrão para
um dos caracteres. Mas agora, quando
você gera um player na interface
do usuário aqui nos blueprints do
widget. Se você for novamente para o
gráfico, como você vê aqui, quando geramos o jogador, nós os geramos em zeros, zeros 0. E é por isso que eles
estão respondendo aqui. Para o canto superior esquerdo. Temos que definir para
gerá-los aqui no início do jogador. E eu quero criar
pontos de geração no modo de jogo, porque lembre-se que o modo de jogo
só é executado no servidor para que o controlador do jogador trapaça se algo
estiver dentro daqui. Esse é todo o
propósito do multijogador. Estamos tentando
parar de
enganar aqui no
início. Então, quando começamos a
jogar o jogo, quero definir esse último
ponto como meus pontos de geração. Podemos dizer que você recebe
ator da classe. E o que isso é o
ator da classe, ele permite que você obtenha o que já foi gerado
dentro do nível. Muito, muito
importante lembrar o que já foi gerado
dentro do nível. Este início do jogador já foi gerado e podemos
tentar procurá-lo. Então, consiga o ator da classe, podemos obter o que já foi gerado e você pode
procurar por partidas de jogadores. E você pode ver aqui, o jogador começa, você pode selecioná-lo aqui. Então, ele vai selecionar
um jogador começa, vai ser
muito mais difícil. Então imagine se tivéssemos estatísticas de
vários jogadores, então você tinha que definir qual
deles você está tentando obter, porque agora ele está
recebendo um de um aleatoriamente. Mas isso está tudo bem por enquanto, para esse propósito, estamos apenas
sendo deslocados aqui. Nós só temos um ponto
ponto no momento. Então, vamos compilar e salvar. Então, à medida que esse jogador começar, vou colocar o local dos atores para o
local. E então eu vou
transformar isso em uma variável, promover para uma variável e
chamá-lo de local de geração do jogador. Ok, então agora
temos essa variável, localização de geração
do jogador
dentro do modo de jogo. Então, agora temos
este único local. Agora podemos usá-lo
dentro do jogador. Então, dentro da base de jogadores, dentro do gráfico de eventos aqui. Então, agora podemos gerar o jogador naquele local que
criamos no modo de jogo. Então, quando nós geramos o
jogador no topo aqui, antes de eu fazer qualquer coisa,
digamos que sets. Na verdade, vamos criar
uma variável personalizada. Vamos chamá-lo de definir o local de geração do
jogador. Então, vamos definir
esse local de vínculo dentro do jogador aqui. E eu quero executar isso
pelo servidor. Portanto, não é trapaça. E dizendo que os servidores definem o brilho, geram a localização e o
executam pelo servidor, executados no servidor, confiáveis. E o que estamos tentando
fazer é que estamos tentando dizer, como tentamos usar esse
chamado set actor location. Esta é a função definitiva que
estamos tentando usar, definir a localização da atriz. Lembre-se, você tem que fazer isso
dentro de uma costela. Notificar. Porque lembre-se
exatamente como o que
dissemos antes na função
unwrap, isso será atualizado para
todos os clientes porque agora você está executando
isso através do servidor. Então, o que estamos tentando fazer aqui, então vamos fazer isso
e talvez seja muito mais claro se fizermos isso
primeiro aqui, o que estamos tentando fazer
é que estamos tentando obter este último
local do jogo modo. Então, assim como o que eu disse
antes, obtenha o Modo de Jogo. E então você pode dizer que
obtém o gráfico de quimioterapia, que criamos anteriormente. E agora, como o modo de jogo, você pode pegar este
chamado último local ósseo. Agora temos essa
variável dentro daqui. Na verdade, vamos clicar com o botão direito do mouse e promovido para uma nova
variável dentro daqui. E eu vou
chamá-lo da mesma coisa, local de geração do jogador. Mas desta vez, já que
estou no servidor, vamos agora replicá-lo para
os clientes porque vamos realmente executar isso aqui
e posso dizer o porquê. Então, o jogador do servidor define a localização do
plasmon. E vamos fazer o jogo inicial. E quando eu começar a jogar o
jogo e o Begin Play, ele será executado sempre que você
gerar o personagem. Então, quando clico no jogo, o jogo inicial para o
personagem ainda não jogou. Mas e se eu clicar
no jogador? Agora, o jogo
inicial vai jogar. Então, sempre que eu gerar meu
personagem, isso será lançado. Então, para começar a jogar, sempre que eu
gerei
o personagem, quero imediatamente definir
a localização do jogador. Portanto, define a localização da camada, localização da
geração,
na verdade, não a localização. Então, o local de geração do jogador. E vamos transformar isso em
uma Interface de Blueprint também. Então defina a localização de geração do jogador. Vamos excluir este aqui
da base de jogadores e
vamos para a base de jogadores da interface. Vamos fazer uma nova função chamada set player spawn location. Vamos voltar para a base de
jogadores e dizer Definir locais de vínculo de camadas. Então, vamos chamar esse evento. E conectado aqui. Quando comecei a jogar o jogo, chamarei esse
evento aqui. Então defina o local de geração do jogador e, em seguida, ele passará pelo servidor e
pelo servidor. Vai obter
os modos de jogo. Os modos de jogo geram a
localização aqui. E vou definir
a variável aqui. Mas lembre-se, você está executando
isso pelo servidor. Portanto, o cliente não tem
chance de saber o que é
essa variável porque ela só
está sendo executada no servidor. Então, apenas o servidor que você pode ver aqui eu sou o servidor agora. Somente o servidor sabe
o que está acontecendo agora, o cliente não consegue ver
o local de geração. E assim como o que eu disse
antes com o multiplayer, você precisa replicar essa
variável de volta para o cliente. Portanto, quando o servidor
terminar de fazer a lógica, a lógica precisa ser replicada de
volta para o cliente. Portanto, os dados precisam
voltar para os clientes. E assim como o que
fizemos com o estado de humor, fizemos isso na função de rampa. Podemos clicar nessa variável
e replicá-la de volta
aos clientes com a notificação do representante. Então, vamos notificar
todos os clientes. E novamente, eu
te disse antes de usarmos o representante notificar sempre que
temos mudanças visuais, e é uma mudança visual, estamos respondendo ao personagem, estamos movendo o personagem disso ponto onde
responder ao personagem. Então, neste ponto aqui,
então é uma mudança visual. Então você precisa definir essa mudança visual para que todos
os clientes possam vê-la. Vou fazer uma notificação de costela, que todos os clientes possam vê-lo. E o que queremos
fazer aqui e
a localização de
vínculo de letras na rampa. E, na verdade, apenas para o meu TOC, vejo que há
espaços entre aqui. Só vou
excluí-lo novamente. Quero mudá-lo
antes de fazer qualquer coisa. Vou remover esses espaços
aqui na minha variável. Assim. Vou pressionar novamente na retina ossify,
assim. Agora, aqui na função de desembrulho, vamos agora tomar na verdade, já estamos dentro
do personagem, então podemos dizer
definir a localização do ator. Isso é o que queremos fazer. Então, a localização da atriz
e a localização são, queremos configurá-lo para
este local atualizado, que esse jogador gere a localização. Então, vamos aqui
para a função unwrap. Arraste este local de plasmon. Acabei de conectá-lo
no novo local. Portanto, este é o novo local para o qual
queremos definir o ator. Agora, todos os clientes
poderão ver que o personagem está mudando de
posição para esse novo local. Então agora vamos clicar
em Play e ver o que acontece se tivermos
estragado algo. Então, clicando em jogar aqui, e você pode ver que agora estou gerando aqui,
então isso está funcionando. E se eu voltar para
Luke Lips para olhar, então esses são os clientes. Vamos dar uma olhada, por exemplo. Você pode ver agora isso realmente surgindo corretamente
e eu posso jogar como se eles
pudessem jogar juntos sempre bem para testar e ver se ele está
com bugs não. Antes de continuarmos. Você pode ver que isso está funcionando,
respondendo corretamente. Então, só para passar por
isso muito rapidamente, porque às vezes estou preocupado que
isso possa ser confuso. Então, vamos começar aqui na interface do usuário. Aqui clicamos em
Serena, por exemplo. Deixe-me arrastá-los para
mais perto um do outro. Então aqui clicamos na
serena para patrocinar a arena. Ele vai para o controle do jogador e
selecionará o personagem. Então, ele vai executar
este evento aqui. E também
removerá a tela de seleção de caracteres. Então, ele vai para esse personagem
selecionado para o controlador do jogador. Então, vamos ao controle
da placa e
ver o que está acontecendo. No controlador do jogador,
que está aqui. Ele está executando este
Select Character Event o personagem selecionado está
passando pelo servidor
e, em seguida, o servidor
está chamando esse evento aqui
no modo de jogo porque
queríamos evitar trapaça, queremos verificar
se temos permissão para gerar
o personagem. Passando por ele novamente
, solicita um jogador de títulos. Ele está passando
pelo modo de jogo. E então ele vai nos jogar volta para o controlador do jogador. E no controlador do jogador, vamos
gerar o jogador. E vamos controlar
o jogador também. Sempre que você gera o jogador, ele executa este lugar inicial. Então, sempre que o
jogador aparecer, ele definirá o local de geração
do jogador. Ele está executando este evento aqui, e esse evento está
passando pelo servidor. Mais uma vez, estamos impedindo o
recuso de trapaça. O servidor. Precisa verificar se o que
você está fazendo está correto. Assim, você pode ver o
método aqui é onde tudo que
estamos sempre tentando definir
variáveis através do servidor. Então, vou pular
direto para o servidor. E então um servidor sem fim, estou fazendo toda
essa lógica de codificação. Servidor. Ele vai definir a localização
do local. Na verdade, ele chegará à localização
do jogador a
partir do Modo Jogo, que inventamos aqui. Então, começamos essa peça
de aula de ator e conseguimos
o local de acesso e a transformamos em uma variável. Então, agora sabemos que o local
específico para este jogador começa aqui. E agora temos
isso, aquele local para esses pontos de desova. E então nós o
transformamos em uma nova variável dentro da base do jogador e chamamos o local de
geração do jogador. Agora o replicou
em uma notificação de rip, que leva você para
a função unwrap porque
toda vez que você altera o valor ou uma função de
notificação de repetição é uma variável de notificação de naufrágio. Ele executará a função
de notificação do representante. Então agora você pode ver que
definimos essa variável. Então, automaticamente,
vamos
executar esta função de desembrulho. E a única coisa que está
desembrulhada é fazer
é definir a localização dos nossos atores. Novamente, estamos usando uma
notificação de representante porque é isso
que fazemos no multiplayer. Sempre que você tiver alterações
visuais e alterar a localização
de um jogador desse ponto para este ponto
é uma mudança visual. Todos os clientes podem ver a mudança visual fazendo isso, assim como o que fizemos
com o estado do movimento. Então nós dissemos os flip books. Essas também são mudanças
visuais. Então, mudando os flip books para que
o jogador possa ver o flip book
alterado. Isso também é uma mudança visual. Então, espero que isso tenha sido claro. Novamente, se algo
é confuso e você precisar de algo para ser
esclarecido muito mais, você é bem-vindo para se juntar ao
meu servidor Discord, e estou mais do que
feliz em ajudá-lo. Então, vamos continuar a partir daqui. Vamos salvar tudo. Deixe-me fechar isso e vamos passar para
a próxima lição.
41. Como criar o ator da câmera: Então, como você pode ver
aqui agora, estou dentro da Maple Story e da câmera e
Maple Story lá. Não é como o nosso
agora você pode ver
quando eu me movo, a câmera está
seguindo sem problemas. Não está realmente ligado
ao personagem. Então, quando estou me movendo por aqui, você pode ver que ele está me seguindo, mas não está realmente
ligado a mim. Então, ele se move como esse movimento
suave. Então é isso que estamos
tentando alcançar. Então, de volta aqui no nosso jogo, em vez de ter a câmera conectada aqui e
a base de jogadores. Portanto, atualmente temos essa
câmera conectada ao player. Temos que criar
câmeras separadas para que possamos seguir o jogador sem problemas. Agora, é claro, você pode
manter a câmera assim se
este for o
lugar que você quer, mas estou tentando
replicar Maple Story o
máximo que puder para que possamos
praticar a partir disso também. Então, vamos começar criando
o ator da câmera. Então, em vez de ter
a câmera conectada, vamos transformá-la em um
plano. Então clique com o botão direito, faça
uma classe de blueprint. E vamos fazer um ator. E vamos chamá-lo de câmera BP. Ok, então
clicando aqui, câmera VB. Vamos novamente subir aqui
e adicionar as câmeras. Então, primeiro, como antes, vamos adicionar uma mola sobre eles. Então este é o suporte
da câmera. E então vamos
adicionar a câmera. Então, como antes,
nada de novo. Clique no
braço da mola. Vou girá-lo menos 90 graus, assim como antes,
Compilar e Salvar. E eu vou remover este chamado Remote fazer testes de
colisão. Vou clicar na
câmera e alterá-la para uma visualização ortográfica e
definir a largura para 1304. E isso não é
realmente algo novo. Isso é o que também tínhamos
feito aqui em nossa câmera. Então, essas são apenas
as mesmas configurações que
estou tentando seguir. Ok, então agora temos a
câmera e eu vou para minha base de jogadores e vou
excluir esta câmera agora. Então, agora que
criamos uma câmera, podemos gerá-la
na próxima lição.
42. Como criar a câmera: Então o que estamos
tentando fazer é que estamos tentando agora gerar
o ecto da câmera. E o objetivo é aparecer na câmera
toda vez que
um novo jogador se liga. Então, vamos fazer a
lógica de desova dentro dos jogadores. Então, sempre que os laços do jogador
entrarem no nível, eles vão, haverá uma câmera
gerando para que ela
possa seguir esse jogador exatamente
como o que tínhamos antes. Então aqui novamente,
no início, então é quando nosso
jogador vai aparecer. Aqui vamos
dizer ator de spawn. Muito bom lembrar de
todas essas ferramentas. ator Spawn é usado sempre que
você gera alguma coisa. Assim como no controle do jogador, onde
geramos o jogador. Você pode usar esse ator ósseo
novamente para gerar a câmera. Então, digamos gerar
ator de classe. E anteriormente eu disse
que temos que
passar pelo modo de jogo para gerar algo para evitar trapaças. Isso está tudo bem agora
para que esta câmera faça isso diretamente
do cliente também. Porque esta câmera
é apenas baseada em jogadores. Não é algo global, como adicionar jogadores
ao nível. Estamos apenas adicionando uma câmera para que
o jogador seja
seguido. Gerando um ator aqui. E temos que escolher
a câmera e
chamamos de câmera BB, BP. Então, apenas procurando por câmera. E esta câmera BP aqui. Agora temos que selecionar a transformação do
spline. E vou dirigir
daqui e clicar em Make transform, assim mesmo. E agora temos que definir em que local
queremos gerar essa câmera. E eu só quero gerá-lo
na localização do jogador. Então, já estamos
dentro do jogador. Então, podemos dizer
para obter localização do ator. E o alvo é
eu mesmo porque esse é o personagem que estamos controlando
atualmente. Então, estamos recebendo esse
personagem gerado e estamos
indo para esse local desse personagem
de vínculo. Vou mover isso
um pouco para cá. A rotação é esta
e a escala é essa. Isso realmente não
importa agora. E quanto à desova, quero clicar aqui, e vamos clicar
neste dizendo tentar
ajustar a localização,
mas sempre gerar. Isso só garante que,
mesmo que estejamos
colidindo com alguma
coisa, em algum momento, estamos apenas gerando
a câmera de qualquer maneira. E, na verdade, acho que
temos que fazer isso no controle da placa também. Aqui, se você ainda o tiver por padrão para o jogador, lembre-se de configurá-lo para tentar ajustar a localização
, mas sempre gerar. Isso nos impedirá de o jogador não seja
capaz de surgir em algum momento, mas estamos tentando ajustar o local, mas ainda assim
gerando o jogador. Essa colisão será
um problema como padrão, assim sempre que
tivermos inimigos, porque haverá inimigos
e você estará colidindo. Portanto, sempre vínculo mesmo
que tenhamos alguma colisão
tentando ajustar a localização. Certo, vamos voltar
para a câmera aqui. Então agora nós
geramos a câmera. Agora você pode ver aqui, mesmo que tenhamos
gerado a câmera e eu vou clicar em jogar. E também lembre-se de remover a câmera aqui se você não tiver feito isso
na lição anterior. Então, removendo a câmera, gerando uma nova câmera. Vamos tentar clicar em Jogar agora. E agora você pode ver aqui que,
mesmo que tenhamos
gerado a câmera, ainda
estamos embarcados
aqui na vista. E isso ocorre porque,
mesmo que você esteja gerando uma câmera, você precisa, você precisa dizer ao
motor que deseja que a nova câmera
seja sua nova visão. Então, se você se arrastar para fora disso
e disser Definir destino de visualização, você
pode ver, você realmente não pode ver nada, mesmo
que esteja procurando por ele. Mas se você remover o
contexto sensível, poderá ver que este
é o que estamos tentando usar. Defina sua meta com Blend. E por que isso está acontecendo? Por que não está
aparecendo aqui? Você pode ver se você segura
o mouse sobre ele. Diz que o alvo
é um controlador de jogador. Sensível ao contexto
significa apenas para o contexto aqui, para esta caneta que você está
arrastando. Este não é realmente um controlador
de jogador. Esta é a câmera. Então, se você estiver procurando por algo que precisa de controle de
suprimento, não
vou mostrar a você menos que você remova esse
contexto sensível. Mas, no entanto, se você conseguir
o controle do jogador, então vamos tentar o outro lado. Digamos que seja controlador. Então é assim que você obtém
o controle do jogador. No multijogador,
você está dentro
do jogador e apenas
diz obter controle. E diz que retorna
controlador para este ator porque queremos
nosso controlador de jogador aqui. Temos o controlador
e vamos usar o
controlador get black REF que
criamos com nossa
interface anteriormente. Então, digamos que o
controlador do jogador ref. Agora estamos falando especificamente
sobre esse controlador. Agora vamos conectar isso juntos. E a partir daqui, como o controlador
do jogador, podemos dizer definir o alvo de visualização. Você pode ver, eu posso vê-lo com a edição sensível ao contexto
e isso é o que significa. Agora ele sabe do que
você está falando porque o alvo é
o controlador do jogador. Então, algo que
você precisa estar ciente. Agora, vamos
clicar neste aqui diz Exibir destino com mistura. Agora ele precisa de um novo alvo de visualização. E a nova visão Chocolate
é apenas essa câmera. Só para fazer tudo como você pode pegar isso e se
conectar aqui, isso não é problema.
Isso funcionará. Mas às vezes eu gosto de organizar as coisas e gostaria de
transformá-las em variáveis. Então, vou
clicar com o botão direito do mouse aqui e promover para variável e
chamá-lo de câmera preta. E, na verdade, eu já
o criei anteriormente que eu
estava testando algo. Então deixe-me apenas
excluir o antigo, compilar e
deixe-me fazê-lo novamente. Câmera de camada. Ok, então agora deixe-me conectá-lo. E agora, como essa variável, você pode simplesmente saber
que você tem a variável. Você pode simplesmente
clicar e arrastar essa variável e
conectar-se assim. Então você pode
fazer isso assim ou você pode fazer assim, que ambos funcionam. Essa é a maneira correta. Às vezes
, gosto de fazer isso separadamente assim para
deixar tudo mais limpo. Novamente, não há problema em definir essa variável mesmo que
estejamos executando a partir do cliente, então não estamos executando no servidor,
o que eu disse antes. Temos que definir
variáveis no servidor. Estou definindo essa variável
específica
no cliente porque esta
é do lado do cliente, a câmera que seguirá
ao redor do personagem só será
vista por esse personagem. Todos os outros personagens, todos os outros clientes realmente
não se importam personagem
do jogador ou com
a câmera do jogador. Em vez disso. A câmera do jogador é
algo especificamente para você e todos os outros jogadores realmente
não se importam com isso. Assim como a interface do usuário,
a interface do usuário, sua interface de usuário, outros
jogadores não se importam com isso. Eles têm suas próprias interfaces. Ok, então temos essa câmera. Agora definimos o alvo de
visualização com a mistura. E vou organizar
isso um pouco melhor, assim antes
que fique muito confuso. Então, algo assim
aqui e eu vou puxar isso mais perto assim. Ok, então vamos agora
clicar em Compilar, Salvar e clicar em jogar
e selecionar um personagem. Você pode ver mesmo que
tenhamos o código, eu sei que temos o
código corretamente, mas você pode ver que ele
ainda está confuso. E por que isso? Isso ocorre porque
às vezes é preciso, você pode ver aqui que diz
erro ou às vezes leva um segundo
para um personagem aparecer no multiplayer, há um pequeno atraso. E esse código,
todo esse código aqui, é executado tão rapidamente, é insano. Então você tem que dar tempo, às vezes para o
personagem aparecer. Então, aqui estamos definindo o local gerado dos jogadores
sempre que os títulos do jogador, eu vou colocar um nó de atraso. Então, vamos tentar puxar
aqui e dizer atraso. E às vezes isso
é tentativa e erro. Sei que esse código está correto, então às vezes fico confuso. Por que isso não está funcionando? E eu poderia pensar que há um pequeno atraso da
geração dos jogadores para realmente
adicionar a câmera. Portanto, não consegue, não consegue
encontrar o jogador. Isto é, está
tentando gerá-lo aqui, mas não consegue encontrar o controlador do
jogador porque você tem que
dar algum tempo aqui. Então, vamos atrasar em 0,05. Atraso muito, muito pequeno. Se você escrever um, isso
significa que é 1 segundo. Então, 0,05 segundos. Então, muito, muito leve atraso aqui. Vamos clicar em Compilar e Salvar, e vamos tentar
clicar em Jogar agora, clicar no personagem e você pode ver a desova do
personagem. Então, o atraso ajudou muito aqui. Vamos tentar gerar o cliente. E o cliente
também está gerando e apenas para se certificar de que
eles se vejam. Se eu fizer isso menor. Sim, então tudo está funcionando
e apenas tentando surgir. Agora recebemos um erro. Vou tentar ver o que é isso. Vamos tentar clicar
em Jogar agora e sair como servidor
e olhar aqui. aparência também pode surgir. Ok, então recebemos um
erro aqui e eu quero tentar ver por que
recebemos esse erro. Ok, então às vezes
o código é executado muito rápido aqui, então, em vez disso, jogamos aqui para não
termos nenhum erro. Então, tudo está
funcionando perfeitamente agora. E às vezes o código é executado
rápido aqui e
não conseguirá encontrar não conseguirá encontrar o controle da bexiga que
outra variável esteja vazia. Então aqui o que
queremos fazer para
garantir que isso não
aconteça. Vamos agora arrastar
daqui do
controle do jogador e dizer que é válido. E você pode selecionar
esse ponto de interrogação. Portanto, se o
controlador do jogador for válido, podemos ir em frente e
definir esta câmera. E se não for válido,
não faça nada. Então, podemos tentar fazer isso aqui, e isso corrigirá o erro. Então, vou clicar
duas vezes neste pino. Portanto, não é muito confuso. Só para organizar as coisas
aqui em baixo, algo assim. E vamos tentar executar
com esse código em vez disso. Então, vamos compilar salvar. Então, agora, se este
controlador do player for válido, vamos em frente e
criar a câmera. Caso contrário, não vamos fazer
nada que impeça que ele dê esses erros
quando as variáveis estiverem vazias. Vamos clicar em compilar. E agora vamos clicar em
Criar este personagem. Vamos criar o Luke. Veja que tudo está
funcionando sem problemas. Vou clicar em
Control ou escapar. Você pode ver que não recebemos erros. Agora, também é muito bom verificar
se algo é válido. Você também pode fazer isso com variáveis às vezes
quando você precisa. Então, se eu apenas puxar esta
câmera para ciência, podemos clicar com o botão direito do mouse nela e podemos clicar em Converter
para validar, obter. Isso também funciona. Então poderíamos realmente ter feito essas linhas de controle de placa para uma variável e podemos
verificá-la assim. Se o controlador do jogador for
válido, você pode fazer alguma coisa. Se não for válido,
isso não faz nada.
43. Como atualizar a posição da câmera: Agora é hora de atualizar
a posição das câmeras. Você pode ver aqui quando
clicamos em Jogar agora, podemos ir com o personagem,
podemos nos mover, mas a câmera é estática e não está
seguindo nosso personagem, e é isso que queremos. Então, vamos voltar para
a base de jogadores, e vamos fazer essa
lógica dentro daqui. Então eu tenho duas novas
ferramentas para te ensinar. É sobre temporizadores e
é sobre uma linha do tempo. Então, duas
coisas muito essenciais no Blueprint. Então, vamos fazer isso aqui
no início. Então, sempre que começamos
a jogar o jogo e
geramos a câmera, e nos anexamos, nossa visão para essa câmera. Vamos também avançar e atualizar a visão da câmera para que ela acompanhe o
player o tempo todo. Agora, antes de fazer um temporizador, eu realmente quero
fazer um sinal de evento. Eu queria te mostrar
isso e antes de
te dizer para nunca usar
este evento de tick, porque isso corre 60 vezes por segundo e seu jogo não
será otimizado. Você pode fazer muito melhor
do que usar isso. Vou usar isso
agora e
vamos alterná-lo com um temporizador. E isso é o que eu
te disse antes. Você pode fazer outras coisas além de
usar um carrapato em alguns momentos. E o que quero dizer com isso é
que você pode usar temporizadores para evitar o uso de textos que
executam seu código 60
vezes por segundo. Assim, podemos usar temporizadores
para evitar isso. Mas vamos usar um carrapato agora. E posso mostrar
como mudamos isso mais
tarde para que você
possa aprender com isso. Então, o que estamos
tentando fazer essencialmente é que estamos tentando obter uma câmera de
exibição que temos. Esta é a câmera
que geramos aqui. Estamos tentando pegar essa câmera e apenas
definir a localização dela. Então é isso que estamos
essencialmente tentando fazer. Estamos tentando definir
a localização dele para a localização do jogador. Então, se tornarmos muito, muito fácil, podemos apenas
dizer obter localização real. E a localização real é auto, que é esse jogador. Portanto, a nova localização
desta câmera é a localização do
jogador. Então, ele seguirá
o jogador o tempo todo. E como isso corre
60 vezes por segundo, ele seguirá
constantemente o jogador. Agora, vamos clicar em jogar aqui. E você pode ver
quando eu corro por aí, agora estamos seguindo o
jogador como antes. Então, isso é essencialmente
o que estamos tentando fazer. E é claro que
isso lhe dará um erro porque você está essencialmente
executando este evento antes de executar este,
esta câmera, responda a
essa câmera aqui. E você pode evitar isso novamente, assim como o que eu disse
no vídeo anterior, você pode converter isso
para uma validação que obtém. Se for válido, você pode ir
em frente e atualizar a câmera. Certo? Então isso corre, nem tome, isso é executado 60 vezes por segundo e está
seguindo nosso personagem. Mas queremos esse movimento
suave. Não queremos que ele siga o personagem como antes. Porque
já fizemos isso antes. Queremos seguir o
personagem sem problemas. E para seguir
algo sem problemas, você pode usar uma linha do tempo. Porque a linha do tempo você
precisa pensar
nisso sempre que
quiser passar de 1 do ponto a para o ponto
B de forma suave. Por exemplo, se você estiver
abrindo uma porta dupla, você está abrindo as portas
duplas suavemente, ou mesmo apenas uma única porta se você estiver abrindo
a porta única. Então movendo a porta do
ponto a para o ponto B, Isso é movimentos suaves que
você pode fazer com linhas do tempo. Por exemplo, se você
jogou a história de Maple, quando você solta itens ou quando você mata algo e
eles soltam itens, eles o deixam cair aqui, como o item voa para o ar
e cair no chão. Esse movimento suave
também é uma linha do tempo. Portanto, qualquer movimento suave
do ponto a ao ponto B, você pode usar uma linha do tempo. Então, vamos procurar a linha do tempo
e vamos aprender sobre isso. Então, vamos clicar aqui na linha do tempo, e vamos dar um nome
e vou
chamá-lo de layout, posição da câmera. E clique duas vezes
nesta linha do tempo. E dentro dessa linha do tempo, podemos adicionar uma nova faixa. E o que queremos
adicionar é simplesmente um flutuador. E posso mostrar por que
estamos adicionando um flutuador. Flutuar novamente, assim como
a variável aqui embaixo, à tona é apenas um
valor numérico com casas decimais. Isso é simplesmente o que é. Então, por exemplo, 25.2
e isso é um flutuador. Então deixe-me excluir
este aqui em baixo. Então, vamos adicionar um flutuador. E vamos tentar. Vamos chamá-lo de movimento alfa. Ok, então deixe-me
clicar com
o botão direito agora no gráfico em dois pontos. E eu quero selecionar isso
primeiro e no momento 0,
então, em 0 segundos, eu queria que fosse 0, então 00. E a duração desta
linha do tempo aqui em cima, quero que você fique apenas 1 segundo. Para o segundo,
no momento 1 segundo, quero que o valor seja um. E você pode clicar
nessas duas setas para
que ela se encaixe na tela aqui. Então, depois de 1 segundo, eu só quero que seja
o valor de um. Ok, então eu posso
mostrar por que estamos fazendo isso e para que
podemos usar isso. Eu também
quero que você clique nisso, use o último quadro-chave como este. Então, vamos voltar agora. Agora
temos essa linha do tempo e você pode ver o movimento alfa, a carga que criamos agora
está sendo mostrada
aqui e podemos usá-la. E o que queremos usar
é algo chamado loop. Então o loop aqui, é. Interpolação linear. E vai do
ponto a ao ponto B. E precisa de um Alfa. E você pode ver que criamos
esse Alfa e o que
isso significa, ele vai suavemente do
ponto a ao ponto B. Então, ele vai
reproduzir essa linha do tempo. Seja qual for o valor que você conecte
aqui do ponto a ao ponto B, ele vai percorrer
desse ponto até este ponto sem problemas,
porque vai assim
até o ponto B. Então podemos imaginar que este é o
ponto a, este é o ponto B. E depois de 1 segundo, ele vai para o ponto B. Movimento
tão suave, este é o alfa aqui, isso
é o que está fazendo. Portanto, temos
que especificar o que é o ponto a e
o que é o
ponto B. O ponto a está onde quer que a
câmera esteja agora. Então, vamos pegar a câmera aqui. E deixe-me puxar
isso um pouco e dizer que fica com a localização do ator. Então, o ponto a é onde quer que
a câmera esteja agora. Na verdade, precisamos de um loop para o vetor porque você
pode ver que este é um vetor, isso é um flutuador, então isso não
está totalmente correto. Então, vamos escrever
um loop, e vamos selecionar este chamado vector, excluindo este. Então, aqui, obtenha a
localização real da câmera. Então o ponto a é onde quer que
a câmera esteja agora, ponto B está onde quer que o
personagem esteja agora. Estamos tentando mover a
câmera de onde ela está
agora para onde quer que o
personagem esteja agora, que tem uma boa localização dos atores. E isso vai acontecer
sem problemas porque temos esse alfa indo do ponto a ao ponto B sem problemas assim. Ok, então deixe-me excluir
tudo isso na verdade, deixe-me excluí-lo. Deixe-me excluir tudo isso realmente vai
fazer isso de novo. Agora, eu quero jogar isso
desde o início aqui. Então não, não jogue aqui. Eu quero sair desta
cidade começar aqui. E agora vamos
conectá-lo aqui na atualização, queremos apenas, novamente, como antes, queremos
definir a localização da câmera. Então defina a localização do ator. O novo local é este. E vamos
atualizar isso como aqui. Então, ele vai
do ponto a ao ponto B sem problemas porque
temos essa linha do tempo adicionada. E por meio dessa atualização, ele atualizará esse local o tempo todo
do ponto a ao ponto B. Então, isso será
atualizado 60 vezes por segundo porque
estamos usando um tick de evento. Então, vamos clicar em Jogar agora
e clicar em Tsarina aqui. Você pode ver quando eu me movo agora, ele está se movendo sem problemas,
assim como em Maple Story. Efeito muito legal. Ok, então agora isso está funcionando
como deveria. Incrível. Então isso foi fácil. E você pode ver, é
claro que estamos recebendo erros porque
isso está funcionando no take e poderíamos ter
evitado isso novamente, tornando este nó válido. Mas não vamos fazer isso. Na verdade, quero
mostrar como não
podemos usar o evento doente porque isso agora está
sendo executado 60 vezes por segundo e você pode
otimizar seu código. Não gosto quando
vejo isso no meu projeto. Então, vamos mover isso
um pouco para baixo. Então, para evitar o uso de tick, você pode usar algo
chamado temporizadores para que ele possa controlar o quanto ele
será executado por segundo. Digamos que defina um temporizador por eventos. Ok, então o que isso
significa agora você tem especificar quantas vezes você
vai executar a cada segundo. Por exemplo, se você escrever um, ele só será executado
uma vez por segundo. Se eu escrever 0,5, ele será
executado duas vezes por segundo porque ele concluirá
esse evento em 0,5 segundos. Se R for 0,2, será executado
cinco vezes por segundo. Então, essencialmente, como você
calcula isso é apenas escrever um dividido por 0 para o
número que você escreveu aqui. E você pode ver que dá cinco, significa
que esse código está sendo executado
cinco vezes por segundo. Se você escrever 0,08, ele será executado 12,5
vezes por segundo. E quanto aos eventos, os ingressos
do evento
em torno de 0,1516. Então este é o carrapato do evento. Está rodando em
0,0017, assim. Então, por exemplo, você pode otimizar seu código
executando-o assim. Portanto, são apenas dez
vezes por segundo em vez de 60 vezes por segundo. Assim, você pode ver que você pode otimizar
as coisas usando temporizadores. Você não pode, você pode optar não executar 60
vezes por segundo. Então, vamos conectar isso aqui. Agora, você precisa de um
evento para executá-lo. Então, aqui o que você pode dizer, você pode arrastar deste evento e você precisa criar um evento personalizado. E vamos fazer esse evento, vamos chamá-lo de atualização da posição da câmera da
camada. Então, agora podemos conectar nosso código. Deixe-me excluir esse carrapato de evento. E deixe-me conectar esse código aqui
a partir do início do jogador. Agora deixe-me clicar em Compilar, Salvar e clicar em Reproduzir. E agora, na verdade, deixe-me
clicar nesse loop, porque se você não
clicar em loop, isso será reproduzido apenas uma vez. Então deixe-me clicar em loop. E se eu clicar em
Jogar agora, minha câmera, está atrasada porque só está me
seguindo cinco
vezes por segundo. Então, só está atualizando nossa
posição cinco vezes por segundo porque
escrevemos 0.2 aqui. Agora, o número que eu
criei é 0,03. Isso foi assim, tornou-o suave e algo acima que o fará
funcionar mais devagar. Se eu tivesse que levar isso aqui. E você pode ver que isso agora está
sendo executado 33 vezes por segundo. Então, muito melhor do que correr
a 60 vezes por segundo. Então, a cada segundo você está rodando 30
vezes menos que um carrapato. Então tente equilibrar
isso e tente ter um equilíbrio entre aparência do
seu jogo e
sua otimização. Então, às vezes, talvez você queira
fazer isso 0,04 em vez disso. E isso faz uma grande
diferença porque se eu escrever 0.04 aqui, então se eu levá-lo aqui, 0104, você pode ver que vai de
33 vezes por segundo, executando o código, que
apenas 25 vezes por segundo. Então, faz uma grande
diferença ir de 0320403 foi o melhor
resultado visualmente também. Portanto, não gosta muito. Então, se eu compilar, salvar
e apenas jogar por aqui, você pode ver que ele funciona bem
como o tick do evento. Mas agora estamos executando apenas 33
vezes por segundo e não
60 vezes por segundo. Então, muito melhor do que antes.
44. Como interromper o movimento da câmera: Tudo bem, então agora vamos ver como paramos o movimento da câmera. Então, quando jogamos o jogo
e vamos para o lado aqui, quero parar os movimentos da
câmera para não ultrapassar essa borda aqui. Então eu quero parar a
câmera em algum lugar por aqui. Então, nunca vamos para o limite. Quando o jogador caminha. De agora em diante até este ponto, a câmera só
vai ser parada e o jogador só
vai andar por aí. Então é assim que
é na Maple Story. Então, vamos ver como
paramos a câmera. E essencialmente tentei métodos
diferentes e sempre tento encontrar o melhor porque não
estou satisfeito, mesmo que dois deles
estejam funcionando. Tentei encontrar o melhor
se fosse eu fazendo meu jogo. E qual seria a
melhor solução para isso? Então, o melhor
para isso é que podemos adicionar algo chamado caixa
de colisão. Primeiro, o jogador ou
a câmera interessam essa caixa de colisão e o
evento deve acontecer. Então, para adicionar uma
caixa de colisão, nós realmente
mudamos esse
mapa de mosaico para um ator. Então, vamos fazer isso
aqui para começar. Então, vamos para a pasta
Blueprints. Podemos fazer isso
aqui se você quiser, ou podemos fazer uma pasta. E sempre podemos
fazer uma pasta. Talvez em algum momento você
tenha mais mapas, ele possa ficar mais organizado. Então mapas de mosaico. Vamos clicar com o botão direito aqui e vamos criar uma nova classe de
blueprint. E se você aqui
procurar por Talmud. Novamente, você pode obter este
chamado ator de mapa de mosaico de papel. Então, vamos selecioná-lo agora e
chamá-lo de TM para mapa de mosaico. E deixe-me
chamá-lo de estrada do dragão. Este era o mapa, como
se chamava. Agora, nosso mapa de mosaico é um ator de blueprint em vez de ser
apenas um mapa de mosaico aqui. Então, clicando duas vezes nele, acordando
sob o componente de renderização. E vamos
selecionar nosso mapa de mosaico. E é esse
chamado mapa de azulejos, um dragão escreveu aqui. Então, vamos compilar e salvar. Agora, para este mapa de mosaico, temos que adicionar duas caixas de
colisão. Então, isso é essencialmente
o que estamos tentando fazer. Então, vamos adicionar um novo componente. Vamos procurar por colisão. Temos essa chamada caixa
de colisão. E esta colisão, caixa de
colisão, você pode ver aqui
que temos eventos diferentes. Então, o que deve acontecer se você começar a sobrepor
essa caixa de colisão? E vamos
pausar a câmera. Então, vamos cobrir a área que
queremos pausá-la quando. Então, vamos subir aqui. E temos dinheiro
extensão, extensão aqui. E o valor é que vou
colocar um 650 no x. então ele vai se
estender aqui. E 500 e DY. E eu vou colocar
mil e o z. e estes são apenas alguns
números que eu testo. Você pode simplesmente torná-los maiores. Essencialmente.
Deixe-me, na verdade, apenas fazer isso 50 talvez
no, em movimento, estalar e
apenas tentar olhá-lo. Veja se vou tornar
a velocidade da minha câmera
um pouco mais rápida. Então, basta ir para o
olho e
torná-lo igual, assim. Então ele está vindo aqui
e está indo para cá. E realmente não
importa porque a única coisa em que
estamos interessados é nessa área porque o
jogador nunca fez aqui, mas eu só gosto de ser
estruturado assim. Então, essencialmente, estamos
apenas tentando tornar
esses bugs grandes o suficiente. E, na verdade, acho que
precisa ser muito menor do que isso. Vamos testá-lo. Então, é dx, que é o
mais interessante,
dependendo de onde o jogador
vai ficar. Então, vamos fazer 600
por enquanto no x. e vamos copiar colar isso. Acredito que podemos fazer
isso, então vamos duplicá-lo aqui. E vamos pegar esta segunda
caixa e deixe-me
movê-la para o outro lado
do mapa. Assim mesmo. Então agora está do outro lado. Ok, então agora temos essas
duas caixas de colisão. Sempre podemos
testá-lo e ver se
precisamos torná-los
menores ou maiores. Então, vamos compor Save. Então, agora o que podemos fazer é deixar-me realmente
renomeá-los primeiro. Deixe-me chamar essa caixa de colisão
à esquerda. Então, se eu pudesse soletrar
assim e o outro, caixa de colisão certa. Ok, então para a esquerda, vamos clicar nele e
vamos descer e clicar na sobreposição de
início do componente. Então, o que deve acontecer quando eu começar a sobrepor
esse componente? Deixe-me excluir esses eventos
padrão padrão. Então ouça, o que geralmente
começamos é para sobreposições. Então, quando nos
sobrepomos a
algo aqui, realmente não temos um
servidor run-on e executamos em clientes. Então, o que costumamos fazer
é usar esse chamado switch tem autoridade. Mais uma vez, eu te disse
antes
que o servidor tenha a autoridade do jogo. O servidor pode fazer qualquer coisa. Portanto, autoridade significa que se eu sou o servidor e remoto significa que se eu sou o cliente,
o que devo fazer? Ok, então apenas
certificando-se de que
isso, esse componente sobreposto
é executado no servidor. E geralmente o que
acontece é sempre que você tem caixas de colisão aqui, sempre que você tem caixas de
colisão, você geralmente deseja alternar tem autoridade e
executá-la no servidor. Porque, novamente, você
evita a trapaça. Estamos apenas nos
certificando de que
há realmente uma caixa
sobreposta aqui. Porque se você apenas
executá-lo no cliente, às vezes o cliente pode
alcançar onde eles, eles se sobrepõem a essa caixa, mesmo que essa caixa realmente
não exista nesta caixa. Na verdade, sobreposto. Talvez esteja aqui,
eles estão aqui e ainda se
sobrepõem a ele de lá. Trapaça. Então, estamos apenas certificando de que nos
deparamos com o servidor. Portanto, autoridade significa que
eu sou o servidor, então o switch tem autoridade. E aqui podemos executar o código. O que queremos fazer é pausar
a câmera sempre que o jogador interagir
com essa caixa de colisão. Portanto, não temos um
evento chamado câmera postal. Então, vamos fazer isso
na base de jogadores. E o que queremos fazer é postar essa câmera, e ainda não
a tornamos variável. Então, vamos fazer isso pelo
tempo que queremos pausar esse temporizador é
essencialmente, então não
queremos executar este código de
posição de atualização aqui. Então, vamos clicar com o botão direito
sobre esse valor. Promova sua variável. E deixe-me chamá-lo de atualizações
de jogador, câmera, posição. E geralmente gosto de
dizer alça
no final porque é
uma alça de cada vez. Sua mão, reprodutor de atualização, alça de posição
da câmera. O que estamos tentando fazer é fazer um novo evento personalizado. E em vez de apenas
fazê-lo assim, vamos realmente fazer isso em
nossas Interfaces de Blueprint foram quase especialistas em Interfaces de
Blueprint agora, então vamos criá-lo aqui
para a base de jogadores. Vamos para o player,
na verdade, não aqui e
as interfaces por base, vamos fazer um chamado. Vamos fazer isso pausar, pausar, camada, câmera,
compilar e salvar. Então, vamos voltar para a base de
jogadores e vamos chamá-la de postar a câmera deles. E, na verdade, eu precisava da câmera da camada de pausa dos
eventos. Então evento Pausa a câmera
do jogador aqui. Então, queremos chamar esse evento. Então, se eu voltar aqui
para o mapa de mosaico, agora, estamos executando esse evento de caixa de
colisão e queremos chamar o
jogador. O jogador. Podemos chamar isso usando
este outro ator. Outro ator significa
o que quer que esteja sobreposto, esta caixa de colisão
sobrepôs componentes, a caixa de colisão
e o outro ator é o que está sobrepondo. Então, estamos caminhando para dentro dela. É o jogador.
E só para ter certeza de que é o
jogador sobrepondo, costumo fazer isso só para garantir que não cometemos
um erro aqui. Eu costumo fazer. O ator marcou. Então o ator marcou, você pode dar o ataque ao ator. Então, vamos dar a ele o player de tags. E o que isso significa está
aqui na base de jogadores. Se você voltar aqui, e se você for, acredito que esteja
nos padrões da classe. Então, aqui, se você pesquisar por tag, você pode ver que podemos adicionar uma
tag a essa base de camada. Então, vamos adicionar uma tag e
vamos chamá-la de player. Então, qualquer peão colide
com esta caixa de colisão. Então agora lembre-se, quando
temos o inimigo, o inimigo também está ligado. O inimigo aqui também está em cima. Então, só para ter certeza de que não é o inimigo colidindo com ele. E é só o jogador. Podemos dizer que o ator
marcou Player. E se isso for verdade. Então, se o ator tiver
o player de tags, que então definimos aqui
e a base do jogador. Então, todos os jogadores conectados
terão o player de tags. Vamos executar esse código. Então, se for verdade,
vamos executar esse código. E o que queremos
fazer é
executar essa câmera de camada de pausa. O outro ator
aqui é nosso jogador. Então, vamos definir especificamente
qual jogador ele é. E, novamente, podemos dizer que obtém camada REF porque este é
o que fizemos anteriormente. E então podemos dizer camada de
pausa, câmera. E quando você seleciona
essa mensagem porque é uma função de interface. Ok, então vamos voltar aqui e fazer algo
com este evento. E eu vou executar
isso nos clientes porque você realmente não
quer executá-lo no servidor. Porque lembre-se que esta câmera
é apenas específica do cliente. Esta câmera é executada apenas para
esse player específico. Todos os outros jogadores
realmente não se importam com sua câmera, eles não vão vê-la. Então, vou executá-lo
no cliente, tão personalizado. E vamos chamá-lo de CL para
clientes, camada de pausa, câmera. Vamos executar este. Se eu clicar aqui, vamos executá-lo em possuir
clientes como não confiáveis. Lembre-se de fazer isso. Agora, o que queremos fazer é
que queremos obter essa variável. O que estamos tentando fazer é
dizer o temporizador de pausa manipulado. Então, quando entramos na
caixa, queremos fazer uma pausa. Quando andamos para fora da caixa, queremos cancelar a pausa da câmera
ou para o temporizador novamente, que ele atualize novamente. Então é isso que
estamos tentando fazer. Então, na verdade, precisamos de
um booleano aqui, porque aqui, quando nos
sobrepomos com a
caixa de colisão, vamos fazer uma pausa. Mas, no entanto, se clicarmos
na caixa novamente e
descermos, temos essa chamada sobreposição final de
n-componente. Então, quando sairmos
da caixa novamente, vou copiar colar
este código aqui, assim. Nós realmente não temos que
fazer isso maduro novamente. Então, outros atores se
conectaram aqui. Agora, os atores também estão
conectados aqui. Então, sempre que sairmos da caixa, queremos cancelar a pausa. Nós realmente não, quero dizer, você pode ir em frente e fazer um novo evento, mas você pode realmente
usar esse evento para fazer as
duas coisas usando um booleano. Então lembre-se de um booleano como
se fosse verdadeiro ou falso. Então, vamos fazer um booleano aqui, clicando neste. E o booleano deveria
apenas dizer uma pausa. E se estiver pausado, então vamos arrastar daqui
e clicar em B ou branch. Então, se for uma pausa, se isso for verdade, então devemos fazer uma pausa. E se não for verdade, devemos deixar de pausar assim. Assim, ele pode fazer as duas coisas
dentro do mesmo evento, assim
usando um booleano. E, obviamente, temos que
executar este evento aqui em cima. E então temos que passar
este booleano por aqui. Então, precisamos fazer um booleano e nosso evento ou em nossa interface. E agora isso está incomodando por algum motivo.
Não sei por quê. Vamos compilar e salvar
e fazê-lo novamente. Às vezes isso acontece, pausa do
selo, assim. Ok, então vamos fazer isso
na interface. Vamos supor que a câmera do jogador, vamos fazer novas entradas, um booleano, e vamos simplesmente
chamá-la de pausa novamente, Compilar
e Salvar, e vamos voltar. Eu posso conectá-los juntos. E agora, se você
voltar ao mapa de mosaico, você pode ver que temos um booleano. Então, quando entramos na sobreposição, queremos fazer uma pausa. Então, definindo isso para corrigir. E quando você sair, vamos chamar esse evento novamente,
pausar a câmera do jogador. E queremos cancelar a pausa. Então, deixando isso falso. Então, agora ele deve funcionar.
Sempre que sairmos, vamos pegar isso. Vamos verificar se é o jogador que
realmente está deixando isso. Vamos definir esse
booleano verdadeiro ou falso. E dependendo do valor, ele será executado aqui. Dependendo do valor, ele vai pausar ou
emPausar esse temporizador. Então, vamos, na verdade, antes
que eu possa clicar em Jogar, vamos verificar primeiro
essas caixas de colisão. Então, na caixa de colisão esquerda e
direita, você pode ir aqui e
verificar a colisão deles aqui. Então, com o que eles estão colidindo? E só para ter certeza de que
tudo está correto, você pode clicar aqui e você pode vê-lo se sobrepõe a tudo, até mesmo o pon, ele se sobrepõe às lagoas para que possamos
fazer eventos de sobreposição. Então, acho que sim, isso parece correto. Tudo bem. Agora, terminamos
com o código, e agora o que precisamos fazer, vamos em frente e excluir
este antigo Talmadge. E isso seria excluído? Vamos colocar nosso novo. Então, vamos para o mapa de
mosaico aqui. E vamos colocar o novo. E vamos colocá-lo novamente em 000. Vou fazer com que a
excelência se aproxime aqui. Mais uma vez, assim como o que
eu disse antes, vamos movê-lo por dez. Acredito que foram dez. E só para nos mover, temos essas cinco
camadas, 123456 camadas. E eu vou, temos essa segunda camada nos meus
zeros, zeros, zeros. Então você pode vê-lo aqui. Está em meus zeros são 0,
mas não é, não é. A primeira camada amarela é
a segunda camada amarela. Agora em 0100
é que você pode ver que
temos as caixas de colisão. Então agora vamos clicar em jogar
e surgir como czarina. E deixe-me caminhar para o
lado e você pode ver que está realmente parando.
Então, está funcionando. Agora, se eu for para a direita, na verdade não está
funcionando e isso é porque eu esqueci de adicioná-lo. Então, vamos voltar ao mapa de
mosaico aqui e
vamos, na verdade, adicionar
o segundo. Eu até esqueci de
adicioná-lo na verdade. Então, clicando no caminho
certo, eles podem se sobrepor. Fazendo o mesmo código que este. Você pode copiar,
colá-lo aqui, conectá-lo aqui, conectar
o outro ator aqui, conectar o outro ator aqui. E clique na caixa
direita novamente. E se você deixar, então,
se você terminar a sobreposição, você vai copiar este e depois
conectá-lo de volta aqui. Então outro ator ou diretor aqui, e isso vai despausar. Ok, então essencialmente,
essencialmente vai funcionar agora, espero. Então, vamos testá-lo novamente. Movendo-se para a direita, ele vai parar a câmera. Você pode ver que
há um pequeno bug. Quando eu entro na caixa aqui. Ele seguirá
meu personagem por algum motivo antes que ele pare. Então ele segue meu personagem
e depois ele pára. Eu não quero que ele faça isso. Isso é algo
que podemos melhorar
na próxima lição
porque, na
verdade, está pausando aqui,
mas está atualizado. Está terminando a atualização aqui
para obter a localização dos atores. Então, ele está seguindo
o ator um
pouco mais e quando ele termina, ele pára aqui. Então, vamos melhorar
isso na próxima lição.
45. Como melhorar o movimento da câmera: Nesta lição, vamos
melhorar a câmera e o movimento. Então o que falamos aqui
é quando eu vou para a direita, as câmeras param,
tudo bem. O problema é que ele
segue o personagem, ele adere ao personagem
antes que ele pare assim, e então ele pára por
algum motivo estranho. E é aqui que estamos
tentando melhorar agora. Então aqui está fazendo essa lógica por causa da boa localização do
ator. Então, mesmo que estejamos
posando o temporizador, ele está terminando esta
atualização aqui está terminando,
terminando a posição da câmera
do player da linha do tempo. E ainda está conseguindo a localização do
nosso jogador e tentando definir a
localização da câmera ou de acordo com isso. Então, a maneira como podemos corrigir
isso é fazendo uma variável temporária para
a boa localização do ator que a câmera não
consiga
mais a localização dos nossos atores quando estivermos aqui no início da
nossa caixa de colisão. Então vamos
dizer ao cronômetro, este foi o último
ponto para o qual você deve atualizar e você não deve mais me
seguir aqui. Ok, então do jeito que fazemos isso, vamos fazer outro temporizador. Então, vamos, E a propósito, vamos realmente fazer
a função primeiro. Então, parece mais claro. Então, vou fazer uma função. Então, clicando no plus
aqui e escrevendo f para função. E então vamos chamar isso, obtém a localização atual do jogador. Agora, com este, a coisa mais
simples que vamos
fazer é basicamente apenas obter
a localização do jogador. Portanto, obtenha a localização real. Estou recebendo esse local de
atriz, e vou
armazená-lo em uma variável. coisa muito simples. Portanto, clique com o botão direito, promova
para uma variável e escreva local da camada
atual. Assim. Isto é, esta é a única coisa que essa função vai fazer. Então, restaurando a localização do ator
get em uma variável temporária
que usaremos. Vamos voltar ao
Event Graph. E aqui vamos criar
nosso segundo temporizador. Então, digamos que defina um temporizador. E desta vez, em vez de
definir um temporizador por evento, vamos definir o temporizador
pelo nome da função. Então, isso também podemos fazer isso. Então, vamos conectar isso e
você pode ver como isso funciona. Então agora ele vai
perguntar qual é a função que você quer executar? E é este. Só estou clicando aqui,
copiando o nome. E você tem que copiar o
nome exatamente como ele é, tanto com maiúsculas, minúsculas, maiúsculas e assim por diante. Então copie-o exatamente como está. E se você mudar o nome, você tem que se lembrar de
mudá-lo aqui também, senão ele não funcionará. O tempo que vou
definir aqui é 0.1, então ele vai atualizar
dez vezes por segundo. E também vou configurá-lo
para looping e clique com o botão direito do mouse neste temporizador
promovido para uma variável, e vamos chamá-lo de identificador de localização da camada
dos pais. Ok, então temos
esse tempo por aí, agora, desta vez
agora correndo. Então, em vez de uma boa localização do
ator, vamos usar nossa localização atual
do jogador. Este é o único
que na verdade,
este, a localização atual
do jogador. Eu estava olhando. Este ficou confuso. Este é o local de desova. Então, ele obtém esta localização
atual do jogador. Vou arrastar isso para
fora e colocá-lo aqui. Certo? O truque agora é que sempre que chegarmos a
essa caixa de colisão aqui, sempre que
chegarmos a ela, vamos parar esse temporizador. Então, em vez de interromper
essa atualização aqui, vamos parar esse temporizador. Então o truque é, e, na verdade deixe-me remover todas
essas linhas de grade. Está me irritando um pouco. Então vá aqui novamente na
renderização e clicando aqui. Então, quando eu chegar a essa linha de caixa de
colisão, ela vai parar o temporizador. E quando eu parar o temporizador
aqui na base de jogadores, ele não vai atualizar isso,
obter mais a localização atual do jogador. Ele não atualiza mais, ele vai ficar preso
aqui no início. Então esse é o truque
para fazer isso. Então, em vez de parar este
temporizador aqui no temporizador de postagem, vamos excluir
este e vamos parar este chamado obter a localização
atual do jogador. A localização não será
mais atualizada sempre que chegarmos aqui. E a câmera
só vai parar por aí. Então esse é o truque. Vamos conectá-los aqui. Agora. Compile e salve. Agora, deixe-me clicar em jogar e testar e ver se
tudo está correto. Então, se eu andar para o lado, você pode ver que não está
mais seguindo e parando sem problemas. E se eu sair daqui, também
seguirá sem problemas. Se eu for para a direita, ele está parando sem problemas também. Então, estamos parando a localização
atual do get aqui, que nossa localização atual, estamos interrompendo a atualização
variável aqui, então ele acha que o
jogador ainda está aqui. Isso é o que está acontecendo
essencialmente. Essa câmera acha que o Player ainda
está aqui porque
paramos o temporizador. Começamos o temporizador novamente
quando eu saio desta caixa. E novamente aqui, eu
paro o temporizador aqui para
atualizar as variáveis. Então, a câmera realmente
acha que ainda estamos aqui. Você pode ver que ele ainda está
recortando, então temos que ajustar o tamanho da caixa de
colisão. Então, se eu minimizar isso, volte para os mapas de mosaico
e vá para a caixa esquerda. E agora vamos
ajustá-lo um pouco. Temos que torná-lo um
pouco maior. Então, no x, vamos tentar 625, talvez seis, vamos tentar 650
e ver o que acontece. Então seiscentos e cinquenta, seiscentos e
cinquenta, clique em jogar. Quando eu andar aqui,
vai parar por aqui. Ok, talvez possamos adicionar
um pouco mais, mas está parando o ar
, então não há problema. Sim, acho que isso é bom. Então agora ele está parando
aqui nas bordas. Não estamos vendo mais essa borda
preta. Então, agora isso é corrigido. E andando aqui. E o mesmo é para este. No entanto, ainda podemos
sair da borda e é isso que vamos
consertar na próxima lição. Tudo bem, então antes de terminarmos isso, vamos voltar para
a base de jogadores. Preciso estruturar isso
um pouco melhor. Então, deixe-me empurrá-los. Lembre-se de organizar
seu projeto sempre porque vai
ser uma bagunça. Confie em mim. Você trabalha
há alguns meses e não faz isso, seu projeto parecerá uma bagunça e você se
arrependerá naquele momento. Então, tente juntar
tudo bem. Estou tentando pegar
essas variáveis. Então, juntando
bem as coisas, clique duas vezes neste pino para fazer um nó de redirecionamento como este. Então agora parece
bonito e organizado. E este, quero dizer, acho que está ótimo. Agora. Você também pode, podemos até empurrar isso um
pouco mais para baixo. Há espaço
para este estar todo o caminho aqui. E este que podemos colocar logo abaixo aqui porque
eles pertencem juntos. Vou para cá. Isso também é organizado. E sempre podemos colocar um comentário. Então, aqui, podemos pegar
isso e dizer
atualizações, atualizar os movimentos da câmera
para que ele siga um jogador. Você pode tentar escrever
o que quiser. Então eu só estou tentando pensar em
algo fora da minha cabeça. Você pode até alterar a cor do
comentário, se quiser, altere o tamanho, se quiser. E para este, estamos definindo a localização gerada pelos jogadores. Então, deixe-me comentar isso também. Digamos que pesquisar as camadas, local
inicial de desova.
Assim mesmo. Então tente se manter o mais
organizado possível. Você pode até mesmo comuns dados. E eu acho que isso parece perfeito agora vamos
compilar e salvar. Ok, então foi isso por enquanto. Vamos passar para a próxima
lição e adicionar os limites.
46. Como adicionar limites do mapa: Agora vamos adicionar
os limites do mapa para que o jogador não possa
sair da borda. Isso é muito, muito fácil. Este é um pequeno vídeo, provavelmente aqui em detalhes,
mapa dragão estrada. Vamos voltar aqui. E assim como antes, vamos adicionar mais duas caixas de
colisão. Então, vamos adicionar uma
caixa de colisão aqui à esquerda. E assim como este,
vou conseguir, este é o x, o y e z, e o z, vou
fazer mil novamente. Eles são apenas copiar colar
isso e eu vou arrastá-lo
para baixo novamente assim. Deixe-me reduzir um pouco a
velocidade da câmera. Acho que isso é bom, então vamos tentar isso. Vou renomear isso
e chamá-lo de salto esquerdo. E vou duplicar
isso e chamá-lo de limites certos. E vamos arrastar
este para a direita. Assim, acredito. Ok, o que queremos
fazer aqui para aqueles que estão
na colisão, então se você clicar em
um deles e descer para colisão aqui e clicar nesta
pequena seta aqui. Eu quero que você clique neste
aqui e clique em personalizado aqui. E agora aqui você
pode mudar as coisas para os pons para que nosso
jogador esteja ligado, e em vez de sobrepor, eu quero bloquear meu telefone. Não quero que o ponto vá
além dessa caixa de colisão. A mesma coisa aqui. Clicando aqui, clicando em traje e clicando em Bullock o. Mas vamos tentar colocar isso. Essa é provavelmente a
única edição que tínhamos que fazer. Então, vamos para a direita e ver se estamos
sendo bloqueados. Estamos no mar. Não podemos nem ir mais longe. Incrível. Isso está funcionando e você
precisa testar isso para ver se o saldo
é grande o suficiente. Eles vão para o outro lado. E espero que isso
funcione também. E isso funciona também e
pára perfeitamente assim. Então é assim que você adiciona limites de
mapa onde
estamos basicamente bloqueando o personagem de cair da borda
com uma caixa de colisão.
47. Como criar os flipbooks inimigos: Agora vamos nos afastar
um pouco
do jogador e vamos
implementar o inimigo. Então, como a primeira coisa que lhe dei aqui nos materiais do
curso. Então, se você for para os materiais de
custo, para os inimigos, eu forneci
para vocês essas texturas. Provavelmente há mais
texturas em sua pasta. E novamente,
só estou colocando
isso enquanto segui com o curso. Mas por enquanto importante, o porco ocioso e se move e
o caracol ocioso e se move. Então, vamos primeiro para
a pasta Assets. E dentro daqui, vamos
clicar com o botão direito do mouse e criar uma nova pasta e
chamá-la de inimiga. Dentro daqui,
vou criar uma nova pasta chamada texturas, que você possa tentar fazer isso
sozinho, se quiser. Isso é algo que
fizemos algumas vezes agora. E você pode clicar e arrastar essas texturas para dentro
da pasta de texturas. Selecione todos eles, clique com o botão direito do mouse, Aplicar configurações de textura 2D de papel. Então, removemos o desfoque. E vamos começar com
esse caracol aqui. Então, temos o ocioso, podemos clicar com o botão direito do mouse e
podemos criar um sprite. Vou renomeá-lo para sprites
S4 e caracol ocioso. E então vamos fazer
isso para o movimento. Então clique com o botão direito do mouse e vamos extrair esse preço
porque temos vários. Então, selecionando a grade aqui e , em seguida, escrever integre 90 por 90. Então essa é a
largura e a altura da célula. Foi o que eu fiz no Photoshop. É por isso que sei
quantos pixels são. Então, vamos clicar em extrair agora. E agora vou
clicar longe
da pasta e entrar nela novamente. Então, eles classificam automaticamente
assim de 0 a sete. E agora eu quero que você
renomeie isso. Vou pular essa parte. Ok, então agora que eu
os
renomeei, posso selecionar todos
eles e clicar com o botão direito do mouse, criar um flip book e
chamá-lo para movimento de caracol FB. Vou clicar
neste caracol aqui e definir os horários são quadros
por segundo para seis. Então essa é a velocidade com a qual
ela se move. A mesma coisa que vou
fazer com o ídolo aqui. Clique com o botão direito do mouse, crie um flip book e vamos chamá-lo de F ser caracol, ocioso e clique duas vezes nele. Os quadros por segundo são apenas
um porque é um quadro. E eu vou levar
o caracol aqui, este, a Irlanda, o
movimento e movê-los para a pasta de inimigos. Então, nós os temos aqui fora,
além de tudo isso. Então, vou fazer
isso também com o porco ocioso e o movimento de porco. E vou pular essa parte. Fiz agora o porco ocioso
e o porco mover-se flip books. Então agora vou clicar no
ídolo do porco aqui e definir os quadros por segundo
para seis, assim. E faça a mesma
coisa com o movimento. Defina os quadros por
segundo para seis. Agora vamos salvar tudo. Vamos clicar nesses dois e arrastá-los para
a pasta inimigos. Então agora temos os flip
books para esses dois.
48. Como configurar os pepinos inimigos: Para configurar os pontos inimigos. Vamos descer para plantas. E vamos até nossa
pasta de inimigos que fizemos
caminho, muito de volta neste curso. Então lembre-se da base inimiga. Fizemos isso clicando com o botão direito do mouse
na base de caracteres e criamos uma classe de
Blueprint filho. Então, a base é um filho
da base de caracteres aqui. Então aqui para a base inimiga, vamos agora clicar com o botão direito do mouse e
criar outra criança. E agora vamos
chamar este caracol VP. Podemos clicar com
o botão direito do mouse na base da imagem novamente, criar um novo filho e
vamos chamar essa seleção de VP. Vamos nos voltar para este caracol aqui. Vamos clicar duas vezes nele. E aqui para o caracol, clicamos no sprite. E aqui no flip book
fonte, selecionamos o caracol ocioso. Vou,
vou procurar por ocioso e selecionar este caracol aqui. Vou fazer a
mesma coisa pelo porco. Clicando no sprite. E aqui procure por ocioso
e selecione o porco ocioso. Então agora temos o porco e
os caracóis configurados aqui. Agora precisamos
reduzir o tamanho
desta cápsula e vamos tentar
fazer isso e a base inimiga, então ela se aplica a ambas. Então, vamos clicar
na cápsula aqui em cima. E aqui. Vamos mudá-lo para nós
temos que fazer isso aqui primeiro. Então 15 por 15 talvez. Deixe-me voltar para o
caracol e ver como ele se parece. Parece, parece bom por enquanto. Sempre podemos
ajustá-lo no jogo. Pode ver que é um pouco
pequeno para o porco. Portanto, ao fazê-lo na base, já que é a
classe pai desses dois, ele
aplicará isso automaticamente. Mas se você precisar de mudanças
individuais, basta clicar
nesta cápsula de porcos. Você não precisa seguir os
pais. Ele muda aqui. Você sempre pode simplesmente fazer a mudança individual para
este porco especificamente, talvez algo
assim em vez disso. Vamos fazer 2323,
algo assim. Este não é realmente
muito importante agora. Temos que testá-lo no jogo
e ver o que parece. Então, temos que testar isso
antes de sabermos que funciona. Então a última coisa que eu quero
fazer é agora, nossos inimigos estão colidindo
com nossos jogadores, então eles estão bloqueando
nossos jogadores. Acredito que sim. Então, vamos
tentar dar uma olhada nisso. Então, base inimiga da BP, podemos clicar na cápsula aqui e verificar as colisões. E agora ele
bloqueia nosso personagem. Então, vamos, na verdade,
eles não apenas bloqueiam nosso personagem
porque os inimigos também atacam, então eles bloqueiam um ao outro. Então, vamos até aqui e a
colisão presente. Vamos clicar no Custom aqui. Vamos agora clicar.
Então, para os pons, vamos clicar na
sobreposição porque talvez
precisemos fazer alguns
eventos sobrepostos mais tarde. Então, vamos sobrepor os
pontes para que eles não se
bloqueiem quando
andam por aí e também não bloqueiem nosso personagem. E isso foi para aqueles agora. E provavelmente temos que
fazer mais coisas depois, mas acho que foi
isso para este curso. Então, se colocarmos isso em 0, você pode ver o que parece. Este é agora o
inimigo que temos. E
é claro que não há movimento agora precisamos
adicionar o movimento. E isso é algo
com o qual
estaremos trabalhando
na próxima lição.
49. Volume de limites da malha de navegação: Ok, então agora que estamos trabalhando com
inteligência artificial, temos que dizer onde toda
essa IA pode se movimentar, porque agora a IA realmente
não sabe
onde eles podem navegar. Você realmente não disse eles para onde eles estão
autorizados a se mover. E isso é o que
faremos aqui. E isso é muito
simples, na verdade. Vamos subir aqui e
eles adicionam rapidamente o botão. E os volumes
que você tem algo chamado volume de rejeição
de malha de navegação. Isso é usado para inteligência
artificial, para IA, e diz para
onde eles podem se mover. Então, agora ele cria essa caixa aqui. Deixe-me
colocá-lo como 0 no y. Então está tudo aqui
no nosso mapa de azulejos. E então precisamos
torná-lo maior. Então, descendo aqui
nas configurações de pincel, vamos torná-lo maior e dx, então ele preenche toda a área. E podemos movê-lo para baixo
assim, então é subterrâneo. E se você clicar em P,
Então P no teclado, você pode ver uma
linha verde aparecer. E se você clicar em P
Novamente, é alturas. Então, diz configurar aqui. Whoops, configurando aqui chamado
navegação e o show. E o atalho é P para isso. E isso mostrará onde a IA pode
andar por aí. Então, agora, isso é verde. Eles podem trabalhar aqui. Eles não podem
passar esta linha aqui. E agora a IA não
é capaz de caminhar até aqui porque não
temos uma linha verde. E isso é porque você tem que
cobrir essa área também. Então, vamos entrar no z, vamos torná-lo maior e eu só vou
movê-lo para cima assim. Então, cobre ambos. Esta área agora é verde, e essa área aqui também
é verde assim. Portanto, há algumas pequenas
configurações que precisamos
ajustar apenas para garantir
que tudo esteja funcionando. Aqui na malha de
navegação de retransmissão que ela fez quando você adicionou o volume de
rejeição da malha de navegação. Aqui no
offset do sorteio, gostaria de adicionar 0. E isso é basicamente
exatamente onde você quer que esse desenho esteja. E eu só gostei de
0 em vez de dez. Então, não é realmente
algo importante, mas eu só gosto disso. A próxima coisa é que as configurações mais importantes estão aqui na inclinação máxima do agente. Só vou colocar isso. Você pode ver o que acontece
se você colocá-lo para baixo. Significa que eles não podem
subir aquela inclinação. Isso é o que significa. E eu só vou
colocá-lo para cima porque
quero que eles possam
andar naquela encosta. E esta é a altura do passo. Vou colocar
isso também. E não acho que precisamos
ajustar mais configurações. Temos que experimentar nosso volume de
navegação para garantir que ele funcione. Então deixe-me apenas
arquivar e salvar tudo. E antes de terminarmos
essas edições aqui, você precisa construir o volume do saldo de
navegação. Então, clicando no acúmulo aqui e clicando em compilação ou
níveis, você precisa se lembrar de construir antes que isso
realmente entre em ação. Ok, então agora o prédio está
terminado tão rapidamente. E o prédio geralmente
leva muito tempo se você tiver iluminação
em sua cena. Então, se você está trabalhando
com um jogo 3D, mas você pode ver
isso não demorou tempo. Não temos iluminação. Isso é muito rápido de fazer. E agora que temos nosso volume de rejeição de
navegação feito, agora
podemos continuar
trabalhando com o
movimento do olho. Assim, podemos testar mais tarde para ver se isso está
funcionando corretamente.
50. Controlador de IA: Assim como criamos um controlador de
jogador aqui, agora podemos criar um
controlador para nossa IA. Então, vamos até
a pasta Inimigo. E dentro daqui
você pode clicar com o botão direito do mouse e criar uma nova Classe de
Blueprint, C aqui, dentro daqui você
só pode ver o controlador do player. Portanto, o controlador é algo mais avançado e
não realmente avançado, mas eles não o incluíram aqui
porque é, as pessoas geralmente não trabalham com IA e um dia começam a
trabalhar com esse mecanismo. Você pode procurá-lo
aqui se você clicar em todas as classes e
procurar pelo controlador de IA. E você pode ver esse
chamado controlador de IA. Vamos selecioná-lo aqui. E vou
dar a ele um prefixo de AIC para controlador de IA. E vou
chamá-lo por um Emmy como este. Então, vamos salvar tudo. E agora o que
vou fazer é clicar
nesta base inimiga. E aqui na classe base
é padrão para a direita. Você pode ver aqui
como possuir IA. Só vou mudar para
lugar no mundo ou gerado. Então, talvez você gere os inimigos e a IA estará possuída. E a classe do controlador de IA, temos que mudar isso para
a classe de controlador de IA que acabamos de criar. Portanto, ele não
usará o padrão. Queremos usar o nosso próprio. E essa era a única
coisa que tínhamos que fazer. Então agora temos nosso controlador de
IA e você pode clicar nele e
ver como ele se parece. E assim como nosso controlador de
jogadores não contém muito. A única diferença
é que ele contém um componente de ação e um
caminho seguindo os componentes, mas nada realmente
vamos nos preocupar
agora ou usar. Então, vamos fechá-lo e passar
para a próxima lição.
51. Árvore de prancheta e comportamental: Agora vamos criar um quadro-negro
e uma árvore de comportamento. Então, se você clicar com o botão direito do mouse
aqui na pasta inimigos e ir para a
inteligência artificial, você pode ver que temos
algo chamado quadro-negro e uma árvore de comportamento. Então, vamos clicar em Criar o Blackboard primeiro,
criá-lo aqui, chamá-lo dB para Blackboard e depois escrever inimigo. E se você
clicar duas vezes neste quadro-negro, você pode ver que ele
realmente não contém muito. Podemos criar uma nova chave
que tenha apenas uma variável. E essa variável, você pode ver
algumas informações sobre ela. Podemos alternar entre a árvore de comportamento e o
quadro-negro aqui. Portanto, não há muita coisa
acontecendo e nós realmente
não precisamos
usar isso agora. Então, vamos criar uma árvore de comportamento. Você pode ver que não podemos
clicar nele e isso é porque não
temos um agora. Então, vamos fechá-lo. Vamos clicar com o botão direito novamente. Vá para inteligência artificial
e crie uma árvore de comportamento. E vamos chamar isso de
inimigo BT ou inimigo da árvore de comportamento. Agora, você pode
clicar duas vezes nesta árvore de comportamento. E dentro dessa árvore de comportamento é onde você constrói a IA, como a IA está se comportando, como ela está se movendo. Então, para começar aqui
na árvore de comportamento, você pode arrastar e soltar. Então, como a primeira coisa
que você faz na árvore de comportamento, você precisa escolher um seletor. Algo muito importante saber dentro da árvore de comportamento é que o código é executado
da esquerda para a direita. E vou te mostrar como
preciso fazer alguns dos nós aqui para que você
possa ver o que quero dizer. Então, começando com a raiz, você pode arrastar para fora e
fazer seletor. E a próxima coisa é
fazer uma sequência. Temos um seletor, temos uma sequência e agora vamos
adicionar nosso código. Então você pode ver aqui, se
eu adicionar algo aleatório, vou mostrar a vocês, vou adicionar a mesma
coisa repetidas vezes. Você pode ver, você
pode ver as notas. Eles têm números. Portanto,
temos o número 0, número um, e ele executará
o código da esquerda para a direita. Então aqui estamos
começando pela esquerda,
temos o número dois e depois o
número três e o número quatro. Se eu mover isso, dessa forma, você pode ver que ele muda
para o número três, ele muda para o número dois. Então, o código sempre vai
disparar da esquerda para a direita. muito, muito
importante de se lembrar. Ok, então o que queremos fazer com essa árvore de comportamento
é que queremos a IA, então nosso porco ou um caracol aqui. E o nível que queríamos encontrar um local aleatório
nesta malha de navegação. Depois de encontrar um local aleatório, ele se moverá
para esse local. Então, assim como em Maple Story, onde o inimigo está
se movendo no nível. Ele encontra um ponto aleatório
na malha de navegação
e, em seguida, ele se move
para esse local. Talvez ele espere por dois segundos. É como no modo ocioso e depois se move para outro ponto. Então, temos que começar encontrando um ponto aleatório
em nossa localização. E depois de encontrarmos
o ponto aleatório, temos que passar para esse ponto. Então, antes disso, temos que
encontrar um ponto aleatório. E isso é o que faremos
na próxima lição.
52. Como encontrar um ponto aleatório na área móvel: Mas vamos agora fazer com que
nosso inimigo encontre um ponto aleatório
nesta área móvel
nesta malha de navegação. Então, vamos voltar para
a árvore de comportamento. E dentro daqui nós
realmente não temos algo assim, então temos que criá-lo por nós mesmos. E você pode fazer isso clicando
na nova tarefa aqui. Então, clicando em nova tarefa, então você tem que salvar essa
tarefa e eu vou chamá-la, vou remover
isso, então BTT. E então vamos remover tudo
isso e vamos chamá-lo de vincular localização aleatória. Certo? E você pode ver
a tarefa que ela salva aqui. Então você tem todas as tarefas. Podemos até criar uma nova
pasta ou todas as suas tarefas. Então, aqui dentro da tarefa, você sempre começa com
algo chamado receber, receber, executar Ai. Este é o evento com o qual você
sempre começa e você sempre termina
com a execução finalizada. Então você tem esses dois sempre em uma tarefa aqui na árvore de
comportamento. E então todo o código
entra entre esses dois. Portanto, a função principal que estamos tentando usar
dentro daqui é chamada obter ponto
acessível aleatório no raio, você tem outros. Portanto, obtenha ponto aleatório
e raio navegável. Quero obter um
em ponto acessível. Então, talvez você tenha alguma
navegação aqui em cima. Então, se o inimigo estiver aqui embaixo, você tem alguma navegação aqui em cima que o inimigo não pode alcançar. E eu realmente não
quero incomodá-lo. Vou usar este chamado Get Random alcançável
ponto no raio. Então, vou clicar
nisso e ele vai
olhar para a nossa malha de navegação. Então, qual é a origem da qual ela
deve começar a pesquisar? E eu só quero
pesquisar de onde quer que o caracol esteja ou maior. Então, vamos colocar um caracol
aqui para que você possa visualizá-lo um pouco mais. Então, temos o caracol dentro do nosso nível aqui andando por aí. Então, onde você quer começar a pesquisar? Aqui na origem? Eu só
caracol grande e confiável está aqui. Então, aqui no peão controlado, Este é o inimigo
que está andando por aí. E lembre-se, fizemos antes, obter ref do jogador e
obter o controlador ref. Não acredito que tenhamos
um para o inimigo, então vamos seguir em frente e fazer
uma interface Blueprint
porque realmente
precisamos de uma referência
dessa base inimiga. Porque precisamos
usá-lo aqui para obter a localização
dos atores e
inseridos como origem. Então, aqui precisamos de uma referência à Interface do Blueprint
ou à base inimiga, onde dizemos obter referência
inimiga. Vamos voltar aqui e vamos criar uma nova Interface de
Blueprint. Portanto, esse é o
mesmo método do que estamos fazendo até agora. Então clique com o botão direito do mouse, vá para blueprints e selecione Interface de
Blueprint. Vamos chamá-lo de E termina a base inimiga. Vamos entrar aqui. E vamos
chamar isso recebe NME. Então pegue os inimigos
como referência. Agora, na saída, o que você está tentando se referir? Você está tentando se referir
à BP e à interface. Então, assim assim. E você pode chamá-lo de inimigo. Ok, agora lembre-se de ir para, para a base inimiga e dentro
daqui vá para Configurações de Classe e , em seguida, adicione a interface que você
acabou de fazer chamada base inimiga final, Compilar e Salvar, e ela
aparecerá para baixo aqui. Agora, quem é o inimigo? O inimigo é apenas desejo próprio, o que significa qualquer
projeto em que eu esteja. Então o inimigo é apenas
essa base inimiga. Ok, agora podemos voltar para
a tarefa e
da lagoa de controle, agora
podemos dizer que recebe referência
inimiga. Então, se é o caracol
andando, sabe agora que
é o caracol. Esta é a referência inimiga
que temos aqui. Só vou clicar com o botão direito nesse inimigo e
promover uma variável. Vou chamar
esse peão inimigo variável. Assim, só para
dizer mais limpo. E então essa origem
agora podemos pegar esse inimigo **** e
podemos dizer
get, obter localização do ator como esta. Portanto, a origem está
onde quer que esse inimigo esteja. Então, agora a origem
é desse inimigo. E ele vai procurar
um ponto em torno desse inimigo. Este é o raio. Agora temos que especificar o tamanho do raio que ele
precisa pesquisar. Agora, este raio, poderíamos
simplesmente inserir um número e dizer 50 e são 100 unidades. Mas talvez você tenha mapas
diferentes. Então imagine que você não
tem apenas esse mapa em seu jogo, mas você tem vários mapas. Alguns mapas são
maiores que outros. Às vezes, você precisa
procurar pontos mais distantes. Então, nós realmente não
queremos ter um número sólido escrito
aqui no raio. Normalmente, o que eu gosto de
fazer pelos meus jogos, gosto
de obter o tamanho dessa área navegável. E com esse tamanho, esse tamanho difere de mapa para
mapa porque você pode imaginar esse volume de rejeição de
malha de navegação é maior ou menor
em outros mapas. Então, ele só terá
esse tamanho, qual for o mapa em que você estiver, e ele vai procurar
dentro dessa área. Então, a maneira como você faz isso é, vamos afastar isso um
pouco. A maneira como você faz isso é de novo, pegue o ator da classe e você
usa o ator da classe. Novamente, já o usamos antes, mas se eu precisar
explicar novamente, você tem que usar isso, obter um extra de aula. Você pode obter um ator que já foi gerado
dentro do nível. Portanto, o volume dos limites da
malha de navegação já
está dentro do
nosso nível agora. Então, podemos procurar
por uma malha de navegação. Se eu puder ver aqui o volume de rejeição da
malha nav. Então, agora temos o volume balanceado de
navegação. Agora podemos arrastar disso
e dizer obter o salto do ator. Certo? Agora temos os limites do ator. E o que podemos fazer com isso
é que agora precisamos do raio, mas aqui o raio, você pode ver a extensão dos bugs. Você pode realmente imprimi-lo na tela e ver como ela
se parece. Mas precisamos executar a
árvore de comportamento antes de fazermos isso, vou
mostrar isso mais tarde, mas por enquanto, vamos
tentar terminar isso. O que estamos tentando fazer é
encontrar o raio aqui, mas você pode ver que a
extensão dos bugs é um vetor. Vou quebrar esse vetor para que eu possa ver o x, y e z. A única coisa em que estamos
interessados é o x. Porque você vê
aqui o vermelho,
o ponto de pivô vermelho, se você se lembrar de
antes, o vermelho é o x. Se você passar o mouse aqui, só
havia realmente
interessado na área no x. Nós realmente não nos importamos com
o Z ou o y aqui. Estamos tentando
encontrar um ponto dentro desse tamanho aqui.
Mas vamos voltar. A única coisa em que estamos
interessados é o X. Então, vamos, na verdade
, dividir essa extensão de caixa por dois
porque testei muito. E eu acho que esse tamanho, como pesquisar
toda a área navegável, é apenas do tamanho grande. E eu gosto que meus peões apenas
pesquisem em uma área menor. Eu não gosto desse caracol para
procurar em toda a área. Às vezes, ele se move
desse ponto do mapa, então ele se move todo o caminho para o outro lado do meu
Eu não gosto disso. Eu gosto dos caracóis
às vezes ele se move daqui para aqui apenas. Então esse talvez seja o movimento
máximo. Então eu gosto de dividir
esta caixa se estende antes de eu realmente fazer essa
dose dividida por dois. Portanto, é muito menor na área. Você pode ver aqui quando
você escreve dividir. Então, se eu arrastar de novo, talvez eu tenha feito isso muito rápido. Você pode escrever o
botão dividir e clicar aqui. Você pode ver agora que é um vetor, mas eu realmente não preciso disso. Só preciso dividi-lo por dois. Então, vamos clicar com o
botão direito do mouse neste pino. E você pode converter
esse pin em um número inteiro. Agora é apenas um número, então podemos dividi-lo por dois. Posso conectá-lo de volta
aqui ao vetor break. Aqui. Agora o x é dividido por dois. E agora eu posso conectar isso
no raio, opa, assim. E vamos derrubar isso,
algo assim. Então agora temos esse local
aleatório. Novamente, a única coisa em que estamos
interessados é o valor x. Queremos que o valor Z seja o mesmo porque eu ainda quero que
meu caracol esteja aqui em baixo. E o valor y também deve
ser o mesmo porque eu ainda quero que
meu caracol esteja aqui. Só estou interessado em
movê-lo para o eixo x. Então, o que vou
fazer é
voltar aqui e quebrar esse vetor. Então agora temos o x, y e z. Então x é qualquer ponto
encontrado no x.
e deixe-me clicar com o botão direito do mouse
e dizer make vector. Agora podemos reconstruir esse vetor para que o x
permaneça o mesmo. Este é o
ponto aleatório encontrado. Mas eu quero que meus y e
z permaneçam os mesmos. Na verdade, vou
copiar colar isso aqui. E eu vou
pegar minha localização de atriz novamente e quebrar este
vetor x, y e z. para que eu possa usar esses valores. Vou apenas
ligar o y e o z. o y e
o z permanecem
os mesmos que o, como o poema que
temos o inimigo ****. Mas são apenas as saídas que vão encontrar um local
aleatório, e essa é a única coisa
que vai mudar. Então, o Y e o Z sempre
permanecerá o mesmo. Tudo bem, então este é o resultado final e
precisamos conectar isso em algum lugar e usá-lo em
nossa árvore de comportamento aqui. É aqui que entra o
Blackboard. Então, vamos voltar
para o Blackboard. Na verdade, acho que podemos ativá-lo aqui e
a árvore de comportamento, para que você possa encontrar o quadro-negro dentro
daqui e abri-lo. Mas, assim como antes,
também podemos fazer isso indo para a árvore de comportamento
deles e clicando no
quadro-negro aqui em cima. Então, vamos criar uma nova chave e vamos fazer um vetor. Isso é o que precisamos. E vamos chamar esse
vetor de localização x. Portanto, estamos interessados apenas
na localização X. E apenas certificando-se de que
este é um vetor e não precisamos
mudar nada aqui. Então, vamos salvá-lo aqui. E vamos voltar para a tarefa. E então aqui vamos
criar uma nova variável. Essa variável,
vou
chamá-la de vetor porque é um vetor. E o que você
precisa fazer aqui é pesquisado pela Blackboard. E selecione este chamado seletor
de teclas Blackboard. Podemos compilar e salvar. E agora você pode tirar
esse vetor aqui. Este é o, o vetor
quadro-negro. E você pode dizer que define Blackboard, valor do
quadro-negro como vetor. Você precisa selecioná-lo agora. E o que ele vai
fazer agora vai
acrescentar esse valor
aqui a este, esse vetor que
você criou. Então, vamos agora adicioná-lo aqui. Então agora esse é o resultado, e vamos conectá-lo. Então ele vai sair
daqui todo o caminho por aqui, assim. Então, agora ele está conectado. E vamos terminar, executar. E lembre-se sempre de
clicar neste botão de sucesso. Muito importante. Compile e salve. Agora vamos ver o que acontece. Vamos agora voltar para a árvore de comportamento
inimiga. Então, clicando na árvore de
comportamento. Agora, o que podemos fazer
é ir até aqui e procurar nossa tarefa. Então, apenas escrevendo para BTT
e podemos encontrar este, PTT encontrar localização aleatória. E agora temos que dizer,
é esse x local que precisamos
usar em nosso Blackboard. Mas você pode ver aqui,
eu não posso realmente, se eu clicar nessa
tarefa, eu não posso realmente, eu não tenho uma
opção para fazer isso. E isso ocorre porque na tarefa, você precisa clicar nesse
vetor e você precisa clicar neste chamado
instância editável. Lembre-se de fazer isso
ou então você
não poderá vê-lo. Então volte para o inimigo. E você pode ver
agora que podemos selecionar um vetor e o vetor
que queremos usar é esse local x. Então agora ele vai
encontrar um local aleatório e são esses vetores. Então, agora temos o resultado. Ele vai se mover
para esse local. E no final o que eu quero
fazer é apenas dizer espere. Então, às vezes, quando
ele encontra um ponto, ele se move para esse ponto. Eu queria esperar um
pouco antes que ele se mova novamente. Aqui no tempo de espera, vou escrever 0. Achei que era a
melhor maneira de fazer isso. Portanto, o tempo de espera é 0, mas a variação
é de três segundos. Então, às vezes eles
esperam 0 segundos, às vezes esperam
três segundos, às vezes eram dois segundos. Então, às vezes, eles podem esperar 0 segundos para que eles não
esperem, eles simplesmente se movem novamente. Existem variações aleatórias, são três segundos ou às vezes
esperam três segundos. Mas agora ele vai
encontrar um local aleatório. Ele vai se mover
para esse local. E então ele vai esperar
por até três segundos e depois voltar e
repetir esse processo. Ok, então para fazer
tudo funcionar, temos que voltar para
o controlador do jogador. E dentro daqui,
vamos começar a jogar. Você tem que dizer que
execute a árvore de comportamento. Caso contrário, sua árvore
de comportamento não funcionará. E então você tem que selecionar
qual árvore de comportamento é essa que vai compor Salvar. E agora vamos colocar um
inimigo no nível e ver se ele funciona ou se
há algo que eu esqueci. Então, basta atacar um
inimigo no nível. Vamos clicar em Jogar agora,
selecione o personagem. E agora o que
olho para o meu inimigo, posso ver que meu inimigo não
está se movendo. Então, há algo
errado e preciso
encontrar o que fiz de errado
dentro desse processo. Tudo bem, então a maneira como eu faço
isso para depurar coisas. Então você pode ver aqui
quando eu jogo novamente aqui, a IA não está realmente
se movendo. Algo está errado. E vamos
colocá-lo aqui em cima. Talvez esteja dentro do chão e ainda não esteja se movendo. Então, a primeira coisa que eu não
gosto quando depuro, às vezes a
malha de navegação salta o volume se esgota, então não vai funcionar. Às vezes, eu apaguei e tentei fazer isso novamente. Então, não sei por que no Unreal Engine às
vezes funciona. Talvez esse não seja o problema, mas podemos começar por aqui. E assim, nos volumes, vamos adicionar o volume dos limites da
malha de navegação novamente, colocá-lo em 0. E na extensão da caixa, vou aumentá-la
novamente, algo assim. E então aumente o, o z. Ok, agora eu tenho de novo
e no re-cast aqui, vou definir o deslocamento de empate
novamente para 0. E definimos a altura do agente para realmente o loop máximo do agente
289 e a altura máxima 289. Então vou salvar e
construir tudo de novo. Ok, agora podemos tentar clicar em Play e ele ainda não está se movendo. Então, a próxima coisa, o que
estou tentando olhar
é encontrar um ponto na minha árvore de comportamento aqui
na minha tarefa, na verdade. Então, para começar, o que eu
costumo fazer é
que vou imprimir na tela. Portanto, a string de impressão é a melhor coisa que você
pode fazer para depuração. Porque quando ele imprime uma
string na tela, você sabe disso, que
esse código está disparando. Esse código está funcionando.
Então, se eu clicar em Jogar agora e você pode
ver isso diz Olá. Então, a tarefa é
realmente dizer olá. Então, tentando executar o código, então nada está errado aqui. Então, vamos seguir em frente com o código. Por aqui. Vamos tentar ver se
ele encontra esse ponto. Então, vamos
imprimir na tela novamente, conectado a partir daqui agora. Porque agora sabemos, agora sabemos que essa parte
do código está funcionando, então está iniciando essa tarefa. Então, aqui, vamos agora
imprimir esse valor. Então, ele vai imprimir
esse vetor e ver se realmente encontramos
algo aqui. E você pode ver no X, na
verdade está encontrando locais
diferentes, mas na verdade está funcionando. Então, está encontrando esses
locais corretamente. Então, tudo bem, são
esses locais e eu sei que meus controladores de IA funcionam também porque este
é o que está executando a
árvore de comportamento que criamos. E pode ser um movimento
e depois esperar instantaneamente. Então, isso também é algo que pode acontecer. Então, aqui na árvore de comportamento, talvez esteja se movendo e então esteja esperando instantaneamente
por algum motivo. Então, deixe-me conectar isso
e apenas conectar esses dois. Deixe-me salvar e
, em seguida, clique em jogar. E se eu olhar para a
minha árvore de comportamento, você vê aqui que estou
jogando o jogo agora. E eu acho que isso é o que
está acontecendo, em última análise porque eu realmente não vejo
nada de errado em nosso código. Está encontrando um ponto aleatório. Está tentando se mover
para esse ponto. Mas você pode ver aqui nossa árvore de
comportamento está enlouquecendo. Na verdade, está se movendo
para esse local, encontrando um novo local,
movendo-se , se movendo,
encontrando movimento, encontrando. Ele continua fazendo isso. Ele
encontra um novo local. Mesmo que a
localização esteja longe, ela meio que se move um pequeno
passo antes de começar a alcançar,
procurando por um novo local. Mais uma vez, acho que a tecla
Blackboard aqui está configurada para auto-ator que este
pode ser o bug aqui. Então, vamos voltar aqui, sair do modo de reprodução e vamos
clicar neste movimento para. Então eu meio que esqueci de
mudar esse local aqui. Então, vamos conectar isso aqui novamente. Vamos clicar em Play. Agora. Você pode ver, agora está
realmente funcionando. Então o caracol está se movendo. Ele se mudou para um local. Está esperando por
até três segundos e depois está se movendo novamente. Então esse foi o bug. E eu não quero excluir isso do vídeo
porque quero mostrar como você
depura as coisas porque você vai
ter problemas. E quando você tenta usar
a cadeia de impressão para imprimir
uma string na tela. E quando ele imprime uma string, você sabe que esse código
está funcionando porque está disparando a decodificação para você, está disparando o evento. Você também pode tentar
descobrir o local para ver, está encontrando um
local aleatório ou não? Então a última coisa,
obviamente, foi que a árvore de
comportamento é sólida. Ficou louco. E isso ocorre porque
ele estava se movendo para esse fator celular
no Blackboard, o que não fazia sentido. Era suposto se mudar
para aquele local x. Então agora está funcionando aqui. Mas você pode ver, é claro que nossa animação não está
funcionando porque não
adicionamos nenhuma animação para o caracol ou para
nenhum dos inimigos. Então, vamos fazer isso
na próxima lição.
53. Estado do movimento inimigo: Tudo bem, então o que
precisamos fazer
nesta lição é que precisamos mudar o estado de movimento
desse inimigo para que ele
mude o flip book. Sempre que está se movendo, ele
tem o flip book de movimento, e sempre que está ocioso, ele tem o flip book ocioso. Então, na verdade, o mesmo processo
que fizemos com nosso jogador quando estamos nos movendo e
parando. Então, a mesma coisa. Vamos voltar para
a base inimiga agora. E dentro daqui, vamos excluir todos
esses eventos padrão. E o que queremos
fazer, em última análise, é criar uma nova variável e
defini-la como está se movendo. Então, na verdade, vou
escrever um B na frente dele. Pois booleano está movendo
este booleano aqui. Se eu arrastá-lo
para fora, queremos configurá-lo para notificar o representante. Portanto, lembre-se, todas
as alterações visuais precisam ser notificadas por interrupção e alterar o flip book é uma mudança visual para que todos
os clientes possam vê-lo. E isso é o que queremos fazer. Então, aqui na função unwrap, lembre-se de que ela cria
uma função on-ramp quando você faz algo
para enrolar notificar. E dentro daqui,
vamos apenas pegá-lo. Então, não agora,
estou trabalhando para trás para que você possa
ver o que quero dizer. Portanto, este é o resultado final, está se movendo é definido como verdadeiro. Então, criando uma ramificação. Se isso for definido como verdadeiro, vamos pegar este
sprite e definir o flip book. Então agora vamos
definir este flip book dois. Então, se estiver se movendo, nós
não vamos ficar ociosos na verdade. Vamos nos mudar para cá. Se estiver se movendo,
vamos nos mover. E se estiver em marcha lenta, se não estiver se movendo, vamos ficar ociosos assim. Mas agora você pode ver que
temos que selecionar, temos que selecionar
o porco também. Então, precisamos fazer
isso dinamicamente. Então, se você tem dois inimigos, isso é apenas para um inimigo, ele só funciona para o caracol. Também precisamos dele para o porco. E lembre-se, como
fizemos com o jogador, você precisa criar uma estrutura. Vamos para a pasta de
estruturas. Vamos clicar com o botão direito do mouse e
criar uma nova estrutura. Então clique com o botão direito do mouse e vamos
encontrá-lo em projetos e estrutura e
chamá-lo de informações sobre animais. Dentro daqui,
vamos criar duas coisas. Vamos criar
a animação ociosa e vamos criar
a animação de execução. Podemos simplesmente chamá-lo
de animação de movimento. Acabamos de chamá-lo de movimento,
mover animação. E este é obviamente um flip book de
papel como este. E isso também é um livro em papel. Ok, então temos esses dois, e você pode adivinhar que talvez
mais tarde possamos adicionar saúde
aos inimigos para que
possamos realmente criar uma nova variável mais tarde
e chamá-la de saúde. Então, todas as informações sobre o inimigo serão
armazenadas dentro daqui. Então, quanta saúde eles têm, quanto dano eles causam e quanto ouro eles
dão a você e assim por diante. Então, todas as informações sobre animais
estarão aqui mais tarde. Então, vamos agora voltar
para a base inimiga. E agora podemos adicionar a
estrutura e as variáveis. E podemos chamá-lo de informação animal. Podemos selecioná-lo aqui e
chamamos de st informações de animais. E essa é a estrutura. Agora temos essa estrutura, podemos arrastá-la para fora
e, assim como antes, sair dela e clicar em break para ver todas
as variáveis. Então você pode adicionar o ocioso. Você pode ver que temos o ADL aqui em
cima e eles se mudam para
cá vai ser uma bagunça porque vai
ser cruzado assim. Gosto de ficar limpo
no meu projeto. Então, o que vou fazer,
vamos tentar ter o ocioso aqui para que possamos reverter
isso dizendo loucos. Portanto, não b significa NÃO booleano. Então, se isso significa que agora é se
o inimigo não está se movendo, então se isso estiver se movendo é falso,
então, se ele não estiver se movendo, então estamos em marcha lenta. Então, deixe-me excluir esses flip
book e conectado aqui. Então, o que precisamos fazer aqui, então se você não estiver se movendo, se isso for verdade, você está ocioso. Então, estamos conectando
ociosos aqui. E eu vou copiar
colar isso aqui embaixo, pescoço
dela, os sprites. Há conexão falsa
aqui em baixo e
conecte-os e mova-os para cá. Então, quando não estamos nos
movendo, estamos em marcha lenta. Quando estamos nos movendo, então estamos na animação em
movimento. E para fazer isso funcionar,
você tem que ir. Então agora você tem
essas duas variáveis e precisa configurá-las. E lembre-se quando você adiciona uma
variável à classe pai, então estamos dentro
da base inimiga. Todas as classes de
blueprint filho herdarão essas informações. Então Porco e caracol são
filhos da base inimiga. Então, vá para o porco e abrindo o editor de
blueprint completo aqui nos padrões da classe. Você pode ver que a variável de
informações animal está aqui porque você a adicionou
à classe pai. Então, aqui você pode selecionar a animação
ociosa para o porco. Então procure por ocioso, pegue isso e pela lua e selecione isso. Mova a animação. A mesma coisa aqui
para o caracol. Então,
abra-o, abra a
classe de editor de blueprint completa padrão informações de animais, procure ocioso
e adicione os caracóis, procure por movimento e adicione o
movimento para o caracol também. Ok, então temos isso agora, e vamos voltar para a base. Portanto, esse é o
resultado final que
estaremos mirando. E deixe-me
aproximar assim assim, para
que fique mais organizado. Vamos voltar ao
Event Graph. Então agora temos essa
variável que precisamos definir, e sempre definimos esse séquito para lutar
através de um servidor. Vamos fazer um
valor personalizado chamá-lo estados de movimentação
do servidor como este, e vamos executá-lo através do servidor e é confiável
e agora podemos conectar isso. Agora lembre-se dessas variáveis de
servidor, temos que nos passar por
uma variável normal também. E isso é chamado de estágio de movimento. Então, vamos realmente criar um diretamente dentro de uma Interface de
Blueprint. Porque agora temos um. Vamos para interfaces
ou à base inimiga. E vamos chamá-lo aqui. Estados de movimento. Vamos compilar. E aqui na base inimiga
fizemos uma variável
chamada está se movendo, então precisamos de um booleano. Então, vamos criar um booleano e a entrada chamada D está se movendo. Vamos compilar e salvar, e vamos voltar
para a base inimiga. Então agora podemos chamá-lo de
dizer estados de movimento. E podemos chamar isso de eventos. E agora podemos executar esse evento de
servidor daqui. Ok, então agora estamos
trabalhando para trás. Então, começamos com esse estado de movimento do
evento. Ele passará
pelo servidor e seguida, definirá essa função de
notificação de interrupção. E dependendo se
for verdade ou não, ele vai definir
esse flip book. Então, precisamos executar
este evento em algum lugar. E acredito que o
melhor, ou acho,
descobri que a melhor maneira de fazer esse estado de movimento está aqui na árvore de comportamento
no local aleatório definido pelo final. Então, quando encontrar
um local aleatório, vamos em frente e
dizer que está se movendo. Então, vamos definir o estado
dos movimentos como verdadeiro. E então ele vai frente e se moverá para esse local. Então aqui já temos
uma referência ao nosso peão. Então isso é muito fácil. Podemos pegar isso e dizer Definir estado de
movimento e selecionar essa mensagem porque é uma Interface de Blueprint.
Assim mesmo. E, na verdade, esta é uma
base de jogadores que é a errada. Vamos voltar e ver
como chamamos isso. Na verdade, acabei de
chamá-lo de estado de movimento. Deixe-me, deixe-me chamar isso de estado
de movimento definido. Acho que isso é muito melhor. Então, chamando isso também, os movimentos
definidos permanecem
assim. Compilar. Vamos voltar a isso e
dizer Set movimentos, Estados. E aqui está na base inimiga, não na base de jogadores. Então, de qualquer forma, mensagem
selecionada aqui. Agora dissemos que o movimento
afirma ser verdade. Então agora está se movendo. Mas temos que defini-lo falso em algum momento, porque
agora, se você clicar em Play e puder experimentá-lo,
você pode ver que ele está se movendo agora. E deixe-me
reduzir um pouco a
velocidade de movimento porque
agora está se movendo tão rápido. Então, para o caracol, vamos
para o Movimento dos Personagens. E vou definir
o movimento para 45. Acabei de fazer muito e
acho que quarenta e cinco foi um bom número para esse caracol de história de
metal. Então você pode ver que está se movendo,
mas quando está em marcha lenta, nunca
vai parar como
no flip book de animação ociosa. E isso ocorre porque nunca
definimos o booleano como falso. Portanto, ele realmente não
sabe quando jogar esse flip book de animação ocioso pode ver quando ele fica
ocioso, ele ainda se move. Então, temos que definir, se eu voltar para a interface, temos que definir isso
como false em algum momento. Vamos fazer isso aqui
na árvore de comportamento, podemos fazer isso também. Então ele se move para esse local
e antes de pesar, vamos em frente e colocar
esse booleano como falso. Então, vamos fazer uma nova tarefa aqui e basta clicar
nesta aqui em baixo. Então, fazemos uma nova tarefa. E este, eu vou
chamar sets movimento booleano,
definir bola de movimento, o que
significa que o movimento booleano, esta é a única
coisa que está fazendo. Mais uma vez, assim como o que
eu disse antes, temos que começar com
um recebimento execute Ai. E temos que terminar
dentro do acabamento executa. E temos que derrubar
o sucesso quando terminar. E a única coisa que estamos
fazendo é tomar esse ditado fica inimigo, recebe referência
inimiga. Então, estamos recebendo essa
referência inimiga aqui e na base. E a partir da interface
podemos simplesmente arrastar e dizer Definir estados de movimentos
aqui e a base inimiga. E a única coisa que estamos
fazendo é apenas definir esse booleano como falso porque agora
não estamos mais nos movendo. Terminamos de nos mudar. Então, vamos voltar para
a árvore de comportamento. E aqui podemos arrastar e dizer BTT e selecionar aquele
conjunto de movimento booleano. Ok, então a coisa está fazendo agora, é encontrar um local aleatório. Está se movendo para esse local. E quando ele se move e
termina esse movimento, ele vai definir
o booleano verdadeiro,
falso, então não estamos mais nos
movendo. Então ele vai esperar aqui. Então, agora vamos
clicar na plaqueta. Na verdade, basta adicionar mais
alguns inimigos só para não ter que esperar
que esse caracol pare. Então, clicando aqui, e
você pode ver que está agora, este está inativo
e funciona bem. Agora está no ocioso. E então, quando ele se move, está no flip book do movimento. Então, agora ele funciona perfeitamente. Então, o que podemos fazer agora é que
podemos adicionar mais
alguns inimigos. Então, segurar Alt e
arrastar será duplicado. E você pode simplesmente duplicar
alguns inimigos neste nível. Quantos você quer. Na verdade, não vou colocar,
vamos colocá-los aqui. Por que, por que não? Vamos para o inimigo e vou colocar
o porco aqui em cima. Tão inimigos mais difíceis
estão no topo aqui. Então, vamos colocar isso em 0. E, na verdade, em vez de 0, temos que colocar um para que
não minta nos azulejos. Mas vamos adicionar, por exemplo, para porcos aqui em cima. E sim, eu acho,
acho que está tudo bem. Então, digamos que vamos
clicar em Play para ver se tudo está funcionando em oposição aos porcos são muito rápidos. Então, vamos voltar às fotos. E outros porcos que estou
chamando vou defini-lo para 90 anos. Acho que os 90 eu testei
isso também. Mas os porcos são um bom número. E você pode ver que eles
estão por trás dos azulejos. Então, na verdade, temos que
movê-los um pouco para frente. A maneira mais rápida de fazer isso é selecioná-los aqui
no outliner. Então, esses são os porcos. Estes são os caracóis. Segure Shift, selecione o último, então nós temos todos eles e
definimos para um aqui no Y. E clique no jogador. O jogador em vez
de um,
quero que ele esteja na frente dos inimigos. Então, clicando em dois
neste surto de jogadores, então estamos na frente
de todos os inimigos. E agora vamos clicar em Play. E isso é o que parece. Então, temos os porcos
correndo lá em cima. A marcha lenta está funcionando bem e o movimento também está
funcionando bem. Você pode ver que esses caracóis
estão um pouco no topo. O que você pode fazer é
clicar no caracol. O problema é que, quando você
aumentar esta cápsula, ela vai empurrar esse caracol para cima para que não
pareça estar no chão. Então, por exemplo, para o caracol, se você está apenas tentando
11 aqui e aqui em cima, clique em salvar composto. E você pode ver agora
que está na grama, agora não está voando para cima. O problema é agora e
vamos corrigi-lo
na próxima lição, você pode ver que ele ainda está se movendo, como está,
na verdade, está ocioso, mas está se movendo assim. Eles estão escutando. Isso ocorre porque a
animação ociosa é bombeada para fora. Então passei um par de tempo
para ver por que estava fazendo isso. E ainda não faço ideia
por que está fazendo isso. Mas acho que minha teoria é que está
tentando encontrar um ponto
na navegação e, em seguida, está escutando porque
na verdade ainda está se movendo. Não está em marcha lenta, mas não
pode se mover para essa área. E isso se deve a
essa cápsula aqui. Está fazendo alguma colisão estranha e está estocando o inimigo. Então, vamos passar para a próxima
lição e corrigir esses bugs.
54. Como corrigir erros e problemas de recorte do movimento: Ok, então para consertar o último
dinheiro do último vídeo, temos que ir, vamos começar com este caracol. Então, vamos tentar
aumentar essa cápsula. Até 2828 sobre isso foi o melhor número para
fazer isso por esses caracóis. E vamos mover este caracol menos 18 para ver se ele
está no chão. Então, movê-lo para menos
18 está se movendo no chão. E só para verificar e ver se está incomodando aqui no Hill, eles parecem estar se
movendo sem problemas agora. Tudo bem, então isso
parece, está bem agora. Então, se ele sair, você pode aumentar esta cápsula
aqui e ela pode descer esse caracol para fazê-lo andar
na grama se você não fizer
isso, está pairando sobre a grama. E para os porcos, o que eu fiz foi que fiz aquela cápsula 30 por 30, e então eu movo
esse porco por menos oito para que um
seja maior também. Este é grande agora, então descobri que essa era a melhor solução para corrigir
esse problema de bugs. E agora podemos ver que tudo está se movendo corretamente e
não temos um problema. Novamente, se você tiver
o problema em que o inimigo está se movendo e ainda está em
marcha lenta no mesmo lugar. Você pode tentar o tamanho da cápsula e depois descer o inimigo. Então agora fizemos
todo esse progresso. Ótimo trabalho até agora.
Você realmente progrediu muito
dentro deste curso. E a próxima coisa que
podemos fazer é danificar ou talvez
precisemos de uma escada aqui em cima. Então, verei o que
farei para a próxima seção. E até agora, tudo
está bem. Se você quiser adicionar mais
inimigos, você pode fazê-lo. Se você quiser fazer
isso sozinho, novamente, você não pode liberar isso no
Steam ou em qualquer outro lugar. Isso é apenas para fins
educacionais. Mas se você só
queria praticar, eu uso este site chamado maples que sou um simulador de bordo. Então você pode simplesmente clicar aqui e criar um novo personagem. Ou você pode criar um
novo monstro aqui. Uma multidão pode ver aqui
que você pode criar mapas. Você pode selecionar o tipo de
multidão que deseja
criar, talvez um lodo, outra
coisa para que você
possa criar mais mapas, você pode então, depois de fazer isso, eu costumo virá-los horizontalmente
porque eles precisam esteja nessa direção
antes que ele possa funcionar. Às vezes você precisa do
Photoshop para girá-los. Então você pode
baixar a planilha. E então você pode usar essa planilha de
limo e importá-las aqui
dentro de nossos projetos. Então, se eu voltar aqui
e nosso projeto, você pode importar essas
texturas novamente para os ativos, inimigos, e você pode fazer todo
o processo novamente, e você pode adicionar mais inimigos. Então, até você o que você
quer fazer com o jogo, você pode tentar brincar
e se divertir com isso. Então, digamos, Bem, e vamos
passar para a próxima lição.
55. Como adicionar o sprite de corda: Olá a todos e bem-vindos de volta. Nesta seção, vamos
trabalhar com o declínio
sendo mecânico. Tão ótimo trabalho
para chegar até aqui. Você tem feito
muito progresso. E você pode ver
que temos feito muito. E nesta seção para
o cliente ser mecânico, temos muito a aprender. Então, vamos em frente e comece a
adicionar o sprite de corda. No material do curso. Eu incluí para
você, as cordas brilhantes. Se você for para os Materiais do
Curso e , em seguida, vai para o ambiente. E dentro daqui você tem
essa textura chamada corda. Então, vamos voltar para
nossa pasta constante. E dentro dos ativos, e já temos uma pasta de
ambiente. Então, dentro daqui,
dentro de texturas, vou carregar minha corda, então arraste-a para a pasta de
texturas. Ok, então dentro daqui,
vamos clicar com o botão direito do mouse. Vá para Ações do Sprite e
aplique papel às configurações. Vamos tentar clicar nele
e, em seguida, criar um sprite. Então, nada de novo até agora. Isso é o que temos
feito até agora. Vou chamá-lo de corda. Ok, então agora temos
esse sprite de corda. Então, até agora temos
feito flip books. E como você pode ver aqui, a corda obviamente
não é um flip book, não
é uma corda animada. Então, vamos arrastá-lo aqui
para o ambiente. E agora estamos trabalhando
com um sprite. Acredito que este seja
o primeiro sprite que
vamos adicionar
ao nosso ambiente. E antes de adicionarmos o sprite, como você pode arrastar o sprite e adicioná-lo ao
ambiente
assim e talvez definir
o y para 0 ou um. E você poderia simplesmente
colocar a corda assim e tudo está
bom e a corda é adicionada. Mas o problema com isso é que
vamos adicionar código
à corda porque nosso jogador
vai interagir com ela. Então, vamos excluí-lo aqui. E eu vou
transformá-lo em um plano em vez disso. Portanto, sempre que você
tiver algo com
o qual o jogador está interagindo, você deve pensar
automaticamente em transformá-lo em um plano. Então, vamos para as
plantas e isso nos
permitirá criar algum
código para a corda. Então deixe-me clicar com o botão direito
aqui e criar uma nova pasta e
chamá-la de escalada. Por aqui. Vamos clicar com o botão direito do mouse
e ir para blueprints. E, na verdade, basta clicar
aqui, Classe Blueprint. Clicando aqui novamente,
procure papel aqui embaixo. E queremos fazer um sprite. Então, antes de criarmos flip
books e mapas de mosaico, mas desta vez também
criamos personagens. Desta vez, vamos
criar um sprite. Para este, vou
chamá-lo de cal sendo base. Portanto, este é o plano base
para o cliente ser exatamente como o que tínhamos para
a base de personagens e a base de jogadores. Agora temos um cliente
baseado porque está tudo bem. Você tem uma corda agora, mas no futuro, e se
você quisesse ter uma escada? E se você quisesse ter um
cachimbo como se tivesse como um mapa da indústria, então talvez você tenha tubos que você usa como
letras ou cordas. Então, temos uma
base de fixação e, em seguida, podemos adicionar muitos objetos de escalada. Então escadas, cordas, canos, tudo o que você quiser
adicionar ao seu jogo. Então, vamos agora clicar com o botão direito do mouse nesta base de escalada e criar
uma classe Child Blueprint. E a partir disso, vamos
criar a corda BP. Ok, vamos arquivar e
salvar tudo até agora. Então, para a corda de escalada ou mais corda aqui,
vamos clicar duas vezes. E dentro daqui temos
o objeto de renderização ou
lembramos de componentes de renderização. E vamos selecionar nossa linha aqui. Então, procurando por corda
e selecionando nossa corda. Tudo bem, então agora
este é adicionado. E o que podemos fazer aqui é que agora
podemos arrastar nossos planos, arrastados para o nível. Vamos definir o local para 0. Vou configurá-lo para
um porque lembre-se as peças de base estão em 0 e não quero
incomodar todo o resto. Então, vou definir este para
um e deixar-nos movê-lo para cá. Não sei, talvez
algo assim. E eu vou mover
esse inimigo para que eu possa realmente ver onde
estou colocando isso. Então, algo assim
e um pouco para baixo para
que, essa parte está pendurada
nos azulejos aqui em cima. Agora você pode ver que
a corda está realmente interferindo em nossa malha de
navegação, então nossos inimigos não podem mais
se mover para cá. Então, vamos clicar
na base de escalada. Não queremos isso. Então
clique na base de escalada. Vamos removê-lo de todos
os objetos do cliente. Dentro daqui, clicando
nos componentes de renderização. Vamos agora, vamos apenas ouvir
na colisão ou nenhuma
colisão. E o jogador não pode
pisar em cima disso. E não
gerará eventos de sobreposição. Os eventos de sobreposição que
faremos mais tarde, vamos adicionar caixas de
colisão. Portanto, não é realmente o componente de
renderização em si. São as caixas de colisão que vamos fazer,
as sobreposições. Então você pode ver agora que
não se sobrepõe nada e
tudo está corrigido.
56. Evento de sobreposição de corda: Vamos agora trabalhar com os eventos de sobreposição de
corda. Então, para os eventos de sobreposição de corda, precisamos de uma caixa de colisão. Então, vamos para a base de
escalada e adicione uma. E a razão novamente, por que estamos
adicionando-a à base colombiana
e não à corda é porque sempre que criamos mais tarde muitos objetos de
escalada, todos esses objetos terão essa colisão bugs porque todos esses
objetos aglomerados serão filhos dessa base de escalada. Então, tudo o que adicionarmos
aqui se aplicará a todos os filhos aqui
no componente de renderização. Vamos apenas uma caixa de colisão. Então procure por colisão e adicione essa chamada
colisão de caixa. E deixe-me
chamá-lo de
caixa de colisão e Compilar e Salvar. E nós realmente não
precisamos fazer mais aqui. Então, vamos minimizar isso e deixe-me
voltar para a corda agora. E vamos abrir o editor de blueprint
completo. Vá para a janela de exibição. E dentro daqui
temos que ajustar este, então ele está enchendo esta corda aqui
na extensão da caixa que vou
fazer agora 55, nós realmente temos que
testar isso no jogo. Então, mas por enquanto podemos
defini-lo para 55. Ou talvez se você
quiser torná-lo maior, você pode, você pode até fazer 1010. E vamos realmente fazer isso. Vamos, vamos tentar fazer
dez em vez de cinco. Menos cinco é muito
pequeno para esse número, talvez algo como
50 novamente, ou 6065. Mais uma vez, temos que
testar isso em jogos. Não tenho certeza de
como será agora. Então, algo
assim onde o
colocamos como 40 no z e 101065 aqui para
a caixa de colisão. Então eu vou voltar para
a base de escalada e
para a caixa de colisão, descendo para a colisão, a única coisa que
vou mudá-la, este pode
personagens avançar, eu vou para clicar e não, acho que
está tudo bem por enquanto, então não vamos tocar em
nada aqui. Agora, para fazer os eventos de sobreposição, você pode clicar
na caixa de colisão novamente como antes. Vá até a
parte inferior e clique neste componente,
comece a sobrepor. Então, o que deve
acontecer quando começarmos a
sobrepor a caixa aqui, vou excluir
os eventos padrão. Então, o que deve
acontecer se começarmos a sobrepor essa caixa de colisão? E você pode ver que a caixa de
colisão é esta, este quadrado aqui que adicionamos. Então, qual deve o bloqueio quando o jogador está vindo aqui e pulando naquela
caixa de colisão, o que deve acontecer? Primeiro, precisamos verificar
se é
o jogador que está interagindo
com nossa caixa de colisão. E antes disso, vou
dizer que o switch tem autoridade. Porque, novamente, para colisões,
adicionamos que tem autoridade para garantir que é o servidor que lida com
todas essas informações. Não queremos que o jogador
trapacee porque novamente, a autoridade é o servidor, o controle remoto é o cliente. E se o cliente
fizer tudo isso, então se removermos isso
e apenas codificarmos aqui, o cliente tem uma grande
chance de trapacear e não queremos que os clientes
trapaceem nosso jogo. Portanto, o switch tem autoridade, o servidor tem
autoridade sobre qualquer coisa. E o servidor verificará se os clientes têm
permissão para fazer isso. Switch tem autoridade e, em seguida,
temos que verificar se
esses são os jogadores. Então o outro ator,
que é o jogador, vamos arrastar aqui e
dizer que o ator marcou. E se o ator
tiver o tag player, e vamos fazer um ramo aqui. Autoridade. Então, assim. Então ele passa pelo servidor e verifica se
o ator tem o player de tags, que significa que é o jogador. E vamos nos certificar de que
nosso jogador tenha essa tag. Então, voltando aos planos,
jogador, base de jogadores,
acredito que o adicionamos antes. Deixe-me verificar os padrões da classe e aqui
você pode procurar por tag. E aqui adicionamos anteriormente. Portanto, certifique-se de ter o player de tags adicionado
à sua base de jogadores. Então, agora, se a tag ou se o
ator tiver o player de tags, que fazemos, se isso for verdade quando queremos
fazer alguma coisa. E eu só vou realizar
um evento chamado pode escalar. Então, quando você colide com
esta caixa, você pode subir. Mas se você não
colidir com essa caixa, isso significa que você não pode
subir porque não
há cliente sendo
objeto perto de você. Então, vamos voltar. Deixe-me abri-lo novamente aqui. E aqui podemos dizer, podemos realizar um evento
dizendo que pode subir, e isso estará dentro
da base de jogadores. Então, dentro daqui, temos que
fazer um evento primeiro, e vamos trabalhar
aqui por enquanto. Deixe-me fazer um evento personalizado dizendo eventos de tempestade
dizendo Can lime. E este que
podemos realmente
transformar em uma Interface de Blueprint. Na verdade, vamos fazer isso
imediatamente em vez de fazer todo esse trabalho. Então deixe-me ir para a Interface do
Blueprint e deixe-me ir para
a base de jogadores. E aqui, deixe-me adicionar uma
nova função de blueprint. E deixe-me dizer que pode subir. O que queremos
adicionar aqui é um booleano. Então, vou
adicionar duas variáveis. Primeiro, um
ditado booleano pode subir. E deixe-me adicionar um B aqui
para booleano pode subir. A segunda coisa é que eu quero definir o cliente sendo objeto. Então, ser cliente. Objeto. Então, é uma carta, é um manto ou o que quer que seja? Então o objeto de escalada é, novamente, o que você fez aqui. Esta base de escalada. Se você procurar aqui, é um ator de sprite de papel, então precisamos de uma referência disso. Então, vamos voltar e dizer ator
de sprites de papel
aqui, referência de objeto. Então agora temos a subida de lata
e a referência do objeto. Ok, então base de jogadores Endo, agora
podemos chamá-lo dizendo que pode subir linha e você
tem esse evento aqui. Então, isso é o que queremos
executar. Então, aqui quando você colide
na base de escalada, quando você colida com
a caixa de colisão. E é o jogador. Queremos chamar esse evento. Então, para chamar eventos
da base de jogadores, novamente, temos que arrastar do
outro ator e dizê-lo, fazer referência
que fizemos anteriormente. E então podemos dizer, podemos subir. Então, agora podemos executá-lo e
lembrar que é uma mensagem porque é uma função Blueprint
Interface. Então aqui pode subir. Temos que aceitar isso porque
agora estamos nos sobrepondo. Sim, queremos escalar
ou sim, você pode escalar. Qual é o objeto de fixação que você pode arrastar
daqui e dizer self. Porque lembre-se que você está
dentro da base de escalada. Então, se for uma corda, se for uma escada, ela vai nos dar
auto-referência e
definir-se automaticamente porque você já
está dentro daqui. Certo? Então, precisamos de
sobreposições acabadas ou sobreposição final. Então, clicando na caixa de
colisão novamente, descendo e clicando em
n-componente e sobreponha. Então, o que deve
acontecer quando você terminar sobrepor com esse componente? Vou copiar colar
tudo isso de novo, não
precisamos escrevê-lo. Mais uma vez. Adoro copiar e colar código. Então, basta conectar, lembre-se de
conectar todos esses
e poder escalar. Ele deve ser apenas removido
porque você não pode mais
subir
porque terminou a sobreposição. Quanto ao objeto Alembic, vou excluir isso
e o que isso significa, ele vai esvaziar o declínio
sendo variável de objeto. Portanto, a variável
ficará vazia porque não
estamos mais
colidindo com nada. E isso faz
sentido. Então, vamos, vamos dizer tudo aqui. E agora ele vai
até
a base de jogadores e
jogará este evento. Então, para este evento aqui pode subir em vez de fazê-lo
diretamente aqui, lembre-se de que estamos jogando
no multiplayer, então temos que executá-lo
através dos servidores. Então, fazer novos eventos personalizados
chamados Harvey e lime. Porque lembre-se quando
você define variáveis, você precisa fazer isso
por meio do servidor para garantir que o
cliente não esteja trapaceando. Então, novamente, vamos
clicar no servidor, executá-lo no servidor, confiável. E agora você pode simplesmente
executar esses eventos do servidor. Então você pode ver que esse é o mesmo padrão que temos
feito o tempo todo aqui. Como a mesma coisa
com o salto, ou passa
pelo servidor e depois passa pelo
multicast com o som. E aqui a mesma coisa
com o estado errado do movimento. Ele passa pelo servidor
e, em seguida, define a variável , então é o mesmo padrão que
estamos fazendo o tempo todo aqui. Eu diria que apenas continue praticando e ficaremos muito mais fáceis. Sei que é muito difícil
desde o início, mas agora vamos executá-lo
pelo servidor. E o servidor agora definirá
essas variáveis. Então, novamente, precisamos de
duas variáveis aqui. Um deles é um
ditado booleano pode subir. E o segundo
era um ator de papel, que é objetos em declínio. E era o jornal
um ator sprite. Este papel é um ator brilhante. Ok, então agora podemos
definir as variáveis. Vamos clicar com o botão direito do mouse
neste objeto de fixação e promovidos para uma variável. E eu vou remover
esse espaço aqui embaixo. Então, agora temos o
objeto de escalada como uma variável. E vamos clicar com o botão direito do mouse pode
subir promovido para uma variável. E eu vou remover
esse espaçamento aqui embaixo. E diz que já
temos essa variável I, e acho que é
a função aqui. Então deixe-me colocar
um B na frente, então é um booleano e agora
podemos escrevê-lo aqui. Assim, pode subir e bombear objeto. Lembre-se de que estamos no servidor, então o cliente não tem
ideia
para quais os valores
dessas variáveis estão definidos porque você as está configurando
no servidor. Então, quando eu jogo como cliente, então você tem o servidor aqui. Mas se eu jogar como
cliente, agora, não
faço ideia
do que é a escalada. Então eu posso realmente imprimir na tela
para que possamos realmente ver e
aprendermos juntos com isso. Então, arrastando esse booleano, vou imprimir o
valor desse booleano para fora. Então agora, se eu sou o servidor, este é o servidor agora
e eu vivi com ele. Você pode ver que diz
falso agora. Isso é porque não estamos
realmente passando por isso. Então, vamos fazer isso agora. Vamos conectar esses. Então, o evento, então vai
desta caixa de colisão
para a linha aqui. Isso vai defini-lo como verdadeiro. Então, a escalada é definida como verdadeira. Agora, ele vai para
a base de jogadores e
vamos conectá-los. E vai percorrer todo o caminho por aqui e
vai imprimi-lo. Então, agora ele vai dizer verdade. Vamos pular aqui. E você pode
ver que é verdade quando colidimos e diz falso quando não
colidimos mais. Então, isso está correto. Agora vamos jogar como
cliente aqui. Estou gerando como cliente. E você pode ver como o cliente, ele está dizendo verdade. Mas é naturalmente o cliente
dizendo que é o servidor. Você pode ver que ele está
imprimindo como servidor, mas eu sou o cliente. Esse é o problema. Eu, como o cliente
não faço ideia de quais são
esses valores porque não
consigo vê-los. O servidor não
me deu essa informação. É por isso que é tão importante
replicar as coisas. Esta é a base do
multiplayer e do Unreal Engine. Então, vamos clicar nessa
variável e replicar essas informações de volta aos
clientes para
que os clientes
possam ver qual é o valor. Ok, então agora que eles
são replicados, deixe-me excluir que
estão em string. Então, agora, se você
clicar em jogar e você como cliente, jogará
como esse personagem, mesmo que você esteja
pulando e veja que o servidor está
imprimindo? Isso está correto. É o servidor realmente
definindo essas variáveis. Mas agora que você está
replicando-os de volta para o cliente, o cliente pode realmente ver o verdadeiro valor disso
se for verdadeiro ou falso. Portanto, lembre-se de replicar variáveis que precisam
voltar para o cliente também. Então, para isso pode subir, podemos arrastar deste
booleano e fazer um ramo. Então, agora, se você pode subir, temos que fazer alguma coisa. Se você não conseguir escalar, temos que fazer outra coisa e faremos isso
na próxima lição.
57. Entrada de movimento para cima e para baixo: Vamos agora dar ao jogador
a capacidade de se mover para cima e para baixo nesta corda
aqui. Para mover para cima e para baixo. Vamos voltar
aos planos e vamos adicionar o movimento
dentro da base do jogador. Então, dentro daqui,
até agora temos esse chamado movimento para a
direita e para a esquerda, mas precisamos de um novo
chamado mover para cima e para baixo. Então, vamos realmente
fazer novas entradas. Então, vamos voltar às configurações de edição
e projeto. Lembre-se
que fizemos isso há algum tempo. Então, espero que você se lembre disso. Então, vá para as configurações do
projeto, clicando nas entradas. E dentro daqui
temos isso até agora. Vamos fazer um novo
mapeamento de acesso e vamos chamá-lo mover para cima e para baixo, para direita e para a esquerda, se você quiser. Você também pode ouvir que
Lipsky fez os errados. Então aqui eu quero
clicar neste mais aqui, você pode adicionar mais
botões se quiser. Por exemplo, a seta para
a direita e a
seta para a esquerda no teclado. Então, tanto da quanto direita e
esquerda funcionam no teclado. E lembre-se para a esquerda
você tem que escrever menos um. Então, caso você queira
no seu jogo também, você pode até adicionar um controle
também para jogar, mas precisamos de um
pouco mais de configuração lá. Então, vamos nos concentrar aqui neles. Mova-se para cima e para baixo. E podemos usar W para mover para
cima e S para se mover para baixo. E novamente temos que escrever menos um para o S.
Então subindo como um, menos um para a descida. Se você quiser, você pode
adicionar as teclas do teclado. Então, seta para cima, seta para baixo. E vamos fazer menos
um na seta para baixo. Ok, então agora nós
mudamos para cima e para baixo. Vamos fechá-lo. E dentro daqui
eu realmente vou
escrevê-lo como a
primeira coisa aqui em cima. Este é o nosso principal evento. Então, vamos escrever, mover para cima, para baixo e vamos selecionar
esse evento de eixo. Então movendo-se para cima e para baixo. Então, antes de voltar aqui,
você disse para obter rotação de controle e, em seguida, você obteve
o vetor para frente. Talvez você já
consiga descobrir. Então, o que vamos
escrever aqui, então obtém rotação de controle aqui. Então você quer
colocá-lo em vetor. Então agora vamos
subir e descer. Vamos adicionar, novamente, adicionar entradas de movimento,
como antes. Vamos conectá-lo aqui e vamos conectar
o valor do eixo aqui. Agora, se você compilar
e clicar em salvar e clicar em jogar. E se você clicar em
cima e para baixo, você verá que nada está
realmente acontecendo, mas você tem seu código escrito. O problema está aqui em
um irreal é que o cima e para baixo
só funcionará sempre que você mudar
o modo de movimento. Então, no movimento do personagem, você pode ver que temos modos de movimentos
diferentes. Agora você está
no movimento andando. Então, fixamos nossa velocidade de
caminhada e assim por diante. Então, somos de fato o
movimento do personagem andando. Mas quanto a subir e descer, você realmente precisa mudar
seu movimento para o vôo. Então você está realmente voando. Tecnicamente. Temos que mudar
isso para isso e
faremos isso
na próxima lição. Então, não agora. Esta é a razão pela qual isso não
está funcionando agora. Mas antes de terminarmos aqui, deixe-me realmente adicionar
este booleano aqui. Desde que já fizemos isso. Só queremos mover para cima e para baixo sempre que estamos
aplicando seres. Portanto, não estamos interessados em fazer
isso se não estivermos escalando. Então, vou arrastá-lo aqui
e fazer uma filial aqui. Então, se esse booleano
pode escalar é verdade, então vamos executar
esse código porque não faz sentido
executar esse código se
você não conseguir escalar. Tudo bem, então foi isso para
este vídeo, muito curto. Mas mais tarde vamos adicionar agora na próxima lição, na verdade o condicionamento de escalada. Então, estamos estabelecendo algumas regras em quando o jogador
pode escalar o burnout. Então, vamos passar para
a próxima lição.
58. Condicionamento de subida: Agora vamos adicionar algum
condicionamento e as regras para quando
o jogador pode subir. Então, vamos voltar para
a base de jogadores aqui. E em vez da base de jogadores, vamos até este onde paramos. Eles podem subir. Então, se você agora novamente, deixe-me lembrá-lo
aqui nas plantas dentro da base de escalada
e escalada, é aqui que você interagiu com a caixa de colisão de
sobreposição inicial. E agora eu posso escalar é verdade. Então, o que acontece quando
eles podem subir é verdade. Quando a vaca pode subir é verdade. Você quer verificar se o
jogador está pressionando a tecla W. Então, movendo-se para cima porque
o jogador quer subir, porque realmente não
queremos subir aqui. Se o jogador não estiver
pressionando para cima ou w, só
estamos interessados em
estar o cliente sempre que o
jogador estiver pressionando para cima. Então isso é algo
que você precisa verificar. Então, vamos voltar aqui. E quando você pressiona
aqui no movimento, então lembre-se
que vai mais um. Se você clicar em S movendo-se para baixo, ele vai ser menos um, como dissemos anteriormente. Então, na verdade, vou
transformar isso em uma variável para que
possamos usá-lo mais tarde. Então deixe-me clicar com o botão direito. Na verdade, não
podemos defini-lo diretamente. Só podemos fazer isso
em um jogador. Então, novamente, temos que
executá-lo pelo servidor. Então deixe-me fazer um novo evento aqui, evento
personalizado e
chamá-lo de valor do eixo Z. Porque lembre-se, z é, estamos movendo para cima e para baixo
e este é o eixo z. Então defina o valor do eixo z x x, z. E vamos executá-lo
através do servidor, o
servidor define o valor do eixo z. Na verdade, sou que podemos fazer isso
através da interface, da interface do Blueprint
e da base de jogadores. Então deixe-me realmente
fazer isso em vez disso. Interfaces da base do jogador e
deixe-me criar uma nova função, chame-a de definir o valor do eixo z. E, obviamente, há, o
valor é um flutuador aqui, isso é o que estamos
tentando definir. Então deixe-me criar cargas de
entradas flutuantes, ok? E vamos chamá-lo de eixo Z. E deixe-me, sim, o
eixo z está bom. Deixe-me voltar para
a base de jogadores. E dentro daqui, vamos chamá-lo de definir o valor do eixo z. E esta é a função de
interface. E agora ele vai
passar pelo servidor. Então, vamos definir este para
ser executado no servidor e confiável. Deixe-me mover isso um pouco
para que
possamos ver o que está acontecendo
e me deixar descer. Ok, vamos executar este evento de
servidor aqui. conjunto x é o valor do eixo z e precisamos de um flutuador. Então, vamos criar um flutuador aqui. E vamos chamá-lo de eixo z. E agora o que podemos fazer é que
podemos clicar com o botão direito do mouse e promover isso em uma variável
e chamá-lo de eixo z. Aqui. Temos o eixo z e
deixe-me conectar todos esses. E agora podemos chamá-lo aqui. Então, se pode escalar é verdade, só
estamos interessados em atualizar isso sempre que realmente
pudermos
escalar, mas porque antes que possamos escalar, não estamos realmente interessados se o jogador pressiona para cima ou não. Só estamos interessados se o jogador pressionar o máximo em nada
sempre que puder subir. Então deixe-me aqui dizer definir o valor do eixo
z aqui. E, na verdade, deixe-me chamá-lo a
partir do valor do eixo zdefinido. Deixe-me realmente chamá-lo
da base int player. E assim. E agora nós conectamos isso,
temos que conectar este, o eixo ou esse valor de eixo
ao eixo z aqui embaixo. E deixe-me apenas executá-lo aqui. Certo? Então, agora temos
tudo conectado juntos e esse valor de eixo será atualizado através
desse valor definido do eixo z. Vai descer aqui
e depois para baixo nesse valor. Lembre-se do que eu disse antes, você precisa replicar
isso
para que essas informações sejam
enviadas a todos os clientes. Else é apenas o servidor que conhece o valor
dessa variável. Tudo bem, então
vamos descer aqui novamente. Então, pode subir, se
pode escalar é verdade. Então agora estamos interagindo
com a corda. Vamos pegar esse eixo z aqui. Se o eixo z for maior que 0. Então, o que significa que o jogador
está pressionando. E podemos realmente
excluir isso e apenas dizer, se o eixo z não for igual a 0, então queremos fazer alguma coisa. Então deixe-me fazer isso. E então podemos
fazer uma filial aqui. Se o eixo z não for igual a 0, então queremos fazer um novo ditado
booleano está subindo. Então, vamos fazer um
novo booleano aqui. Dizer que B está subindo. Então agora, antes de termos
esse chamado pode escalar, mas agora estamos realmente subindo. Então, estamos fazendo um novo
booleano chamado é escalar. E novamente, temos que
executá-lo através do servidor para que
possamos fazê-lo aqui
assim, porque lembre-se, já
estamos dentro
do servidor, mas acho que vamos
usá-lo mais tarde onde nós na verdade vamos usá-lo aqui através do cliente e ele precisa ser
executado pelo servidor. Então, vamos realmente
fazer um evento para isso. Vamos criar um novo
chamado evento personalizado. E deixe-me fazer isso diretamente dentro da interface aqui. E basta chamá-lo,
set está subindo. E ele só vai
tomar um booleano como uma entrada. É Vi, está subindo. E vamos voltar
para a base de jogadores. E aqui podemos dizer que o
set está subindo. E podemos chamar esse
evento que acabamos de criar. Vamos fazê-lo passar
pelo servidor. Então, vamos criar um
novo evento personalizado. O mesmo conjunto de servidores está subindo. Dê a ele uma entrada de
uma linha booleana chamada é assim. Certo? E este realmente pode subir, mas vou colocar um B
aqui apenas para boas práticas,
apenas certificando-se de que tudo está
correto e possa escalar. Tem um B aqui, então isso é legal. Então aqui o set está subindo e vamos executá-lo através
do servidor, confiável. E a única coisa que
vamos fazer aqui é fixada em dois, é escalar. Então, criamos essa variável, arrastamos para fora, configuramos aqui e vamos executar isso
pelos clientes para ir
para os servidores. O conjunto de servidores está subindo
e conectá-lo aqui. Ok, então vamos
definir essa variável aqui. E o que queremos fazer com este não é replicado. Replicado só é
usado quando você deseja enviar informações aos clientes. No entanto, novamente, a
notificação do representante é usada quando você quer mudar
algo visualmente. Portanto, não apenas informações como
aqui e o valor do eixo z, nós só queríamos
enviar informações. No entanto, aqui queremos fazer alterações
visuais porque
vamos mudar
o flip book
para o cliente que está sendo flip book. Então, vamos alterar essa replicação para notificar
encapsulamento porque
temos algumas mudanças visuais que precisamos
recusar saber. Ok, então aqui
vamos adicioná-lo. Portanto, se o valor do eixo z não
for igual a 0, o
que significa que o jogador está
pressionando para cima ou para baixo, então queremos subir. Então, vamos fazer isso. Digamos
que o conjunto esteja moendo. Agora podemos chamar isso, set está subindo e
podemos fazer isso como verdade porque
agora queremos escalar. No entanto, aqui no outono. Então deixe-me realmente arrastar isso uma maneira melhor aqui no falso. Para que possamos subir. Mas agora deixamos a corda. Então agora não podemos mais escalar porque quando você termina
se sobrepõe aos bugs. Aqui, digamos que
já estamos sendo escalados
e isso fica falso. Temos que definir isso
como false também porque senão não temos nenhum lugar em nosso código
agora
especificamos quando isso
será falso? E se você estiver subindo
na corda e
deixar a fileira, então esta
ainda está definida como verdadeira. Então, vamos copiar isso e
colocá-lo aqui assim. Então, digamos que
já estamos escalados sendo, então deixe-me pegar que isso é escalar e deixe-me
dizer ramo aqui. Então, se estamos, então aqui, se deixarmos a caixa de colisão
aqui na base de escalada, se a deixarmos e
ela estiver definida como falsa. Se já somos seres
escalados. Então, se houver, se houver escalada
definida como true, vamos seguir em frente e
defini-la como false. Apenas certificando-se de que
isso está definido como falso. E ainda não estamos
subindo assim. Então deixe-me
avançar e avançar isso e organizar
isso um pouco mais. Mais uma vez. Quando algo
não estiver estruturado corretamente, você pode selecioná-los e clicar em Q no teclado para
torná-los uma linha como essa. Ok, então temos um
pequeno problema com isso e talvez você
já consiga descobrir. Deixe-me compilar
aqui e deixe-me imprimir isso na
tela assim. E, na verdade, deixe-me ir para o cliente sendo
baseado na verdade na corda. Então, vamos para a
escalada da corda. Deixe-me ir para a
janela de exibição e apenas aumente isso para 80 ou
algo assim. Algo grande. E deixe-me colocar o jogador aqui em
cima. Assim. Deixe-me clicar em Play. E agora, na verdade, eu quero imprimi-lo na tela também. Então, indo para a base de jogadores, agora vamos imprimir
olá. Sim, isso é bom. Então deixe-me clicar em Play. E agora, se eu clicar na tecla
do mouse para baixo e eu me mover, você pode ver se eu me movo. E então deixe-me me mover primeiro. Então, clicando em um para mover
e, em seguida, clico em S aqui. Você pode ver isso diz
Olá, porque ele pode verificar se quando estou correndo, então eu colido com quando
estou correndo e depois colidem com minha caixa aqui
e ela está pronta para subir. Ele pode ver que estou pressionando meu eixo z, então
não é igual a 0, o que significa que ele realmente
vai definir para escalar seres. Portanto, isso está sendo executado corretamente. No entanto, o problema
agora que temos é se eu estiver de pé na corda
e eu quiser descer, se eu clicar em S para descer, não vai realmente verificar. Porque lembre-se, esse
evento só é executado uma vez. Só é executado sempre que
você colide com a caixa. E se você já estiver
colidindo com a caixa? E se você estiver de
pé na caixa? Isso nunca
correu novamente. Isso só vai
correr sempre que você deixar a colisão e
depois colidir com ela. Mais uma vez. Este evento aqui
só será executado uma vez se você não estiver pressionando o botão Down no momento em
que estiver colidindo
com o, com a corda, isso ainda
será 0, então isso nunca verificará. Então, se eu clicar em, se eu
voltar ao meu jogo aqui, clique em S para descer. Isso realmente não
vai funcionar. Então, precisamos de algo para fazê-lo verificar
continuamente aqui
sempre que eu estiver na caixa de colisão aqui para verificar
continuamente se isso
é igual a 0 ou não. E, novamente, usamos
temporizadores para isso, já
usamos
o temporizador aqui. Portanto, verificação contínua,
você sempre pode usar temporizadores, ferramentas
muito boas para lembrar. Então, vamos ouvir, desconectar
isso e melhorar esse código. Então deixe-me fazer um temporizador, conjunto, temporizador por eventos. Vamos conectá-lo aqui. Agora
podemos fazer um evento duas corridas daqui e arrastá-lo
para fora e dizer entradas de cal. Na verdade, vamos fazer eventos
personalizados. Foi o que eu quis dizer. E
chame-o de entradas escaladas. Então, essa entrada do cliente, vai verificar, isso
é igual a 0 ou não? E se não for, então
vá em frente e suba. Vou organizar isso um
pouco mais assim. E para este, para o temporizador,
vou fazer um loop. E durante o tempo
que ele vai fazer um loop, vou escrever 0.1, que significa que todo o
loop é executado a cada 0,12, o que significa que isso é executado
dez vezes por segundo. Sempre que sou cliente, não
quero mais
verificar isso. Então, vou promover
isso para uma variável. E vamos chamá-lo de
verificar entradas caladas. E eu vou pegar isso e dizer Lear e
temporizador invalidado por alça. Então sempre que, sempre que
verificamos aqui, então estamos verificando a entrada. Então, sempre que estamos
vendo que o jogador está pressionando para cima e
para baixo nesta corda, o que significa que
vamos subir. E naquele momento, não
queremos mais verificar. Porque todo o objetivo
disso é apenas verificar se o jogador está pressionando para cima e
para baixo nesta caixa de colisão. Então, podemos
parar desta vez. E lembre-se, se você
não parar o temporizador, eu vou te mostrar. Então, se você acabou de imprimir
Olá o tempo todo e você pode gostar que depurar
com o halo é tão útil. Então, clicando em S para
baixo para descer, você pode ver que está imprimindo
Olá o tempo todo. É claro que é melhor
quando você não pressiona
mais S porque você
não está realmente se movendo para baixo. Mas se eu pressionar, ele
imprime o tempo todo, eu realmente não
quero imprimi-lo o
tempo todo sempre que estou subindo porque isso só é útil
para verificar se já, se você realmente
quer subir a corda . Então, se já
estivermos
escalados, não
queremos verificar isso. E é aqui que dizemos temporizador
claro e invalidado por alça. Porque agora podemos dizer, quando isso for verdade,
vamos configurá-lo para subir e ir em frente e
remover esse temporizador. Então, se eu clicar em
Jogar agora e eu ir aqui e clicar em
S, mantenha-o pressionado. E é claro que temos que
imprimir algo, então vou colocar algo para possamos realmente
ver o que está acontecendo. Vou clicar em Play,
clicar em S para mover para baixo. E mesmo que eu esteja
segurando agora, ele só disse olá uma vez. É assim que você faz algo
otimizado e blueprints, lembre-se de parar o temporizador sempre que não
precisar mais dele. Else vai correr para sempre e você
realmente não quer fazer isso. Então, para o temporizador aqui também, apenas para garantir que ele pare, vamos copiar esse código. Deixe-me ir aqui. Então, se pode escalar está definido como falso. Então, sempre que você termina se sobrepondo com a caixa de colisão, estamos. Então, se você já está subindo
e vai deixar a corda, lembremo-nos novamente de
parar esse temporizador. Então, apenas certificando-se de que o temporizador não esteja mais
funcionando. Então foi isso para
este vídeo aqui. Então, temos muitas coisas feitas. Configuramos o temporizador para verificar
continuamente se o
jogador está se movendo para baixo ou não. Então, todo o processo
é apenas para explicá-lo muito rapidamente antes de
encerrarmos este vídeo, caso você precise de
uma explicação completa. Então, o que estamos fazendo
aqui inicialmente é o jogador vai
pular aqui na corda. O jogador
tocará nesta caixa de colisão. E o que o jogador toca
nessa caixa de colisão, este evento será jogado. O evento
passará pelo servidor e verificará
se o ator tem
o jogador técnico apenas para se
certificar de que o jogador está realmente tocando na
corda e não em outra pessoa. E isso é, se isso for verdade, vamos chamar o evento
can climb, que está dentro do
jogador, ator jogador aqui. Vamos definir pode
escalar booleano para ser verdade. Então, queremos subir, e qual é a coisa que
vamos escalar? Aquela coisa que
vamos subir sozinhos, que é o que
você colocou aqui. Então, neste caso,
colocamos a corda deles, que é um filho de
escalada, base de escalada. Então, escrevendo a si mesmo, ele sabe automaticamente
ir aqui para a corda. E este é o ator
que estamos escalando. Então ele vai
subir para poder subir. Então, começamos aqui. A informação
aqui, o booleano, você definiu
que ela é verdadeira, então será
aqui para verdade. As informações
continuarão aqui no servidor, enviando essas variáveis e
vendendo-as para replicá-las. Como estamos
interessados em fornecer essas informações aos clientes porque estamos no
servidor agora,
o cliente não tem
ideia de qual
é esse valor se você não
replicá-lo de volta para os clientes. Agora, se eles conseguem subir é verdade. Vamos verificar se
o jogador está realmente pressionando o botão
para baixo para subir a corda. Se o jogador estiver pressionando
o botão Down, vamos definir, isso está subindo para true. Quando fizermos
isso, ele vai definir o cliente dele passando pelo servidor,
passando pelo servidor aqui
e, em seguida, definindo essa
variável como true. Agora nós codificamos isso,
mas faremos
isso na próxima lição. Então, definimos isso
para enrolar notificar, o que, novamente, lembre-se uma notificação vermelha cria
uma função na rampa. Aqui vamos codificar
muitas coisas, como mudar seu flip book para
recusar ser flip book. Assim, o jogador visualmente pode
ver que você está subindo. E se eu voltar aqui, então se eles podem subir é falso. Se você já está, se você
já disse que está subindo para ser
verdade, isso é verdade. Vamos defini-lo como falso porque você não
pode mais subir. E vamos
parar o temporizador de qualquer maneira. Se eles puderem,
subir será falso e você
não o encontrará.
59. Como atualizar o modo de movimento do jogador: Olá e bem-vindo de volta. Então, há um pequeno bug
agora antes de começarmos, você pode ver se eu me
movo para cá para o lado, de
repente meu sprite desaparece e se eu
voltar, ele aparece. Muito, muito estranho bug
que temos agora. Vamos corrigi-lo, na verdade,
antes de eu seguir
em frente para corrigir esse bug estranho, descobri que se você for para as plantas e
ir para a base de
escalada, escalada aqui, vamos enfrentá-lo por todo o
aperto objetos, você pode clicar no componente de
renderização. E se você descer
para renderização aqui, você pode clicar em Avançado. E se eu minimizar isso, você também pode ver
desaparecer sempre que. Deixe-me clicar em G para
remover tudo isso. Você pode ver que aparece
quando estou aqui, ele desaparece quando estou aqui. Descobri aqui na renderização
em componentes de renderização que você pode ir para a prioridade procurada por
translucidez e escrever uma, Compilar e Salvar. E você pode ver que
ele aparece para que esse bug não
apareça mais. Tudo bem, então o que
queremos fazer
agora é que queremos atualizar
o movimento dos jogadores. Então, agora temos
a coisa correta, estamos fazendo a coisa correta. Mas agora, não podemos
realmente viver aqui em cima. E isso é porque queremos, devemos mudar o modo de movimento
do jogador. Então, vamos voltar para
a base de jogadores. E dentro daqui, vamos
começar a codificar a coisa dentro do nosso ISClient
sendo a função desembrulhada. Então, entrando aqui, vamos primeiro arrastar a
variável e escrever uma ramificação. Então, o que deve acontecer
quando você está escalando? Então o jogador acerta a corda e pressiona o
botão W para subir. O que deveria acontecer? A primeira coisa que queremos fazer é pegar o componente de
movimento do personagem e, em seguida, arrastar daqui e
dizer Modo Definir movimentos. Este aqui. E então isso é, vamos definir
isso para voar porque quando você está escalando,
você está realmente voando. Por padrão, agora
estamos andando por aí, e esta é a caminhada. Sempre que estamos pulando. Lembre-se aqui no salto, se eu voltar para o Event Graph, sempre que pulamos, então se eu puder
achar que o código está em algum lugar aqui. Então, para o
código de salto aqui,
você pode ver mais cedo,
se você se lembrar, fizemos desta uma
função pura onde
verificamos se o
movimento do personagem caindo não era verdadeiro. Cair é sempre que estamos pulando aqui e
o modo de movimento, se eu voltar para a função de
desembrulhar, a queda é sempre que
você está pulando, a caminhada é agora
quando estamos andando por aí. No entanto, quando queremos subir, temos que colocá-lo para voar. Então, estamos realmente
voando por aí. E pouco antes de eu esquecer, deixe-me ir aos
movimentos do personagem e ir até aqui para
voar aqui. Deixe-me definir a
velocidade de voo para 1 quinto. Eu testei na história do Maple, então joguei a história do Maple
hoje para conferir. E é de cerca de 115 velocidades. Você tem que testá-lo no jogo
para ver que você pode deixar ser 600 e você pode realmente testar
e ver o quão rápido isso é. Mas vou
mudá-lo para 150 agora. E quebrando a aceleração
se você não colocar isso. Então, se você clicar em
W e soltar, você ainda vai
voar para cima. Eu não quero isso. Eu quero que o Wonder
player que solte o botão W para
não subir mais. Quero que o jogador pare completamente e não
deslize para cima ainda. Vou colocar
isso em algo alto, como 10 mil. Então, alguns apenas um
número aleatório, Compile e Save. E quando o jogador não
está subindo, então quando o jogador
soltar a corda, eu vou copiar
colar isso e defini-lo para cair porque
realmente andando, porque eu quero que o jogador
caia de a corda. Então, algo assim. E se você, novamente, se quiser
fazer isso parecer melhor, provavelmente deve mover essa
plataforma e dar lances para cima. Então, na verdade, isso não está
atingindo o chão. Então, vamos voltar para
a base de jogadores aqui. Então, quando o jogador não
está subindo, vamos
colocá-lo para cair. Agora vamos definir nosso flip book. Então, vamos levar nosso sprite aqui. Digamos definir flip book. E vamos
conectá-lo primeiro aqui para a escalada. Então, quando estamos subindo, queremos que o cliente seja animação e
deixe-me copiar colar isso. E quando estamos caindo, queremos ter nossa animação de
salto. Então, a animação de salto que
temos agora, mas em declínio, não temos, então precisamos preparar isso. Então aqui para a queda, você tem essa animação de salto. Lembro-me de que temos
dois personagens e queremos tornar isso o mais
dinâmico possível. Então, vamos tomar nossa estrutura
novamente. Vamos quebrá-lo. E aqui agora podemos fazer
nossa animação de salto. Tomando essa animação de salto
e conectando-a aqui, escondendo todos os outros
pinos assim. Então, parece muito mais limpo. Então agora temos isso pronto, mas quanto ao voo, não
temos uma animação de
escalada agora. Aqui nos materiais do curso
nos personagens da czarina. Você pode ver que eu
preparei a subida para você, bem como em Luke. Então, vamos continuar e
minimizar isso aqui. Vamos para o azul, na verdade aqui nos personagens de
ativos ou Serena primeiro
e nas texturas. E deixe-me importar a subida e fazer a mesma
coisa para o loop for. Então vá para a textura Luke. Aqui. Temos Luke e a
subida, tão importantes, mas ambos
clicam com o botão direito do mouse neste 1 primeiro e aplicam papel
às configurações. Faça o mesmo pela Serena. Clique com o botão direito, aplique papel às configurações e
clique com o botão direito aqui. E vamos extrair os sprites. A grade é um oitenta, um oitenta clicando em extratos. E então este, você tem que
renomeá-los para S lime 01. Este é, na verdade, 0202. E este, Onde está
o outro aqui? 01. E faça a mesma coisa pelo Luke. Então clique com o botão direito, Extraia sprites, grade, um oitenta, um oitenta. Este aqui é como 01 e o outro
é o clima 0 a. Agora, você pode
selecioná-los com o botão direito do mouse para criar um flip book chamado FB escalado. Arraste-o para a pasta do Luke. E vamos definir os quadros
por segundo para quatro. Então vamos defini-lo para
quatro assim e fazer a mesma coisa para
Serena aqui para o cliente,
clique com o botão direito do mouse, faça um
flip book chamado escalar. Coloque-o fora dessa pasta. Aqui vamos mudar os
quadros por segundo para quatro. Agora vamos salvar tudo
e temos que lembrar adicioná-lo à nossa estrutura
aqui na base de jogadores. Então, ainda não fizemos isso. Então, vamos para a
estrutura e os blueprints, estruturamos as informações do jogador e
vamos adicionar uma nova,
uma nova variável chamada animação de
colina. Agora, se você quiser adicionar, vamos
torná-lo mais dinâmico. Então você não
tem necessariamente uma corda. Você também pode ter uma carta e isso terá
outra animação. Assim, podemos chamá-lo de
emissão climática ou ser melhor, ou você pode chamá-lo de animação
de corda. E mais tarde, se você quiser, você pode adicionar uma animação de escada. E isso é outra animação. Então, animação de robôs,
vamos chamá-lo de
flip book em papel ou a variável é um flip book em papel, como aqui. E vamos salvar, deixe-me realmente mover isso para cima, então arraste-o para cima
dos efeitos sonoros. Sim, eu realmente queria que
os efeitos sonoros estivessem
aqui embaixo na parte inferior. Então, emissão de Robin,
economize. Por aqui. Vamos realmente salvar
tudo, compilar e salvar. E você pode ver a animação
de corda aparecer. Deixe-me clicar nele novamente, clique em Ocultar pinos não conectados. Então, aqui em cima, o que queremos
fazer é copiar colar essa estrutura. E você pode, como, ver sempre que esconde pinos
não conectados e ele
se esconde assim, agora
você pode vê-los mais. Você pode clicar nele e
clicar nesta categoria padrão e você pode selecionar este
é o vôo, então é uma escalada, esta animação de corda
e você pode vê-la aparecer e você pode
conectá-la aqui. Agora lembre-se, você precisa
conectar a animação de corda porque ainda não
especificamos o que ela é. Então você tem que ir para
Serena e Luke. Então, o jogador de blueprints. Vamos começar com uma olhada aqui. Lembre-se na classe T false, você tem que definir a animação
de corda. Então, se subir para Luke, vamos para Serena. Para Serena, vai
ficar assim. Então, animação de corda. E então vamos encontrar carro funerário. Este FP subiu. Ok, então agora eles
deveriam estar funcionando. Agora, vamos voltar
à nossa base de jogadores. Então, agora o que estamos fazendo é enviá-lo para o modo de vôo. Então, devemos ser capazes de
mover-se para cima e para baixo aqui
no gráfico, eu desço. Então, devemos ser capazes de
mover-se para cima e para baixo porque agora estamos no
modo de vôo e podemos escalar. E deixe-me voltar aqui e então estamos definindo o flip book. Então, vamos realmente tentar jogar e ver se estou
perdendo alguma coisa. sempre bom testá-lo. Então, vamos salvar
tudo. Vamos jogar. Agora, se eu for aqui,
clico em baixo. Você pode ver que estou realmente me movendo. Mas o problema é que esse bloco de colisão está
parando meu personagem. Então deixe-me realmente
experimentá-lo de baixo aqui. Cair. E se eu for para a corda aqui, você pode ver que estou
subindo e descendo a escada. O problema está aqui, o título está nos impedindo de subir. E isso é algo que queremos consertar isso no próximo. Mas acredito
no próximo novamente, removemos essas colisões
para que possamos avançar para cima. Também temos um pequeno inseto
onde podemos caminhar para os lados, mesmo
estando caminhando aqui. Então, vamos seguir em frente e corrigir isso. Deixe-me clicar em escapar e
deixe-me abrir a base do jogador. E aqui em cima,
deixe-me ir ao Event Graph. Deixe-me fechar tudo. Acho que tenho muito
aberto, muitas coisas abertas. Agora, aqui no Event Graph, vou clicar com o botão direito do mouse e
dizer guias fechadas à direita. Então eu só tenho isso
aberto agora. Então, aqui, no
movimento para a direita e para a esquerda, nós realmente não queremos nos mover
para a direita e esquerda sempre que você estiver subindo. Então, podemos adicionar um
booleano para isso. Então, se eu arrastá-lo de
volta aqui e pudermos usar o que está escalando e
você pode escrever um booleano. Então, se você não estiver subindo, você poderá se mover
para a direita e para a esquerda. Mas dois, se você está
subindo uma corda, nós realmente não queremos nos
mover para a direita e para a esquerda. Então, algo simples como esse
pode corrigir um bug como esse. Então, apenas usando um booleano, às vezes você pode
evitar algum código. Então lembre-se sempre que os booleanos
são muito, muito úteis aqui. E você pode ver que não consigo me
mover para a direita e para a esquerda. E também nossa animação, animação de escalada está
funcionando perfeitamente. Agora, não posso, não posso me
afastar da minha corda porque acredito que
minha caixa de colisão é muito longa agora. Então deixe-me voltar para a corda. Porque estávamos testando aqui, indo para a corda aqui. E deixe-me reduzir
isso para algo como 65, algo assim. Clicando em Jogar
agora você pode, bom,
na verdade, deixe-me colocar meu
jogador começa aqui em baixo. Nós realmente não precisamos
cair o tempo todo. Aqui. Posso subir, posso me mover para baixo e posso deixar minha corda aqui. Mais uma vez. Você pode colocar essa plataforma
mais alta se quiser, ou pode simplesmente tornar a caixa de
colisão um
pouco menor você não
precise necessariamente ir
até aqui. Então, algo como 60
e eu posso movê-lo para cima, algo assim. Então, clicando em Jogar novamente. E podemos pular e
deixaremos a corda sempre que estivermos
em algum lugar por aqui. Certo, muito legal. Agora podemos mover para cima e para baixo. E você também pode ver
que estamos deslizando um pouco quando eu me
mudo para o lado. Às vezes, estou me
afastando da corda,
algo assim. Então agora estou subindo
e descendo a estrada, mas também estaremos ajustando a
localização do cliente mais tarde. Então não se preocupe com
isso, mas por enquanto, você pode ver que podemos pular enquanto
estamos aqui na corda. Então, vamos consertar isso também. Então, vamos voltar para a
base de jogadores e para o salto. Então, vamos encontrar a lógica de
salto novamente. Se você não está
caindo e
não está alinhado, nós
realmente não queremos pular
quando você está subindo. Então, vamos pegar isso.
E aqui podemos dizer que acabe aqui e booleano. E você não está escalando. Tão nozes, booleano. Novamente, se você estiver, se você não está caindo
e você não está subindo, nós realmente não queremos
pular quando você está subindo. Deixe-me avançar e deixe-me clicar neste e
clicar em Ocultar pino não conectado. Então, ele sobe novamente e
conecte este em vez disso. Então, se estamos caindo,
não queremos pular. Se formos sendo colina, também não
queremos pular. Então, temos que verificar
esses dois para garantir que só podemos pular em seu
nullcline estar ou cair. Então deixe-me aproximar
isso e
podemos testá-lo novamente,
Compilar e Salvar. Podemos jogar, ir na estrada. E se eu clicar no espaço, posso adicionar salto aqui. Ok, então agora isso está corrigido e vamos
para a próxima lição em
que realmente fazemos uma enumeração de
objetos de escalada. Então, em vez de fazer
o, a corda só você pode
realmente adicionar letras e animações para
elas também.
60. Enumeração de tipo de objeto de escalada: Ok, então, até agora aqui na rampa está a função de escalada. Até agora, adicionamos
que devemos mudar para a animação do roupão
sempre que você estiver subindo. Mas e se você
também tiver uma escada? E se você tiver outra coisa e precisar de uma nova animação, você precisa de uma animação de
escalada de escada. Talvez você tenha duas
animações em seu jogo. Agora queremos fazer uma
enumeração para corrigir isso. E eu gosto de tornar
meu jogo dinâmico. Então, no futuro, quando eu
quiser adicionar algo, posso fazer isso em dois minutos, não em 30 minutos. Então, vamos tornar tudo
dinâmico agora. Demora um pouco
mais para fazer isso, mas economizará
muito tempo quando você tiver
criado seu jogo. Sempre tente fazer essas coisas
boas para o seu jogo. Tente fazer boas práticas de codificação. E você pode economizar muito
tempo sempre que criar um DLC ou o que quer que esteja
tentando criar atualizações mais tarde. Você pode fazer isso em dois segundos. Então, vamos tentar fazer
uma enumeração primeiro. Novamente, as enumerações são
muito, muito poderosas. Até agora, criamos
esses estados em movimento. Então, vamos realmente
clicar com o botão direito do mouse aqui, vá para blueprints e
crie uma nova enumeração. Vamos chamar esse tipo de objeto de
escalada E. Se eu pudesse soletrar aqui
digite e clique nele aqui. E deixe-me adicionar dois
tipos por enquanto. Eu realmente não tenho
mais do que isso. Então eu tenho uma corda e tenho uma escada como essa,
então salve tudo. E vamos voltar para
a linha estando aqui
e escalando a base. E deixe-me adicionar essa
variável às minhas variáveis. Então, chamando essa
linha de tipo de objeto. Agora vamos adicionar esse tipo
à nossa enumeração que fizemos chamada de tipo de objeto
de escalada. Esta é a enumeração. Então, o que podemos fazer isso
agora que lembre-se quando
adicionamos variáveis ao pai, classe
Blueprint será
adicionada a todos os filhos. Então, clicando na corda aqui, você pode ver nos padrões da
classe, agora
posso ver essa enumeração. E você pode alterar o tipo de cada coisa que você adicionar aqui. Então esta corda é
obviamente uma corda. Mas se você adicionou mais tarde
uma escada, você pode realmente
mudar isso para um isqueiro e ele saberá
que esta é uma escada. E quando ele sabe que
isso é um lateral, ele sabe que deve
tocar a animação mais leve. Então, vamos realmente codificar
essas informações. Então este é apenas uma corda. Então eu acabei de definir minha nova
enumeração para corda. E vamos voltar
para o cliente sendo base e podemos
adicioná-lo aqui na verdade, na
verdade, não a base de escalada. Vamos voltar para
a base de jogadores. Foi o que eu quis dizer. Indo para uma base de jogadores. E nos ouvidos, o
recorte está subindo. Função Unwrap. É aqui que queremos adicioná-lo. Então, vamos afastar isso
um pouco mais longe. Aqui nos perguntamos
a referência ao nosso cliente ser base porque
queremos usar essa variável. E lembre-se que já
fizemos uma variável para isso. Se você for aqui, quando dissemos que pode subir, acrescentamos lembrar
que a auto-referência. Então, na verdade, já estamos
definindo essa base de escalada, que precisamos chamar essa
função ou essa variável. Agora, podemos criar uma Interface de Blueprint e
dizer que o cliente é base. Você poderia fazer isso
se quiser. Mas para este jogo,
isso é muito mínimo. Eu não quero, não quero
incomodar porque
não vamos usá-lo tanto quanto a base de jogadores e para o que
estamos usando. Então eu vou custar, eu disse que antes é bom
custar desde que você não
faça isso o tempo todo. Então, vamos voltar aqui
e podemos apenas
pegar essa referência aqui, deixe-me descobrir que o objeto de
aperto, deixe-me agora arrastá-lo
e dizer custo também. Então, qual é o objeto de escalada? O objeto de fixação é quando custamos para
algo que podemos dizer
que está falando especificamente
sobre essa base de escalada da BP. Portanto, o objeto de escalada
é especificamente esse modelo porque
lembre-se dessa referência, se você segurar o mouse sobre
ele, é apenas um ator de sprite de papel. E estamos definindo que
este ator sprite de papel é especificamente essa
base de fixação e declínio S sendo base. Agora posso acessar qualquer informação que
preciso dentro daqui. O que precisamos
é dessa variável chamada tipo de objeto de escalada. Então, vamos para a
base do jogador e arraste disso e digamos que a colina seja recebendo tipos de objetos de
escalada. Então, agora podemos usar essa variável. Assim como antes.
Lembre-se do que fizemos. Então, se você se lembra aqui, na verdade,
está aqui para o lado. Sobre o movimento na rampa Estados. Criamos esses
estados de movimentos há muito tempo. E você pode fazer
isso, a
enumeração do interruptor enumeração para selecionar qual animação
você quer algum lugar. Então, vamos
fazer isso de novo, indo para a base de jogadores, o ISClient sendo desembrulhado. E dentro daqui podemos arrastar
disso e dizer
switch, ativar esta enumeração. Então, o que deve acontecer
quando é uma corda? Então, o que deve acontecer se
tivermos esse conjunto para corda? Queremos reproduzir essa animação. Então esta é a animação de corda. Certo? E o que é é uma escada, se for uma carta, queremos
reproduzir outra animação. Então, deixe-me copiar colar
isso aqui embaixo. E agora não
temos uma animação para isso. Assim, podemos ir para
a estrutura aqui e você pode adicionar uma nova animação
chamada animação de escada. Nós realmente não temos
um para o jogo. Só estou mostrando como
você pode fazer isso caso você tenha ou queira
aprender a torná-lo dinâmico. Então, criando um
flip book em papel aqui, animação de
letras, eu posso
simplesmente movê-lo para cá. Agora o que você pode fazer,
vou colocar uma animação aleatória só
para ver se funciona. Então eu vou para o
jogador para a Tsarina. Se eu salvar tudo,
na verdade, preciso
compilar para parecer tão salvando aqui
e indo para Serena. E por algum motivo
não está realmente aparecendo. Acho que preciso compilar
na minha base de jogadores. Então, aqui, clicando e compile. Lembre-se muito
importante para compilar. Agora, voltando para Serena
nos padrões da classe, você pode ver que ele aparece. Então, para a animação de letras, vou
colocar esse porco aqui. O porco ocioso. Algo muito aleatório
só para ver se funciona. Você pode fazer isso em Luke também, indo para Luke e apenas colocando alguma animação aleatória de porco ocioso
apenas para ver se isso funciona. Então agora está na carta e podemos tentar clicar em Place se eu
voltar ao jogo, certificando-se de que
tudo está correto. Então, vamos acertar isso ou
conectar isso aqui. Para esta última animação, vou
conectá-la aqui. Então, agora temos os dois. E se estamos apenas ligando, então removendo o cliente, se for falso,
vamos pular. E deixe-me clicar em Ocultar
pinos novamente, assim. Ok, então agora isso deve funcionar. Então, se eu clicar em Play,
agora, estou subindo. Você pode ver que isso está funcionando. E se eu mudar
isso para outra corda? Mas e se isso fosse uma escada? Então eu mudei esse tipo de escalada. Esta é, na verdade, uma escada agora. E se eu escalar agora, você pode ver que a animação está mudando. Então, dependendo se você
tiver uma corda ou não, isso mudará
a animação para qualquer que seja a animação que
você adicionou aqui, dependendo se for uma
corda ou se for uma escada.
61. Canal de colisão personalizado: Então o problema que
estamos enfrentando agora é um aperto de fazenda
aqui na minha corda. Na verdade, deixe-me mudar
essa animação. Isso parece tão estranho. Preciso mudar isso em uma corda novamente. Então, se eu for para as plantas, vá para a escalada
da corda e, na verdade,
troque-a de volta para uma corda aqui. Certo? O problema que estamos enfrentando
agora é se eu estiver subindo aqui e
se eu for para o topo, não
posso realmente subir
para a parte superior aqui. E o motivo é esse ladrilho de
colisão aqui. Lembre-se de que temos colisões. Essas peças de colisões estão impedindo meu personagem
de se mover para cá. E então precisamos de alguma forma dizer a essas colisões para desligar
sempre que estivermos escalando. Mas não queremos
desligá-lo para cada um. Se quisermos, se
o desligarmos para todos, todos esses inimigos
cairão do chão. E todos os jogadores que estão conectados com você, eles cairão do chão
se não houver colisão. Então, queremos
removê-lo especificamente para esse cliente ser jogador. E a
maneira mais inteligente de fazer isso é criar nosso próprio canal de
colisão personalizado, o que é muito, muito fácil. Então, vou ensinar
isso a você agora. Podemos fazer isso indo para
Editar e indo para as configurações do
projeto. E dentro daqui,
podemos ir para colisão, que está aqui sob o motor. E então aqui nos
canais de objeto , são colisões, então podemos clicar em novo canal de objeto,
clicando nele aqui. E então temos que
dar algo aqui. Então, vamos
chamá-la de linha sendo camada. E a resposta padrão, vamos defini-la para se sobrepor. Clique em Aceitar. Então agora temos um canal. Então, o que isso significa? O que isso aparece? E isso realmente aparece. Vamos voltar ao mapa de
mosaico que
criamos na pasta de mapas de mosaico. É aqui que temos
essas colisões. Então, dentro daqui, lembre-se no componente de renderização
para este mapa de mosaico aqui, se você descer para a colisão, você pode ver Alice encontrar uma colisão aqui, Predefinições de
colisão. Vamos clicar nessa
seta para vê-la. Você pode ver que na verdade está
bloqueando todos nós aqui. E acabamos de criar
esse jogador de escalada. Veja como é fácil. Ele só aparece aqui. Portanto, sempre que você criar
um canal personalizado, ele aparecerá aqui. E você pode defini-lo para uma configuração dependendo do
que você está tentando fazer. Então, até agora, todo o nosso
jogador é um peão. E quando o jogador está ligado, estamos sendo bloqueados de
toda a colisão
que está sob telhas. E para o jogador de aperto agora, nós o configuramos para se sobrepor por padrão. Lembre-se de que você
sempre pode mudar isso clicando aqui
e dizendo fantasia. E você sempre pode
mudá-lo para outra coisa. Só porque você disse isso aqui nas Configurações
do projeto,
na colisão, só porque você define
o padrão para se sobrepor, é
claro que você pode
simplesmente clicar em Personalizar e alterá-lo para outra coisa, mas só estará
sobreposto por padrão. Então aqui vou
voltar para bloquear tudo de novo. Por padrão, agora o
jogador de escalada está definido para se sobrepor, o que significa que eu realmente posso
realmente
me deixar remover todas
essas linhas aqui. Então, por padrão, agora posso, se eu sou o cliente sendo jogador, agora
posso passar por todas essas colisões porque elas não me
bloquearão mais. Eles se sobrepõem a mim. Então, temos que dizer o motor agora que sempre que eu estiver subindo, quero que o jogador seja
esse jogador de colina. Eu não quero que meu
jogador ainda seja um lago porque
mesmo que eu tenha feito este canal agora quando
estou subindo meu personagem ainda em cima e ele está bloqueado
por essas colisões. Então, temos que dizer que
queremos mudar nosso canal. E se eu for a uma base de jogadores
agora, você pode vê-lo aqui no
sprite ou na cápsula. Aqui neste brilhante
você pode ver que estou,
então o canal de objetos é peão. E lembre-se aqui e as lagoas do objeto de renderização estão sendo bloqueadas do canal de
colisão. Portanto, temos que alterar
essas configurações. E vamos fazer isso
na base de jogadores onde temos o cliente sendo, só
estamos interessados
em fazer isso sempre que o jogador estiver subindo. Vamos fazer isso antes de
mudar a animação. Então deixe-me mover todas
essas animações para o lado, mais longe aqui. Então, sempre que eu
estou na linha, quero levar o jogador. Então, tomando este Componente de
Cápsula, você pode ver que o componente da cápsula
aqui está definido como fantasia, mas aqui
no canal do objeto, ele está definido para uma lagoa e não
queremos que a cápsula se sobreponha. Então, vamos voltar
aqui para a cápsula, menos arrastar isso
aqui no mundo. E podemos mudar
esse tipo de colisão. Então, se você descer, você pode ver que esse é
o tipo de objeto. E sempre é bom
olhar para os nomes porque então você pode realmente
saber como é chamado. Então, se você simplesmente arrastar
daqui e dizer colisão, porque é isso que estamos
interessados em mudar. Lembro-me que foi
chamado de tipo de objeto. Vamos tentar ver se temos uma função chamada
set object type. E aqui defina ou está aqui
Definir tipo de objeto de colisão. Então, clicando aqui. E se por algum motivo
fez um para mim, deixe-me excluir meu antigo
e deixe-me conectar aqui. Então, sempre que estamos subindo, estou interessado em mudar minha cápsula, que está colidindo. Quero mudá-lo para
uma linha sendo jogador. Este é o personalizado
que fizemos. E sempre que não estou mais
subindo, quero
mudá-lo de volta para cima. Então você pode copiar,
colar isso aqui embaixo, conectado de volta assim. E vamos afastá-lo. Aqui. Você pode mudá-lo de
volta para um poema. Então, estamos apenas
mudando para um jogador de aperto
sempre que estamos subindo, mas estamos mudando de volta para **** quando
não estamos mais escalando. Agora vamos compilar e salvar, e é tão fácil quanto isso. Então, vamos tentar ver
se temos algum bug. Então agora você pode ver,
agora eu posso subir por ele porque sou
um jogador de escalada. Canal de objetos e
minhas colisões. E eu posso subir aqui, e agora posso
andar por aí porque agora estou no meu canal de
objetos de peão agora.
62. Como ajustar a localização de subida: Ok, então o pequeno problema que
temos agora, sempre que andamos e pulamos, às vezes ele cai na corda. Às vezes você pode vê-lo cair
no lado da corda. Então, não especificamente
no roupão aqui. Então, temos que ajustar
o local de salto sempre que você estiver pulando
em cima dessa corda aqui. Então deixe-me voltar aqui e
voltar para a base de jogadores. E a melhor maneira de fazer isso é continuamente
atualizada em algum lugar. E o que estou
pensando quando faço isso é o que os eventos tenho que atualizar
continuamente
que posso usar? Eu realmente não quero
fazer um sinal de evento. Eu realmente não quero fazer isso. Então, temos alguns temporizadores, mas eles param sempre que eu configuro meu cliente sendo
assim sempre que eu sou escalado sendo o que está
atualizando continuamente, isso está parando
quando estou subindo. Então a coisa está aqui quando
nos movemos para cima e para baixo, isso ainda está atualizando. Então, ainda estou me movendo para cima e para baixo. Então, vamos realmente fazer isso aqui. Depois de adicionarmos a entrada de movimento. Só queremos ajustar a localização quando
estamos sendo colina. Então deixe-me porque aqui,
se eu não fizer isso, ele ajustará a
localização sempre que
eu estiver apenas interagindo com
a corda e puder subir. Então, vamos arrastar isso aqui e fazer um booleano ou
realmente um ramo. Sempre que estou subindo, quero ajustar a localização
do meu cliente. Então, o que estamos tentando
fazer é que queremos definir a localização
do jogador
para onde quer que isso,
esse ator aqui é
esse ator de corda. Então, onde quer que esse ator esteja e quando estamos
pulando em cima dele, eu quero definir os
jogadores x localização. Lembre-se que a localização x é
o que está acontecendo de errado agora. Porque ou o jogador está muito longe à esquerda ou muito longe
à direita da corda. Portanto, é o local x que
precisamos ajustar aqui. Eu quero definir meus
jogadores x localização como
o mesmo que este
ator x localização. Então, se eu voltar para
a base de jogadores, então se eu estiver reivindicando aqui, quero ajustar minha localização. Vamos pegar esse objeto
ou prender o objeto. Deixe-me clicar com o botão direito do mouse e dizer
Converter em um get validado. Porque lembre-se se você
não está mais se sobrepondo, se eu voltar à minha lógica você
possa ver por que
estou fazendo isso. Voltando para a base de escalada. Lembre-se, quando você
não está mais subindo, você está definindo essa
variável como nada, o que significa que você não tem nada
dentro dessa variável. Então é por isso que estou configurando
isso apenas para não ter nenhum bug. Então, eu só estou vendo se
essa variável é válida, se ela contém algo
e se ela contiver, se houver. Então deixe-me levar aqui a localização dos atores,
mas a localização dos atores. E então também estou recebendo
a localização do ator dos jogadores. Então, obtenha a localização do ator. E este, o
alvo é eu. Lembre-se de que estamos
na base de jogadores, então esta é a localização do
jogador. Esta é a localização do objeto. Vou quebrar para ambos
para que eu possa usar o X, Y e Z porque só estou
interessado no x aqui. Vou quebrar o
vetor aqui também. E só vou
executar esse código aqui, ajustando a localização do jogador sempre que não estivermos na corda. Mas se nos
ajustamos à corda, então não quero mais
executar esse código. Então, se o x da corda não for igual ao x dos jogadores,
então, se eles são
diferentes, isso é verdade. Então, vou conectar
isso como válido aqui. Se isso for verdade, vou
ajustar a localização. Então, vou realmente
fazer um novo evento aqui. Lembre-se, isso está sendo executado
no cliente e quando
ajustamos um local, isso é uma atualização visual. E temos que fazer isso
por meio de uma notificação de representante. Então, vamos fazer um novo
evento aqui em baixo. Vamos chamá-lo de evento personalizado. Na verdade, vamos transformá-lo em
uma Interface de Blueprint primeiro. Então, deixe-me ir para a interface
Blueprint dos jogadores. E vamos criar uma nova
função chamada Ajustar, linha sendo local,
composto Salvar. Não sei se precisamos de
alguma entrada agora. Não consigo pensar nisso agora. Vamos fazer isso e
sempre podemos adicionar variáveis,
se quisermos. Então, deixe-me chamá-lo dizendo
ajustar, subir a localização. E esta é uma função de
Interface de Blueprint. Vamos executá-lo pelo servidor. Então, servidor personalizado e
ajuste a linha sendo. Se eu puder escrever um local
de escalada e vamos alterá-lo para executar
resposta e confiável. E a partir daqui,
é claro, podemos executar este evento de servidor, apenas
subindo locais. Então agora o que queremos
fazer é aqui em cima, se isso for verdade, se o, se a localização da corda e a localização x não for a
mesma que a localização x do jogador. Queremos ajustar a localização do
jogador. Então ajuste a escalada. Queremos executar esse
evento essencialmente. Então, aqui queremos ajustar
a localização do jogador. Então, em última análise, o que
estamos tentando fazer é que estamos tentando criar um
vetor. Então, vamos criá-lo. Agora. Estamos tentando fazer um vetor
chamado local de escalada. E vamos transformá-lo em um vetor
porque é um local. E este, em última análise,
queremos configurá-lo para uma notificação de representante. E dentro desse local de
fixação, a única coisa que precisamos
fazer é definir a localização do ator. Isso é o que estamos tentando fazer. O alvo é auto, então estamos tentando definir a localização
do jogador, esse novo local, esse local ajustado.
Vamos conectá-lo aqui. Essa é a coisa que
queremos fazer em última análise. Então, definindo a localização do jogador para este local ajustado, que está nesse local de cordas, que cordas x localização. Então, se o x da
corda não for o mesmo, atua como o jogador, queremos ajustar a localização. Então, como ajustamos
a localização? Primeiro, novamente, quero pegar
esse objeto de agrupamento novamente, você pode fazer um get
validado apenas para garantir que ele seja válido. Então, novamente, vamos pegar,
na verdade, deixe-me copiar isso novamente. Na verdade, vamos
escrever a mesma coisa. Então, estamos obtendo a localização das cordas e estamos recebendo a localização do
jogador. A única coisa em que estamos
interessados é mudar essa localização x porque a localização y dessa forma não
estamos realmente interessados, interessados em ajustar isso. Também não estamos interessados
em ajustar o z. Só
estamos interessados em
ajustar o x aqui. Se eu voltar ao meu plano, a única coisa em que estamos interessados
em ajustar isso. Então deixe-me pegar meu vetor de
localização de escalada aqui, conectado e arraste
disso e diga make vector. Agora, o que podemos fazer
aqui é que queremos definir a localização do jogador. Lembre-se de que esta é
a localização ou configuração do jogador. Então, queremos definir a
localização do jogador para as cordas x. então faça y e z. Só
queremos que eles
permaneçam os mesmos. Não queremos ter
o y e z da corda. Nós só queremos o y e z
e o z do jogador, seja lá o que for atualmente. Portanto, estamos interessados apenas
em ajustar o x. Todas essas
informações
entrarão neste vetor agora. E sempre que for definir
a notificação do representante da turnê, ele executará
essa função aqui. Então agora vamos definir a localização
da atriz. Ok, então vamos
clicar em Jogar agora, quando saltamos na corda, Ok, agora isso é
realmente perfeito. Vamos voltar para pular aqui. Perfeito também. Ok, então quando
jogarmos o jogo agora, vou jogar como Luke
no servidor e
Serena na linha. Então, apenas torná-los um
pouco maiores assim. Então, no servidor e agora
eu posso pular na corda. Estou ajustando minha
localização bem. Z no entanto eu pulei, está ajustando minha localização. ID de Alice no
cliente para garantir que
tudo esteja funcionando,
então eu estou pulando, ele está ajustando minha
localização corretamente. Você pode ver no servidor, há algum bug aqui. Sou cliente,
mas de alguma forma minha animação não
está sendo reproduzida. Acho que ele
se consertará mais tarde
nas lições em que estamos
posando e atualizando. Você pode ver agora que ele funciona. Então, vamos pausar e atualizar essa animação da Columbia porque, obviamente, não
queremos reproduzi-la enquanto estamos pulando. Mas, inicialmente,
vamos definir essa animação de salto,
reproduzi-la e detê-la. Acho que vai por toda parte. A coisa como ela dá
errado está aqui na base de jogadores. É como se ele jogasse. Mesmo que tenhamos colocado um booleano aqui em
movimento para a direita e para a esquerda. Na verdade, está reproduzindo a
animação aqui antes ou depois. Aqui no, na
rampa é escalada depois que definimos o flip book
para subir ou escada, ele ainda está passando por
aqui e jogando. Então, mais tarde,
vamos parar e iniciar a animação,
dependendo se o jogador
estiver pulando ou não. Então eu acho que ele vai se consertar. Mais tarde, veremos. Mas, por enquanto, vamos
deixar que seja assim. Então tudo está
funcionando corretamente agora e o salto está bem, está
tudo bem. Estamos ajustando a localização. Então, vamos compilar,
salvar tudo e passar para a próxima lição.
63. Como remover a escalada para Spamming: Ok, então temos um pequeno bug que precisamos corrigir agora. E se eu for para o
cliente ser e para o roupão e me deixar
ir para as viewports. Na verdade, vou
aumentar isso aqui e colocá-lo aqui para que eu possa
realmente subir do topo. Então agora eu posso jogar como servidor
e estou subindo aqui,
subindo até o topo, que
está funcionando perfeitamente. Mas o problema agora é que
se eu desci, você pode ver que está
funcionando bem também. Mas agora, se eu estiver
aqui em cima e eu clicar, você pode ver que eu posso me
acalmar, tudo bem. Mas se eu clicar,
posso enviar spam. E parece assim. Quero dizer, não é realmente o
maior problema do seu jogo, mas visualmente, acho que podemos
fazer o jogador fazer isso. Eu acho que é um
pouco estúpido, então vamos consertar isso. Como remover este cliente
Bob spamming aqui. Então, vamos voltar aqui. E para fazer isso,
acho que a melhor maneira é adicionar outra caixa de colisão, que então nega que você pressione
o botão Up se você estiver. Então, vamos adicionar uma caixa de
colisão aqui no topo desta corda. Vamos fazer isso
na base de escalada. E aqui no objeto de renderização, vamos adicionar outra caixa de
colisão. Procure colisão
na caixa de colisão e vamos chamar essa caixa de colisão
superior. O que queremos fazer inicialmente como aqui
e a base de jogadores. O que queremos
fazer é fazer um evento dizendo que pode subir. E isso é basicamente
apenas um booleano. Então, vamos fazer um booleano
chamado e subir. Isso é realmente o
que queremos
fazer e vamos
configurá-lo para replicá-lo, obviamente porque
todos os clientes precisam saber sobre isso. E assim pode escalar Bob, isso é o que estamos
tentando definir, e obviamente vamos
configurá-lo através do servidor. Então, vamos fazer
eventos personalizados passando pelo servidor dizendo que
o
conjunto pode subir. E vamos conectá-lo aqui. E agora precisamos de um evento normal
aqui, não de um servidor. Então, deixe-me realmente
lembrar de executar isso no servidor,
clicando em não confiável. Então, queremos um conjunto normal
chamado, podemos escalar Bob e vamos fazer isso dentro da Interface
Blueprint. Acabe a interface
Blueprint base do jogador. Fazer uma nova função aqui
chamada set pode subir. Vamos fazer um booleano.
Faça a mesma coisa. Você pode subir. Certo? Agora podemos voltar para a base de
jogadores e chamar esse
conjunto de eventos pode se alinhar aqui. E agora podemos executar os
eventos do servidor por meio deste. Vamos ver onde
está, pode subir. E vamos conectá-lo. E agora ele vai
passar por isso. Então é isso que estamos
tentando correr e vamos defini-lo como falso quando o
jogador não conseguir escalar Bob. Então, vamos compilar e salvar, e vamos voltar para
a base de escalada. E aqui temos essa caixa de colisão superior
agora. Vou
movê-lo um pouco para cima, então está aqui em cima para que eu possa
vê-lo compilar e salvar. E podemos voltar para a corda e podemos realmente
ajustar o tamanho. Não acho que
deva ser tão grande. Quero dizer, não
importa, mas talvez vamos mudar para
algo como 25. Pense, posso tentar. E vou
colocá-lo aqui. Então, quando o jogador está de
pé aqui
no chão e apertando essa caixa, você não pode pressionar o botão para cima. Ok, então vamos compilar e salvar isso e vamos
voltar para a base de escalada. Então, agora clicando nesta caixa de colisão
superior, vamos descer até a parte inferior e clicar neste no
componente começar a sobreposição. Então, o que deve acontecer quando
você se sobrepõe a essa caixa aqui? O que deve acontecer é que
você não pode clicar
no botão para cima e não
pode subir. Mais uma vez. Deixe-me
copiar todo esse código. Estamos fazendo a mesma coisa. Estamos passando por
este servidor com verificação se é o jogador, e se é o jogador, vamos chamar este chamado, chamamos de conjunto pode subir. Então set pode subir e é a mensagem porque
é uma função Blueprint
Interface. Então, pode subir Bob está definido
como falso porque quando você está apertando esta caixa de colisão, você não pode pressionar o botão para cima. No entanto, agora vamos fazer o segundo é quando
você sair desta caixa. Então, quando você está subterrâneo, por exemplo, você pode subir. Então deixe-me conectar isso juntos. Outro componente é
este aqui também. Você pode subir
sempre que
não estiver mais se sobrepondo a
essa caixa. Então a coisa é, agora
temos esse booleano. E assim, na base de jogadores, vamos ver onde podemos usá-lo. Na base de jogadores
podemos usar aqui quando estamos verificando o
cliente sendo inserido, não
queremos que o jogador
suba sempre que
isso estiver definido como verdadeiro e eles
estão lá em cima no chão. Então, pode subir aqui. Podemos dizer que, em vez de apenas
dizer que não é igual a 0, podemos simplesmente excluir isso e
atualizar para outra coisa. Então, se for inferior a 0, o que
significa que o jogador
quer descer, não
temos
nenhum problema com isso. O jogador pode descer. No entanto, quando o jogador, e agora podemos pegar isso de novo, eu posso realmente simplesmente, gritos, eu posso realmente arrastar disso e dizer se
é maior que 0, que significa que o jogador
é tentando subir. Aqui está o problema que temos. Então, se o jogador
está tentando
subir e eles estão autorizados, então pode subir dinheiro. Lembre-se de que eles não podem subir quando estão
colidindo com isso, aquela caixa de colisão aqui em cima. Então, se for maior que 0, podemos dizer final. E eles podem subir buck. Então queremos ir em
frente e subir. E o que podemos fazer
aqui, podemos simplesmente dizer, o que pode arrastar disso e dizer, ou este ou booleano. E então podemos conectar isso
aqui e nos conectar este ano. Então o que estamos dizendo é se o, se o jogador estiver pressionando para baixo, que significa que o eixo z
será negativo. Somos capazes de subir. Se o eixo z for positivo, que significa que o
jogador está pressionando para
cima e
podemos realmente subir. Então vamos subir. Portanto, é essa condição aqui ou essa condição aqui. Isso é o que ele está
dizendo em última análise. Então agora podemos subir, então está verificando agora, você
pode realmente subir? E isso resolverá nosso
problema com o spam. Então deixe-me compilar e salvar. Posso clicar em Play
e ver o que acontece. Então, quando eu subo agora, tenho um pequeno inseto. Você pode ver que eu não consigo escalar Bob, então eu vou
voltar e ver o que fiz de errado. Então o eixo Z pode
subir está passando por isso. E está definindo esse valor. E deixe-me ir aqui para ver se eu disse isso corretamente. O problema é que agora é,
na verdade, isso precisa ser verdade por padrão porque, por
padrão, você pode subir. Então, temos que compor o seguro. Então lembre-se também, que pode
subir como verdadeiro por padrão. Então podemos realmente
subir aqui. Então você pode ver agora
podemos escalar Bob. E se eu escalar o Bob aqui,
posso andar por aí. Se eu clicar no botão para cima, não
posso gastar mais. Mas se eu clicar
no botão Concluído, posso descer a escada. Então agora está funcionando.
Não podemos enviar spam aqui. Podemos simplesmente descer,
mas podemos caminhar para cima
e para baixo, aqui embaixo. Portanto, isso não é problema.
64. Como pausar a animação de escalada: Então, a última coisa
nesta seção, quero pausar a animação
do cliente sempre que não estiver subindo. Então, quando eu estou subindo aqui
você pode ver que a animação
ainda está sendo reproduzida e eu não
quero fazer isso. Nós também tínhamos um dinheiro
anteriormente onde eu, como cliente, por jogar. E eu só faço isso um
pouco maior aqui. Quando eu escalo, você pode ver meu personagem
está estranho aqui, a animação parece estranha. Então, talvez ele
se conserte quando pausarmos e
reproduzirmos a animação. Então, vamos tentar fazer isso. Vamos voltar para
a base de jogadores. E dentro daqui, eu
quero que você faça isso
no movimento para cima
e para baixo, porque ele vai verificar continuamente que eu estou movendo
para cima ou movendo-se para baixo ou
apenas parado. Então, o que vou fazer agora
está ficando um pouco de bagunça e precisamos
limpar isso no final deste vídeo. Então deixe-me mover isso
para cá. Então eu quero atualizar isso sempre que eu estiver
subindo porque antes de subir e eu realmente não
quero
fazer nada. Então, depois desta, estou subindo. Vamos
desconectar isso. Então, antes de ajustar
o local, vamos reproduzir e parar
a animação. Então, vamos pegar nosso eixo z aqui. O eixo z simplesmente nos
dirá, o jogador
está
pressionando para cima ou para baixo, ou o jogador está parado? Portanto, se isso não for igual a 0, que significa que o
jogador está se movendo, queremos reproduzir a animação. Para reproduzir a animação,
você pode pegar este sprite aqui
e você pode, então, você pode dizer Play, e ele
reproduz esse flip book. Mas lembre-se, você não
pode simplesmente jogar o flip book porque agora
você está na
placa automática do cliente. E esta é uma atualização visual. Mais uma vez, estamos no
multiplayer, então
precisamos executá-lo através de uma notificação de representante. Porque se você fizer isso, apenas um cliente o verá. Então, vamos removê-lo. E agora precisamos torná-lo um novo evento chamado pausa,
escalar flip book. E podemos definir isso
como verdadeiro ou falso. Então, vamos voltar para
a função de interface
para a base do player. Vamos fazer uma nova função. E vamos chamar isso. Pausa, subiu. Suponha que subiu, flip book. Vamos fazer uma variável
aqui no Booleano. Eu só chamo isso de pausa,
escalou, iluminado livro. E vamos compilar e salvar. Ok, então vamos chamá-lo aqui, pausar o flip book cego, e queremos
executá-lo para o servidor, chamá-lo de pausa limed flip book. Agora, este também é,
também tem um booleano chamado flip book cego de
pausa. Certo? Então aqui estou apenas me
certificando de que eu tenho B na frente do meu booleano
apenas para boas práticas. E tudo bem, então agora
temos esse evento, execute-o no servidor, confiável, e queremos
promover isso para uma variável. Promova isso para uma variável
chamada pausa, colina, mas flip book e eu vou
colocar um B na frente dele aqui e remover os
espaços assim. Ok, então este
é um representante notificado. Então, clicando aqui,
clicando em rep notificar, compilar e salvar. E vamos executar o servidor
por aqui. Então, faça uma pausa. Eu tenho muitos agora. Então deixe-me procurar, pausar, colina, mas flip book. Deixe-me passar por aqui. E, em última análise, o que
estamos tentando fazer é tentar fazer uma pausa, escalar, virar livro, verificar se a
pausa está definida como verdadeira ou louca. Então, se a pausa for definida como verdadeira, queremos pegar esse
sprite e dizer Pare. Aqui, o flip book. Quando você segura o mouse sobre ele, ele diz parar a reprodução de livros. Então, queremos parar
a animação. Então, quando a pausa for verdadeira, queremos interromper a animação. Uma das pausas é falsa, o que significa que queremos
reproduzir a animação. Podemos dizer que comece
ou realmente jogue. Então, chama-se play. Então, vamos
reproduzir a animação. E agora vamos voltar
e codificar essa lógica. Então agora temos esse evento pronto. Então, quando estamos subindo e o eixo z quando
estamos pressionando, quando pressionamos para cima e para baixo significa que não é igual a 0, então queremos
movê-lo se isso for verdade. Então, vamos conectá-lo aqui. Se isso for verdade, queremos reproduzir
a animação, o que
significa que podemos chamar
este evento Pausa, escalar, virar livro, pausar,
escalar, virar livro. Este aqui. Então,
podemos definir isso como falso. Então, como configurá-lo como false, o que significa que
não queremos pausar, só
queremos
configurá-lo aqui para pausá-lo. Então, quando isso estiver definido como false, ele vai desembrulhar a notificação
aqui estão a função Honorlock. E quando estiver definido como falso, ele vai reproduzir
a animação. Agora eu não quero reproduzir
a animação constantemente, só quero reproduzi-la sempre que
ela não estiver sendo reproduzida. Então, o que você pode fazer é tirar esse brilho e então você
pode dizer flip book. E agora podemos ver que
temos, vamos ver, temos como reverter está jogando, este está jogando. Queremos verificar se ele já
está jogando. E digamos, vamos dizer loucos. Então, gritos, não este. Não é B, que é este não booleano. Então agora o que estamos dizendo aqui, vamos escrever um
booleano final também. Então agora o que estamos dizendo, se o jogador estiver
pressionando para cima e para baixo, então o eixo z não é igual a 0
e a animação ainda
não está sendo reproduzida. Então vá em frente e reproduza a
animação porque não estamos realmente interessados
em continuar enviando spam. Reproduza esta animação. Já estamos reproduzindo
a animação. Então, quando você ainda não está
reproduzindo a animação, então quando a animação não está sendo reproduzida e os jogadores
realmente pressionando para cima e para baixo, queremos ir em frente e
reproduzir a animação. Então deixe-me seguir isso em frente. Estamos correndo em
problemas com o espaço, então apenas organizando
as coisas um pouco aqui. Ok, então a próxima coisa que
queremos verificar, queremos dizer agora,
é o jogador parado, o significa que o eixo z é igual a 0 porque o jogador
não está pressionando para cima e para baixo. Então, se isso for igual a 0 novamente, e se a animação já
estiver sendo
reproduzida, queremos
interromper a animação. Então, e booleano novamente, conecte-os juntos
e faça um novo ramo. E pegue o falso aqui. Portanto, estamos verificando, o eixo z
é igual
ou não igual a 0, significa que o jogador está se movendo. Se for falso porque o
jogador realmente não está se movendo, ele vai
descer aqui e verificar, o jogador não
está se movendo? Se isso for verdade. Como se também fosse verificar
se a animação já está
sendo reproduzida. Se isso for verdade, vá em frente e pause
a animação de reprodução. Vou
movê-los para baixo novamente. E assim. Agora vamos
reproduzir a animação ou pausar a animação
se ela já estiver sendo reproduzida. Mas estamos parados. Queremos fazer uma pausa porque não queremos reproduzir
a animação enquanto
estamos parados. E como a coisa quando
tudo é falso, queremos apenas
ajustar nossa localização. Então, vamos colocar isso aqui embaixo. E assim, quando estamos nos mudando para cá, se estamos nos movendo, mas a animação já está
sendo reproduzida. Vamos descer aqui. Vai ficar falso,
vai ficar falso. E então estamos apenas
ajustando a localização. Portanto, inicialmente está se
concentrando em reproduzir nossa animação ou
posar nossa animação, e depois
ajustará nossa localização. Certo, então acho que não
precisamos de mais aqui. Então, vamos ver se
tudo está corrigido. Deixe-me clicar em jogar como o
servidor e deixe-me pular aqui. Você pode ver que eu não estou jogando. Se eu mover para cima e
para baixo, ele está jogando. Certo. Parece que tudo
está correto agora. Incrível. Então deixe-me agora ir como clientes e abri-lo aqui. Isso está funcionando também. Agora vamos ver se ainda temos esse balde ou
talvez precisemos corrigi-lo. Então deixe-me movê-lo para cá. Agora ainda temos essa caixa, então eu preciso dar uma
olhada em onde deu errado
corrigir esse bug porque às vezes ele aparece e
às vezes não acontece, então temos algum bug. E eu acho que se nós apenas formos aqui
e movermos a base de jogadores, vamos testá-lo rapidamente aqui. Então, se eu tiver o jogador
parado aqui e eu for para a base de jogadores, e eu os desconecto, mova para a direita e para a esquerda. Talvez algo esteja dando
errado porque
também estamos definindo animações aqui. Então deixe-me clicar em jogar. E se eu jogar como o servidor, na verdade não o servidor, o cliente, enquanto eu
tenho o vínculo de serviço. Ao pular, clique em cima. Você pode ver que a
animação completa obviamente não está atualizando porque eu
desconectei esse evento. Mas ele está jogando corretamente. Parece que não temos, nunca
temos um
problema na escada. Então, há algum decodificação inicialmente está correto
todo o código, há apenas essas atualizações
que acontecem, mesmo que
nós dissemos que só queremos jogar isso quando não
estamos escalando. Então, vou ver o que
posso fazer sobre isso. Então eu acredito que a melhor maneira de
corrigir esse bug é se formos, então ele está reproduzindo essa animação, mas às vezes ela
passa por isso e jogando sexualmente
a função on-ramp. Assim, podemos tentar ir para o, lembre-se
que fizemos esse estado de movimento aqui, esse movimento é salvo, está realmente executando aquela função de
estado de movimentos
desembrulhados. Então, indo para a função de estado de
movimento aqui antes
que ela possa mudar, também precisa verificar se
estamos subindo ou não. Então, vamos levar nosso cliente a ser. Está aglomerando aqui e
vamos fazer um ramo. E agora vai dizer, vamos escrever um booleano louco aqui. Então, se não estivermos escalando, você pode fazer
todos esses movimentos. No entanto, se estivermos escalando,
não faça nada. Então, algo assim aqui. Então, vamos agora salvar e rezar para que tudo esteja correto. Então, vamos tentar pular
agora e está funcionando. Vamos tentar novamente
algumas vezes para
garantir que ele esteja funcionando. Ok, então agora isso
corrija o problema. Agora está funcionando e
se eu sou o servidor, e eles podem se ver, então agora estou pulando
como o servidor, você pode ver que isso funciona também. Portanto, tanto o cliente quanto o
servidor podem se ver. E novamente, só para
ter certeza de que não está incomodando. Então, aqui no jogador, eu só queria verificar minha
colisão na escada. Então, como sprites, não estou
gerando nenhum evento de sobreposição, então isso realmente não importa. Nós, os eventos de sobreposição
vêm principalmente da cápsula. Então, clicando na cápsula, olhando para baixo nas Predefinições de
Colisão aqui. Assim, os poemas estão ignorando uns outros e a linha sendo jogadores estão
se sobrepondo. Então, na verdade, vou
mudar este também. Ignore um ao outro.
Assim, os jogadores nas letras também se
ignorarão. E você sempre pode
mudá-lo se precisarmos, mas é isso que
podemos fazer por enquanto. Ok, então agora tudo
está funcionando e você pode ver a câmera agora. Você pode ver que está escutando. E isso ocorre porque você só
precisa ter cuidado para não colocá-lo dentro
dessa caixa de colisão ou
pode torná-la menor. Vou colocá-lo lá fora porque já estamos
na sobreposição. Agora, vamos clicar em Play. Jogue como o jogador e o cliente para garantir que
o jogo esteja funcionando. Então, temos o cliente aqui
e temos o jogador aqui. Então o jogador responde
agora o servidor, lugar, esse cara aqui, o
lugar do personagem, Tsarina aqui. E estamos nos movendo. E isso está parecendo bom. Agora, como o servidor. Isso também parece bom, e eles não conseguem bloquear um ao outro. Certo. Então, tudo está
parecendo correto e não
posso gastar o botão
para cima aqui. Tanto o jogador quanto o cliente
podem abranger o botão Para cima. Ok, então tudo está
funcionando corretamente. E vamos tentar
jogar agora clientes S2, às vezes você precisa
testá-lo como dois clientes para ver se isso está funcionando
corretamente também. Então, brincando, Serena e Luke, andando por aqui, pulando na carta de que
as coisas estão funcionando. O cliente e o servidor. Então, clicar em spam
aqui em cima não faz spam. Mas isso é bom. Tudo está funcionando e o cliente, a câmera está funcionando. Você pode ver que está ajustando
a localização dele. Assim mesmo. Então, tudo
está funcionando corretamente agora. E, claro, se encontrarmos
alguma caixa no futuro, estaremos consertando isso. Mas, por enquanto,
parece que tudo está funcionando e
não há realmente nenhum bug aqui. Então, a próxima coisa que
podemos fazer é trabalhar na
saúde e nos danos. E isso será realmente
interessante porque agora podemos ser danificados
pelos inimigos. Podemos aplicar danos a eles
e será muito divertido. Então, vamos passar para
a próxima seção.
65. EXTRA: como limpar seu código: Então eu queria adicionar
esse vídeo extra porque acho que é muito importante que
limpemos o projeto e acho que está ficando
um pouco confuso. Então, vamos seguir em frente e
limpar parte do projeto. A primeira coisa que podemos fazer é entrar aqui
na base de jogadores. E aqui terminamos nosso sistema
climático e assim por diante. Então, temos alguns eventos
aqui que podemos limpar. Então,
a partir do movimento para cima e para baixo, você pode clicar duas vezes nesses pinos aqui para fazer um nó de redirecionamento. E eu costumo fazer
isso para que
pareça mais magra para que possamos clicar aqui
e fazer isso aqui. E em vez de
ter dois desses, porque isso está vindo
inicialmente, vindo da mesma coisa. Posso arrastar
deste aqui e me conectar aqui e posso
excluir este aqui. E por alguns motivos,
bombeando , não me deixa excluí-lo. Deixe-me fechá-lo e abri-lo novamente e excluí-lo.
Então, agora ele funciona. Ok, então vou
mover isso para baixo. Então tente o seu melhor para limpar
tudo isso aqui em cima. E eu posso mover
isso até aqui. Se você quiser, você pode
fazer dois deles. Você pode fazer um aqui e outro aqui e conectá-lo
assim, se você quiser,
se você acha que isso parece mais limpo, eu acho que isso está
parecendo bom agora, talvez mova-o para cima. Não, acho que isso é bom. Por aqui. Podemos mover esse ranho assim. Podemos mover isso
para cima assim aqui. E essa parte do código. Isso é como se estivesse parecendo bom. Podemos movê-lo um pouco para cima, talvez mais para trás,
algo assim. E acho que isso
está bem até agora. Então, aqui em baixo, temos o
cálculo do eixo z. E vou movê-lo
por baixo disso porque
eles pertencem juntos. Só vou
movê-lo para cá. Então temos o código pode escalar. Eu vou mover
tudo isso
aqui para que eles possam subir é
quase limpo ou é, na verdade, é totalmente limpo para que
possamos arrastar isso para mais perto. Esta é a lata escalada, mas acho que eles podem subir. Isso deve vir como o
número dois porque esse é um dos
códigos iniciais também. Vou mover isso para baixo. E eu vou
levar essa parte
do código listado abaixo aqui, apenas certifique-se de que eles não
colidam aqui para o lado. Então nós também podemos
subir aqui. Este é realmente o servidor, então realmente precisa mover
isso um pouco para baixo, mas pode mover isso, pode subir acima dele. Então ele começa aqui e
desce para o servidor. E então temos a
escalada e temos a pausa do flip book e posando que o flip book
vem daqui de cima. Talvez eu possa colocar isso aqui em cima, ou posso abrir espaço e colocá-los ao lado
um do outro aqui. Gosto de juntar
as coisas para que elas não estejam muito espalhadas, mas acho que elas são
muito próximas umas das outras. Então eu vou, vou puxar isso um pouco para baixo. Isto é, este aqui em cima
é o código principal. E temos alguns
eventos aqui em baixo. Então isso está ajustando
a localização, o que está acontecendo aqui. Então, ajustando a localização, posso novamente colocá-lo do lado aqui apenas para
deixá-lo mais limpo. E posso selecionar tudo isso. Vou movê-lo um
pouco para baixo novamente, assim. Ok, então temos
o set está subindo e podemos subir
esta subida sendo, eu vou apenas, na verdade,
podemos deixá-lo estar aqui, apenas aproximando-o para que não
seja muito longe. A mesma coisa com este. E o que podemos fazer com esse código e apenas movê-lo um
pouco mais perto assim. Podemos levar tudo isso aqui. E então podemos clicar em, ver. Vamos chamá-lo de subir. Suba sendo talvez você não tenha
chamado de algo
melhor ou talvez mecânico de
escalada ou toda
uma linha de texto. Você também pode fazer,
lembre-se de que podemos fazer comentários para inserir também, então você não precisa
apenas fazer isso aqui, você não pode tão bem. Faça isso aqui, dê
cores se quiser,
se você fizer suas próprias regras. Às vezes, o que
faço pelos meus jogos, se vier do servidor, faço um comentário e então
esse comentário será lido. Então, todos os comentários vermelhos
dentro do meu jogo, eu sei que este é o servidor, então algo pode fazer. E se for especificamente
para o cliente, talvez goste de rosa
em vez de vermelho. Então você pode tentar
fazer suas próprias regras e fazer tudo
organizado aqui. Vou fazer isso se encaixar aqui. Então agora recusamos
ser mecânicos, temos o salto. Este, vou
limpar um pouco mais. Então, aproximando isso. Então, inicialmente,
muito importante, tentei deixar seu
código muito mais enxuta. Agora clicando neste, escondendo a conexão porque
eu realmente não preciso dela. E vou mover tudo
isso, mas mais longe. Portanto, há mais espaço aqui. Certo? Algo assim. E agora o que podemos fazer é apenas movê-los um sob o outro. Ok, então agora temos isso, e na verdade este
está um pouco confuso. Então, vamos pegar esse pino
aqui e movê-lo desta forma. Em vez de ter tantos, posso clicar duas vezes aqui, e posso
conectá-lo aqui e conectar este aqui. Para que eu possa excluir este. E agora temos aqueles
conectados a todos os três. Então, um pouco mais limpo que antes deste, podemos arrastar um pouco
para trás para que possamos ver a linha. Acho que tudo o
resto está bem. Então podemos mover isso, a frente assim,
e podemos mover
isso e podemos mover um pouco mais longe
para que eles não estejam colidindo. Ok, então eu acho que isso
está procurando notas. E lembre-se quando você
limpar tudo aqui, lembre-se também de verificar
suas funções para garantir que tudo
esteja bem. Acho que basicamente
tudo está bem aqui. Podemos movê-lo um
pouco mais longe para que eles não estejam
colidindo assim. Você pode
clicar duas vezes neste e torná-lo assim aqui. Certo? Agora, eu posso afastar isso, e aqui você pode fazer o mesmo. Então eu posso mover isso um
pouco mais longe. E este mais longe. Você pode até
clicar duas vezes neste, movê-lo para baixo assim e clicar em q. dois. Eles se unem,
algo assim. Algo assim. Quero dizer, vai ser
muito mais limpo. Talvez você possa simplesmente afastar tudo isso, exceto por
este assim, que parecerá um
pouco mais limpo, mas isso está parecendo bom até agora. Certo? Então, quando você
limpar tudo, então tente verificar tudo, tente comentar tudo
muito importante quando você voltar
três meses depois, você não tem idéia do
que tudo isso é se você não tiver
cometido nada disso. Então lembre-se de limpar o código, tentar comentar tudo
e certifique-se entender o que aconteceu
aqui, o que você codificou. A segunda coisa é que você pode
limpar suas variáveis. Então, o que você pode fazer aqui, por exemplo, a
subida aqui. O que você pode fazer
aqui à direita, você pode adicionar uma categoria a eles. Então eu posso chamar essa
categoria de escalada. E você pode ver que ele o adiciona
automaticamente a uma categoria. E isso pode fazer isso para todos
os outros seres clientes. Então este pode escalar Bob. Posso selecionar a categoria
agora e selecionar a linha sendo. E ele os
reunirá automaticamente aqui em cima. Eles vão subir sendo a
localização também está subindo. A pausa subiu e
o cheque sobe também. Então, ambos, vou
mudá-los para escalada. Agora temos pode subir também
está em declínio. E então temos
o objeto de escalada também
é a escalada. E temos
outra coisa aqui. Temos o estado do movimento. Este, por exemplo, você pode chamar movimentos de um jogador. E temos a localização da camada. Então, este talvez
o chame de propriedades do jogador, algo assim ou local. Então, a localização atual do jogador. Também podemos alterar as propriedades
do jogador. Atualize a câmera do jogador. Então, este podemos chamar
a câmera de layout. Então, tudo sobre
as câmeras plug aqui e as informações da planta. Talvez possamos alterá-lo para
jogar propriedades também. Desova de camadas e localização para
reproduzir uma propriedade também. E a câmera do jogador, podemos mudar para a câmera
e temos o eixo z. Este é o movimento.
Então, talvez você possa simplesmente mudá-lo para
o movimento do jogador. Então, agora você pode ver
que organizou todos eles e, quando
os minimiza, você vê como isso é limpo. Quando você tem um jogo
grande, muito, muito importante limpar
todo o seu código. Então você sabe o que está acontecendo. Ok, então vamos salvar tentou fazer isso com todas as
suas plantas. E a próxima coisa que
podemos fazer é aqui. O que podemos fazer
aqui no outliner, você pode agrupar coisas. Por exemplo,
temos os porcos aqui. Posso selecionar todos eles e
posso criar uma nova pasta. E posso chamá-los de inimigos. E eu tento encontrar
todos os meus caracóis. Então, desse caracol
para este caracol, posso segurar Shift e
clicar neste, arrastá-los para a pasta
inimigos. E agora temos todos os
inimigos que você pode ver aqui. Certo? E agora temos o,
temos a corda aqui. Talvez você possa adicioná-lo a uma
pasta chamada ambientes. E acho que não escrevi
corretamente, assim. E nós temos este. Este também é o ambiente, então vou
movê-lo para dentro daqui. Temos o jogador começar
com a malha de navegação. Talvez você possa chamá-lo de volumes. E este é o volume da malha de
navegação. Pós-processamento,
posso realmente criar uma nova pasta chamada
pós-processo. Ok, então podemos mover
essa reformulação também dentro dos volumes
e o jogador começar, podemos simplesmente deixar estar aqui. Não precisamos
colocá-lo dentro de uma pasta. Então agora você pode ver que
este também está organizado. Se você quiser ir
para o próximo nível, você pode até renomear as coisas. Então, por exemplo, ele
pode renomeá-los. Mas acho que está tudo bem por enquanto. Ok, então a última
coisa que você pode fazer também, você pode ir para as Interfaces
Blueprint. Por exemplo, aqui.
Lembre-se disso. Você também pode dar uma categoria. Então, por exemplo, pode subir, você pode novamente dar uma categoria
assim como as variáveis, e todas elas
estarão em uma categoria. É muito importante fazer
isso para seus próprios projetos. Limpe todo o seu código. E eu só queria
fazer esse vídeo extra só para
limpá-lo um pouco. E agora acho que é
muito mais limpo trabalhar com ele. E sim, foi
isso para este vídeo. Então, vejo você no próximo.
66. Como preparar os flipbooks: Olá e seja
bem-vindo a esta seção. Agora é hora de trabalhar na saúde e
no dano, tanto para o jogador
quanto para o inimigo. Então, temos muito o que fazer
aqui nesta seção. Então, vamos começar. Primeiro de tudo, aqui nos materiais
do curso que eu
enviei para você algumas, algumas surpresas ou texturas que
precisamos preparar primeiro. Então, indo para o personagem, eu tenho esse
chamado The Death. Então, vamos até os ativos
aqui e vamos para os personagens. Eu só vou fazer o upload
aqui porque isso é o mesmo para
serina e para olhar, nós acabamos de fazer o upload aqui. Clique com o botão direito sobre ele,
aplique textura de papel 2D. Sabemos que todas essas
coisas agora vão parecer, temos esses efeitos de passo. Então, vou procurar texturas, e eu quero que você importe
esse efeito passo também. A mesma coisa com a Csarina aqui. Posso ver que já o fiz
upload para o Luke, e vamos tentar
enviá-lo agora para Serena. Então este efeito de um passo
foi carregado para a Tsarina aqui e aplique papel
às configurações. E antes de
transformá-los em sprites, quero que você vá,
vamos voltar aqui. Vá para os inimigos. E dentro daqui, vamos pegar os
golpes de porco e pegar a morte. E vamos para os inimigos
agora e as texturas. E vamos carregar o
porco, ele e a morte. E também os
acertos do caracol e a dívida do caracol. Então, esses dois
também carregam esses dois. E para todos aqueles
que eu fiz upload, novamente, aplique papel
às configurações. E eu quero que você faça flip
books com tudo isso. Então, a morte HIT
ou ambos. E a morte do mar aqui. E também Luke esfaqueando, este chamado
guia de aparência anserinus passo. Então, vou pular
isso no vídeo. Já sabemos o que fazer aqui. Então eu quero que você crie sprites a partir desses
e flip books. Então, o maior 180 por 180 para os personagens
e para os inimigos. Quando você extrai os sprites, a grade é 90 por 90. Ok, então aqui
terminei os flip books. Então, para a morte do porco, eu disse que os quadros por segundo, dois por enquanto, não tenho certeza
sobre os quatro aqui. Talvez precise
ser seis ou mais lento, então teremos
que testar isso no jogo mais tarde. E para a cabeça de porco, lembre-se de definir um a menos
quadros por segundo para um. Acredito que isso
afetará o código mais tarde, então defina-o para um. E para as
cabeças de caracol ou morte de caracol, eu disse que um
a oito quadros por segundo para esse caracol atingiu. Eu o defini para um
quadro por segundo. Também é muito importante
fazer isso aqui. E para a profundidade aqui e os personagens definiram
para oito quadros segundos. Então esta é a animação da morte. E para Luke, o esfaqueamento é
através de quadros por segundo. E a mesma coisa aqui para Serena é esfaquear são
dois quadros por segundo. Ok, então agora temos todos
esses flip books prontos. Vamos, na verdade, antes de
encerrarmos este vídeo, também aplicá-los
à estrutura. Então, vamos ver
nossos projetos nas estruturas e abrir
as informações
do jogador. Agora, você pode ver aqui
que não temos uma animação atacante, então vamos clicar em Adicionar variável. E digamos que animação de ataque. Vou arrastar
este aqui. Talvez eu queira arrastá-lo
logo após o salto aqui, realmente não
importa, mas sou só eu escrevendo aqui, flip book
papel. É um flip book em papel aqui. Agora economizando. E vamos fazer a mesma coisa aqui
pelas informações dos animais. Então o animal agora
temos o ídolo e o movimento, mas também temos
a animação Hit. Temos a animação da morte. Na verdade, tenho isso
para o jogador também. Então, deixe-me primeiro mudar isso
em um flip book em papel. Novamente aqui e aqui. Assim. Ok, então agora eu tenho escondido
imortal realmente acrescentar isso para o jogador
também enquanto estamos edições. Então, vamos adicionar a animação da
morte. Deixe-me movê-lo aqui
acima do efeito sonoro. E lembre-se que é
um flip book em papel. Certo, acredito
que temos tudo aqui, então vamos salvar tudo. Vamos para o jogador. Vá para Luke e clique em
abrir o editor de blueprint completo, clique em padrões de classe. E aqui nos padrões da classe, vamos encontrar as informações do jogador aqui. E você pode ver
que eles não podem realmente adicioná-los aqui mesmo que
nós os adicionamos, lembre-se, você tem que ir para
a base de jogadores, clicar em compilar, clicar em Salvar, e você tem que clicar em
compilar dentro de aqui. Como você adicionou a
estrutura dentro daqui, as variáveis dentro daqui, ela tem que compilar aqui. A mesma coisa com o inimigo. Antes que possamos adicionar aqueles
em caracol e porco, você tem que ir até o
inimigo e Compilar e Salvar. E agora podemos vê-los. Para dar uma olhada, agora você pode clicar nos padrões da
classe e ver
que
temos a animação de ataque. E vamos apenas procurar por uma etapa. Então Luke, passo, mais profundidade. Podemos pegar este
chamado morte do FB. Esta escada de animação. Nós realmente não tínhamos nada. Isso foi apenas para testes. E se você quiser de novo,
eu disse que você pode, você pode ir para aquele
site chamado Maples. Estou aqui e crio um personagem e tento usar
seu personagem ou apenas fazer. Você vê aqui, você tem algumas
animações que você pode fazer. E você pode simplesmente selecionar a animação da escada e você
pode ver como ela se parece. Ou você pode simplesmente colocar a animação de corda
aqui, se quiser. Vamos realmente fazer isso. Então, não parece estranho. Acho que se chama escalada. Ok, então vamos para Serena agora, indo para jogadores,
Tsarina, não aqui. Camada Tsarina e abrindo o plano completo de que
é um ataque NDA. Novamente, procure por passo, selecione Salinas, Serena
e pela carta. Vamos procurar
aqueles que subiram. Aqui. Adicione para a animação da morte, basta procurar a morte
e selecionar esta. Então, agora temos
tudo selecionado. Agora vamos fazer a mesma
coisa pelos inimigos. Então, vamos para o inimigo. Vamos escolher primeiro editor de blueprint completo
aberto
nos padrões da classe. Vamos encontrar este
chamado informações de animais. E aqui nos sucessos, podemos procurar por
acertos de porco e a morte. Podemos procurar por morte de porco. Faça a mesma coisa
agora pelo caracol. Abra o editor de blueprint completo
e dentro das informações de animais, vamos adicionar os hits de caracol e vamos adicionar a dívida do Caracol. Então agora temos tudo
adicionado aqui na estrutura. Então, com essas coisas adicionadas agora, vamos analisar e fazer os
jogadores atacando a entrada.
67. Como adicionar a entrada de ataque: Agora vamos em frente e
adicione as entradas de ataque. Então, primeiro, vamos
para Configurações do projeto. E dentro da entrada aqui, vamos agora temos
apenas o salto até agora. Então, clicando neste plus e adicionando um novo chamado ataque. E eu vou
clicar aqui e clicar no meu controle esquerdo
no teclado. Agora vou usar
o controle de elevação como meu botão de ataque, mas isso é apenas um curso, então você pode escolher seu próprio
botão se quiser. Acredito em Maple Story, era este
ou o botão Alt. Então, vou escolher o
botão de controle menos no meu teclado. Feche-o, entrando em plantas e dentro do
jogador e uma base de N jogadores. Então, vamos fazer esse movimento de
ataque ou lógica aqui
na base de jogadores. Então, o que fiz
aqui, acabei de selecionar todos os meus nós e clique em C
para criar um comentário. E acabei de chamar
esse movimento e
mudei o
tamanho da fonte para setenta. Eu só tenho todos os meus movimentos. A coisa que codificamos
até agora dentro daqui. E para que possamos economizar algum espaço. E agora podemos
atacar aqui em baixo. Então, aqui embaixo, o que
eu quero que você faça é eu quero clicar com o botão direito do mouse
e dizer ataque, seja lá o que você chamou dentro
das configurações do seu projeto. Selecione-o aqui. E agora, para o ataque, queremos fazê-lo passar
pelo servidor porque novamente, isso é multiplayer e queremos
garantir que o cliente não
esteja trapaceando. E então o que vou
fazer é realmente criar um aqui e as Interfaces de Blueprint
e a base de jogadores. Aqui. Vamos clicar em Adicionar e vamos criar uma nova
função chamada ataque. E vamos fazer
uma nova variável aqui. Aqui chamado B está atacando. Então, estamos apenas verificando se
o jogador está atacando. Agora você pode ver aqui às
vezes que está incomodando, está atacando. Quando eu escrevo aqui e clico em Enter, vou
excluí-lo. Não sei se faz isso
às vezes sem motivo. Então, vou
excluir isso aqui, excluí-lo e criar
uma nova função. Agora posso ver se clico
aqui e clique em Adicionar. repente, funciona. Não sei por que ele
faz isso. Às vezes. Vamos renomeá-lo para atacar novamente. Por aqui. Agora podemos fazer, podemos chamá-lo agora
dizendo ataque e selecionamos aqui o ataque do
evento. Certo? Então, queremos que isso
passe pelo servidor. Então, vamos fazer
novos eventos personalizados chamados ataque ao servidor. E este também vai
ter que o booleano chamado B está atacando. Vamos ligar, na verdade, vamos
executá-lo pelo servidor primeiro ano e vamos chamar
esse evento do servidor aqui. Assim. Vamos conectá-lo. E agora aqui em cima podemos chamar esse ataque da base de jogadores
finais. Certo? E agora vamos definir
isso para ser verdade. Então, sempre que você clicar
no botão de ataque, você definirá o booleano
atacante como verdadeiro. Ele vai passar
pelo servidor e pelo servidor. Você pode clicar com o botão direito do mouse aqui,
promover isso para uma variável, chamá-la de B está atacando. E agora o servidor
definirá essa variável como verdadeira. E, obviamente,
quero replicá-lo para os clientes para que eles
possam ver minha mudança. Certo? Então o que
queremos fazer aqui é que não queremos que o
jogador esteja atacando. Se você já está atacando, isso não faria
sentido células que você
poderá atacar spam o tempo todo. Então, o que queremos fazer é pegar esse booleano e fazer um ramo. E vamos realmente fazer um
entalhe aqui, então NÃO booleano. Agora, o que estamos dizendo é que se
o jogador não está atacando, então se isso for falso, o jogador não está atacando. Podemos ir em frente e atacar. Mas se já estamos atacando, não
queremos atacar
spam em cima disso. Então, só ataque quando
você ainda não está atacando. Ok, então ele vai
passar
pelo servidor e definirá
a variável. Agora, o que queremos fazer é
jogar e atacar animações. E lembre-se, há muito, muito tempo fizemos esse estado de movimento aqui onde
mudamos os movimentos. Então, vamos adicionar um novo
movimento aqui. Adicionamos um à estrutura. Então, vamos realmente ir para
a enumeração agora, porque aqui na enumeração, se eu puxar para cima novamente, só
temos isso agora. Mas na estrutura de reprodução aqui, temos essa animação atacante que adicionamos no vídeo anterior. Então, agora vamos adicionar essa opção
aqui em nossa enumeração, que também
criamos há muito tempo. Aqui nas enums, no movimento Estados. Vamos clicar em adicionar enumeração
e adicionar o ataque. Agora, para essa tag, você pode arrastá-la para cima,
se quiser. Vou
deixar que ele esteja aqui em baixo. E agora podemos ver que o
oxigênio está disponível. Se você não conseguir vê-lo, lembre-se de clicar nesta
seta e ela aparecerá. Agora vamos copiar colar
este flip book set e deixe-me
conectá-lo ao ataque. E agora, novamente, lembre-se que você não pode simplesmente
entrar aqui e selecionar etapa uma das animações facadas porque, como queremos torná-lo dinâmico
para todos os personagens, eles têm seu
costume animações. Temos que encontrá-lo aqui a partir
da estrutura que adicionamos. Então, clicando na
estrutura, você pode ver, você não pode ver nenhum pino. E isso acontece quando você clica
em Ocultar pinos não conectados. Mas você pode clicar
na marca de seleção aqui. Então, a animação de ataque. E agora eu posso clicar nesta seta e você
pode ver que ela aparece. Agora posso arrastar essa animação de
ataque e entrar
nessa aqui. Ok, então isso é corrigido. Agora vamos compilar e salvar. O que podemos fazer agora é
voltar ao Event Graph. E aqui queremos jogar ou atacar animação
porque lembre-se, você pode apenas dizer definir
movimentos Estados. Isso é o que temos
usado até agora. E aqui você tem que prestar
atenção porque agora você pode ver que temos algo
chamado estado de movimentos definidos, e a base inimiga também. Isto é o que o inimigo, isso é para o jogador. Portanto, preste atenção ao
que você está selecionando. Este, queremos usar
esse do jogador. Quer reproduzir a animação de
ataque sempre que o jogador atacar. E agora, antes de
fazermos qualquer coisa aqui em cima, lembre-se do movimento para a direita. Não queremos mover para a direita e esquerda um que o jogador
está atacando. Então eu vou pegar meu
a está atacando booleano aqui e dizer loucos. Então o que vou dizer aqui é se o jogador não
estiver subindo. Então, vamos fazer um AND booleano e o jogador não está atacando. Portanto, se o jogador não estiver subindo e os
jogadores não atacarem, você pode ir em frente e se
mover para a direita e para a esquerda. Mas se o jogador estiver atacando, não
queremos nos
mover para a direita e para a esquerda. Deixe-me arrastar isso para
o lado, então eu realmente tenho um pouco mais de espaço para
trabalhar assim aqui. Certo. Agora vamos
compilar e salvar. E agora você pode ver que há um pequeno erro e eu não
vou falar
sobre isso agora. Vou explicar
daqui a pouco. Então, vamos clicar em Jogar agora. Lembre-se antes de
clicarmos em jogar, lembre-se de configurá-lo no
play como servidores de escuta. Então, aqui, as peças ouviram. Vamos clicar em Play. Vou atacar. Você pode ver que está funcionando. Tudo bem, está tudo bem. Está atacando. Não definimos
o ataque como falso, então ele vai atacar para sempre. Então é isso que o
servidor pode agora no cliente? Mais uma vez, vou
clicar no controle. Mas você pode ver
sexualmente não funcionar. Não consigo ver minha animação. Lembre-se, isso aconteceu, isso é uma mudança visual e tem que
passar por uma notificação de representante. Agora você está executando esse
evento pelo servidor. Portanto, o cliente não tem
ideia do que você está fazendo porque no momento em que
você vai ao servidor, o cliente não pode ver todas essas informações, a menos
que sejam replicadas para ela. Essas informações
que o cliente pode ver porque você está
realmente replicando. Mas este está apenas
passando por uma função normal. E não está indo para o cliente e você está
executando
o servidor para que o cliente
não possa ver tudo isso que você está escrevendo
aqui, a menos que seja replicado. Então, o que vou fazer é
mudar este em vez de replicado para uma notificação de representante porque isso é uma mudança visual. Então, vamos mudá-lo para o
Eric notificar. Assim, podemos notificar o
cliente sobre este. Aqui e o está atacando. O que vou dizer é pegar esse booleano de
novo, dizem marcas. Então, se você está atacando, quero reproduzir esse
estado de movimento atacando animação. Vamos voltar e
garantir que tudo esteja correto. Então isso é sim,
então vamos tentar agora. Clique em Jogar. Agora, como o servidor novamente,
clique em controle. Isso deve funcionar. Agora, se você for para o
cliente, eu clico no controle. Agora, você pode ver
que também está atacando. O servidor também pode ver
que o cliente está atacando. Então lembre-se, isso é muito
importante no multiplayer. Você precisa passar por uma
notificação de representante se for uma mudança visual. E se você jogá-lo
diretamente no servidor, cliente, o cliente não
poderá ver todas as coisas você está fazendo aqui, a menos que você esteja realmente replicando
para os clientes.
68. Para cada loop: Então o problema é que agora
queremos aplicar dano a todos os
inimigos que atingimos. E para fazer isso, vamos usar algo
chamado de para cada loop. Então, o que ainda não
usamos loops, e eu não acredito que já
expliquei isso a você ainda. Então, este é apenas um pequeno vídeo
explicando quais loops são. Então, vamos começar aqui. Aqui em baixo dissemos antes de atacarmos e ele
vai para o servidor. Agora, toda a
lógica estará dentro
do servidor porque queremos
garantir que o cliente não
esteja trapaceando. Então, vamos fazer isso dentro daqui. Mas vamos fazer, é que vamos usar uma função chamada obter atores sobrepostos. Então vamos bater algo e vamos
conseguir todos os atores sobrepostos, então todos os atores
que estamos batendo. E para este, vamos fazer
um para cada loop. Este é o que
vamos usar. E vamos conectar esse. Então, quais atores
vão se sobrepor? Vamos dar uma olhada nos inimigos porque esses são
os que queremos atacar. Então pegue todos os atores
sobrepostos, pegue todos os inimigos
sobrepostos. E para cada um desses inimigos, então agora ele vai
levar cada inimigo. Então, digamos que no meu nível aqui, eu tinha cinco inimigos empilhando
uns sobre os outros assim. E eu cliquei no meu botão de
ataque e na verdade, apertei todos
esses cinco. Então, o que vai fazer agora? A sobreposição é cinco. Então você pode ver todos
os cinco inimigos. E agora para cada inimigo, o que você quer fazer? E o que queremos fazer, aplicou dano a
todos os inimigos. Isso é o que o corpo do loop é. Agora, você vai fazer uma ação para cada
inimigo que você atingiu. O que queremos fazer
é apenas aplicar danos. Agora, eu quero ter
certeza de que esse código não
seja executado sempre que eu
não acertar em nada. Se você não acertar nenhum inimigo, não
queremos
executar esse código. Então, vamos dizer é, vamos pegar
este e dizer comprimento. Então, verificando o comprimento. E eu vou pegar
isso e dizer não igual. Assim, podemos fazer isso escrevendo não igual ou dizendo um ponto de exclamação
e igual. Isso é incrível em matemática,
o que significa não igual. Então, se isso, o comprimento dos atores sobrepostos não
é igual a 0, significa que eu realmente
acertei em alguma coisa. Então você pode seguir em frente
e executar esse código. No entanto, se o comprimento for 0, então não faça nada
porque realmente não queremos executar esse código
se não atingirmos nada. Isso é
muito simples para cada loop, vai dar uma olhada em
todos os atores sobrepostos. Então, talvez tenhamos atingido três inimigos. E para cada um
desses três inimigos, queremos aplicar dano. E faremos
isso na próxima lição.
69. Jogador aplicando danos: Agora vamos entrar no plano
do jogador novamente e ver como o
jogador pode aplicar dano. Então, aqui dentro da base de jogadores, isso que fizemos
no último vídeo. Então, fazendo o ataque aqui. E, a propósito, se você não
viu isso antes, você pode ver com o que estamos
trabalhando até agora. As variáveis, elas são como circulares aqui no pino aqui. Mas este é um quadrado e tem muitos pequenos
quadrados dentro dele. E isso é chamado de array. E você pode vê-lo aqui quando
você cria uma nova variável. Por exemplo, acabei de
chamar isso aleatório. Você pode ver quando você
clica no Tipo aqui, o contêiner variável aqui, podemos realmente alterar o tipo de um único para um array. Então, qual é a diferença
entre este e este? Então, até agora o que temos
feito, vamos, por
exemplo, dizer que
os jogadores se conectaram. Por exemplo, vamos levar
os jogadores conectados e vamos mudá-lo aqui
para a base de jogadores bp. Então, vamos dizer que o que
queríamos fazer com este é armazená-los todos
em uma variável. Então você não pode simplesmente pegar
isso aqui e defini-lo aqui. Como quando um jogador se conecta, você define essa variável. Essa variável só pode
conter uma informação. Por exemplo, essa variável é se o jogador estiver
atacando ou não. E deixe-me ver se temos
outras variáveis aqui. Essa variável contém o estado de
movimento agora. Então, quando você defini-lo para cair, ele definirá esse estado de
movimento para cair. Portanto, você não pode ter várias informações ao
mesmo tempo dentro dessas variáveis. No entanto, você pode
fazer isso ao mudá-lo para uma matriz. Então, para armazenar
jogadores conectados, todos os jogadores se conectaram
em uma variável. Portanto, não apenas um jogador, você realmente precisa
transformá-lo em uma matriz. E se você clicar em
Alterar tipo de variável, poderá ver que eles se tornam
como este quadrado. E o que é isso,
agora é a matriz que você pode, você pode imaginá-la
como uma caixa grande. E eu te disse antes, você pode imaginar essa variável
normal como uma caixa com algumas
informações nela. Este aqui, você pode imaginá-lo como uma caixa grande com pequenas
caixas de informações nele. Então agora posso armazenar todos os jogadores aqui,
todas as variáveis. E o que posso fazer aqui é que
posso pegar isso e dizer “get”. E eu posso realmente pegar um dos jogadores e fazer
algo com ele. Portanto, uma matriz é apenas uma caixa
grande contendo, por exemplo, todos
os jogadores conectados. Talvez eu contenha todos os pons, enquanto que se for
apenas uma circular, então apenas uma única variável
normal, ela pode
conter apenas uma informação. Mas se você tiver uma matriz, ela pode conter
várias informações. Por exemplo, todos
os jogadores conectados
ao servidor. Então, aqui, os atores sobrepostos, contém todos os atores
que foram sobrepostos. E digamos que eu me
apegei a eles. E esses são cinco inimigos. Agora, com esses cinco inimigos, agora
posso
quebrá-los aqui no meu loop. Agora eu tenho
todos os inimigos aqui. E agora o que queremos fazer
com nosso loop é que queremos
aplicar dano a cada
inimigo que eu acertei. Portanto, se o comprimento não for 0, o que significa que
atingimos alguém, queremos cuidar
e dizer Aplicar dano. É assim que você
causa danos a alguma coisa. Use esta função
aqui, aplique danos. Agora temos que especificar ao que
você deseja aplicar danos. Então, quem é o ator danificado? Esse é o inimigo, e
o inimigo está aqui. Lembre-se, você pegou todos os atores sobrepostos que são a base inimiga, então os inimigos. E para cada inimigo, você quer aplicar
dano a eles. Ok, então qual é o
dano que você quer aplicar? E, na verdade, temos que especificar o dano que
o personagem faz. Então, vamos voltar às
informações do jogador, nossa estrutura aqui, informações
do jogador, e vamos adicionar uma nova variável
chamada dano base. Talvez mais tarde possamos
atualizar esse dano. Então este é
chamado de dano base, e podemos movê-lo por cima aqui. Isso realmente não
importa, mas eu só gosto de estruturar
as coisas dessa forma. Então, para o dano base, vamos voltar para a
base do jogador Compilar e Salvar. Nos padrões da classe
Na verdade, você não
pode simplesmente
no padrão da classe, você pode simplesmente clicar nele aqui. Se o encontrarmos aqui nas propriedades do
jogador informações do jogador, esta é a estrutura
e clicando aqui. Então, por padrão, eu só quero que o dano base seja
talvez algo como cinco. Então, fazer cinco danos toda
vez que você acerta alguma coisa. Então agora que temos
esse conjunto e vamos pegar este aqui e
vamos quebrá-lo. E agora podemos usar
esse dano base e conectá-lo a isso aqui. Agora, mais tarde, se você quiser
fazer upgrades para um jogo, e provavelmente
faremos isso para o nosso jogo. E não realmente
no curso base, provavelmente
vou adicionar seções
de bônus para desenvolver cada vez mais neste jogo até que ele
se torne um enorme. Mas talvez eu já tenha
gravado isso. Então dê uma olhada na
minha seção de bônus no momento em que você estiver
assistindo a este vídeo. Então, aqui estamos aplicando
o dano base. No entanto, mais tarde,
se quisermos adicionar atualizações e, mais tarde,
queremos aumentar esse dano. Você pode simplesmente criar
uma nova variável. Chame-o danificado, multiplicador e Compile e Save como Padrão. Agora vamos mudá-lo para
realmente para um float, e não vamos
alterá-lo para um ArrayList, basta mantê-lo em
uma única variável. Vamos arrastá-lo para fora. E, por padrão, lembre-se
de defini-lo para um. Portanto, o
multiplicador danificado é apenas um, o que equivale ao dano base. Agora, vamos dizer, isso
é multiplicado
pelo multiplicador? E então nós o conectamos aqui. Agora, mais tarde, se
fizermos atualizações, podemos aumentar esse
multiplicador, por exemplo, dois. Então, vai dizer que o dano
base vezes dois, o que então aplica mais dano. Mas, por enquanto,
vamos fazer um aqui. Vou mover isso
um pouco de peso para ficar mais organizado. Agora, o instigador do evento, se você segurar o mouse sobre
ele, ele diz o controlador que foi responsável por
causar esse dano. E este é o jogador. Então, estamos dentro de um jogador e para obter o controle do jogador, você pode simplesmente dizer Get Controller. E get controller é
uma função que diz retorna controlador
para este ator. Então, o controle do jogador,
você pode obtê-lo dessa maneira. Para o tipo de dano aqui, você pode simplesmente
alterá-lo para o tipo de dano. Tudo isso, como o dano mais próximo que realmente não
precisamos agora. Tudo bem, então é
assim que você aplica danos. E se salvarmos tudo aqui, agora na base inimiga, o que vai acontecer é
se eu for para o inimigo agora, aqui na base inimiga, nós realmente não fizemos
muito dentro daqui. Mas aqui você pode dizer evento, qualquer dano, e esse é um
evento que ainda não usamos. Qualquer dano só
receberá qualquer dano que aconteceu até aquele ponto e podemos
fazer algo com ele, por
exemplo, podemos subtrair da
saúde desse inimigo. Agora, antes de terminarmos
isso, deixe-me realmente fazer algo com
as colisões também porque isso é se eu
for para a janela de exibição aqui, realmente me deixe ir para
um dos inimigos. Assim como o caracol. Abra o editor de blueprint. Eu acho que essa caixa de sucesso é muito grande e quando o jogador
pular sobre o inimigo, o jogador será atingido quando
você entrar nessa sobreposição. Eu só quero que eles sejam atingidos sempre que você estiver muito
perto daquele caracol. Então eu acho que
este é muito grande. Então, o que podemos fazer
aqui é apenas adicionar outra colisão
responsável por danificar o jogador. E vamos para Adicionar aqui e
vamos procurar por colisão. Na verdade, não é uma lesão esférica. Vamos escolher esse. Acho que isso é
melhor neste caso. E vamos mudar o nome
para este para colisão. E eu quero que você
faça isso na verdade, vamos adicioná-lo não aqui, eu estou no caracol,
esse é o meu erro. Vamos voltar para a
base de jogadores e adicioná-la aqui. Então colisão, esfera de colisão e chame-a de colisão porque
queremos isso em todos os inimigos, não apenas no caracol. Agora vamos voltar para o caracol e agora você pode torná-lo
menor para caber nesse caracol. Caracol, podemos fazer
esse raio de esfera menor. Você também pode arrastá-lo para baixo. E talvez vamos fazer 20. Então eu posso ver que isso é 20. E se você também pode
vê-lo da vista correta. Lembre-se de que falamos sobre as visões ortográficas
na introdução, a visão certa. E você pode mudar isso
do wireframe para o modo oblíquo
e você pode ver o caracol. Assim, ele também pode
ajustá-lo aqui nessa visão, às vezes é muito melhor. Mas 20 acho que é
uma boa caixa de sucesso. Vamos voltar
à perspectiva. Agora, o que queremos
fazer é apenas tomar as colisões para todos esses. Então, vamos compilar e salvar. Vamos voltar para a base inimiga. Então, aqui na cápsula, quero descer e
clicar nesta predefinição de colisão para verificar se todas
as colisões com as quais estamos
trabalhando estão corretas. Então eu acho que este está bom. Nós realmente não temos que
fazer nada aqui. Então, clicando na colisão agora e clicando nesta predefinição de
colisão. Então este, assim como antes, lembre-se em uma lição anterior, tivemos esse problema com
os caracóis escutando, como se estivessem andando
perto da rampa. E isso foi, na verdade,
devido ao mundo estático aqui se sobrepor e eu realmente não
quero que eles se esgotem. Vou primeiro, você pode caracterizar o
passo em cima dele. Não, você não pode. E vamos fazer o costume aqui. E então vamos
ignorar a estática mundial. Portanto, o padrão não está indo ou os caracóis não
vão se incomodar dentro dele. Clicando no sprite,
certificando-se de que ele não
está gerando
efeitos de sobreposição. E acredito que isso seja feito aqui. Então, vamos voltar para
a base de jogadores. Agora, para a base de jogadores,
vamos adicionar uma colisão onde você pode
detectá-la, o ataque. Então, vamos fazer uma nova
colisão aqui, e vou anexá-la
ao sprite para que você possa ver
por que estou anexando. Então, primeiro, vou apenas
adicionar um aqui. Colisão, digamos que
a caixa de colisão. E vou para a vista
certa, o modo lead. Então agora eu posso ver onde estou adicionando, na verdade, não
na base de jogadores. Vamos, vamos fazê-los
no espaço pleural porque todos
os jogadores são iguais. Portanto, não faria sentido
fazer isso em Luke e depois Serena. Então, vamos fazer o tamanho
dentro daqui. A razão pela qual fizemos
o tamanho dentro
do caracol é porque todos
os inimigos são diferentes. Mas para os jogadores, eles são todos iguais. Então, vamos fazer o tamanho
aqui na base de jogadores. E o que eu quero fazer aqui, vamos fazer o x primeiro. E acho que algo como 20. E para o y, não
consigo vê-lo aqui. Talvez como 20 ou 25, realmente não
importa. Vamos apenas fazer 20. E para o Z aqui, quanto
para cima e para baixo? Acho que 30 é um bom número. Então, vamos tentar 30. E vamos movê-lo um pouco
mais perto do personagem. E se os inimigos estiverem
dentro dessa colisão? Você é capaz de causar danos. Agora, se você realmente,
antes de fazer isso, vamos para a colisão e verificar se
tudo está correto. Certo. Então, tudo está correto
, exceto por uma coisa. Então aqui, novamente, pode jogar ou pisar em cima
disso. Não, você não pode. Ele gerará eventos de sobreposição. E agora deixe-me
definir isso como personalizado porque
preciso adicionar algo aqui. Agora você pode ver antes
e a base inimiga. Agora, se você clicar nessa
colisão que fizemos, você pode ver que o
tipo de objeto é dinâmico mundial. Agora, o problema é que se
você tem essa
dinâmica mundial que se sobreponha
agora para esta caixa de colisão, como se o caracol estivesse perto você e depois se
sobrepõe a essa caixa, este caracol causará danos a seu personagem e isso realmente
não faz sentido. Por que meu, meu, eu quero que o inimigo entre em mim aqui
nesta cápsula antes
que ela possa causar danos. Na verdade, não quando se
sobrepõe ao meu alcance de ataque, isso não faria nenhum sentido. Então aqui você pode ver
o fim de uma base. Este é um tipo de objeto
de dinâmica mundial. Então, na verdade,
vou ao jogador aqui para esta colisão
atacante, e vou defini-lo para
ignorar a dinâmica mundial. Então, não vai
colidir comigo aqui. Só quero que ele danifique sempre que estiver
bloqueando minha cápsula. E você pode ver que minha cápsula tem a dinâmica mundial de dois blocos, então eu vou ser
atingido por esse inimigo. Agora clicando aqui, vamos
mudar o nome dele. Vamos chamá-lo de colisão de tags. Vamos compilar e salvar e
deixe-me clicar em Play e eu
posso realmente mostrar algo legal para que possamos
aprender com isso também. Agora podemos ver se você
quer ver alguma coisa. Então, se você quiser, se você quiser ver a colisão porque
está depurando, você pode clicar nessa
colisão e você pode remover esse
chamado Jogo Oculto. Jogo oculto, remova
isso, clique em Jogar. E agora você pode ver
essa caixa de colisão aqui na frente de
você e do jogo deles. E você pode ver quando
eu viro este lado, as colisões
realmente atrás de mim. Então precisamos da colisão
para me seguir de cada lado. E é por isso que é importante. Se você quiser isso,
inclua-o aqui no sprite. Então, na verdade, está
ligado ao sprite. Então, é uma criança. E você pode clicar em Jogar e ele vai
girar com esse brilho. Então, agora ele pode ver que está
realmente seguindo corretamente. É muito legal
aprender com isso. Vou deixar isso
não ficar escondido nos jogos para que possamos realmente ver o que está acontecendo. Com isso. Acredito que não tenho mais. Então deixe-me verificar esta
cápsula aqui para o jogador só para ter certeza
se essa coisa está correta. Então agora você pode ver que a cápsula está definida para ignorar é o
osso que é o inimigo. Na verdade, vou
definir a sobreposição porque queremos ser
danificados pelo braço. Portanto, não faz sentido
ignorar o osso. Isso está correto agora
e para os sprites, essa parte não
gerará nenhum evento de sobreposição
assim. Então, vamos dizer onde tudo, acredito que tudo está correto. Então, agora na base de jogadores, estamos aplicando dano a cada inimigo
que estamos atingindo. O problema agora, que resolveremos na
próxima lição é que se eu atacar, ele vai atacar para sempre. Então, vamos passar na próxima
lição e consertar isso.
70. Como interromper a animação de ataques: Então, de volta aqui neste código, até agora definimos que o ataque
é verdadeiro. E se ele está atacando é verdade aqui na função de
desembrulho, ele definirá esse movimento de
ataque. Agora queremos fazer algo
quando o ataque for falso. E o que queremos que você faça é que
gostaríamos de copiar e colar isso. Agora você pode fazer isso,
basta configurá-lo para ocioso para que não estejamos mais
atacando. E temos que, em algum
momento, definir isso como falso porque até agora acabamos de
definir isso para ser verdade aqui em cima. E isso agora é verdade, mas não
especificamos em nenhum lugar em nosso código quando ele será falso. Então, vamos realmente fazer isso. Então aqui vamos dizer antes de
fazermos qualquer coisa com os inimigos. Então vamos dizer que sim, se eu aqui, se eu me sobrepor, se meu comprimento for 0, se eu não acertar nenhum inimigo, só
quero parar de atacar porque não bati em ninguém. Então eu vou pegar isso
e colocar isso em falso. No entanto, se você fizer isso, ele fará isso ao
mesmo tempo em que você está atacando. Então você pode ver que eu
vou clicar em ataque e, na verdade,
ao mesmo tempo que estou atacando, isso vai parar minha animação. Então, em vez de fazer isso instantaneamente e
deixe-me jogar novamente, na verdade, não
preciso bater em ninguém. Então, clicando aqui, você pode
ver que eu clico em Fila, mas nada está acontecendo porque eu vou instantaneamente de
definir um verdadeiro para falso. Você tem que esperar um pouco
antes de defini-lo como false porque você precisa esperar
que a animação atacante seja reproduzida. E você pode fazer isso
de uma maneira muito inteligente. Você pode pegar o sprite
aqui e dizer flip book. Agora eu posso obter o comprimento
deste flip book e ele diz obter o comprimento
do flip book em segundos. Você pode obter quanto tempo esse
flip book está jogando. Você pode realmente atrasar. Lembre-se de que usamos esse nó de atraso. Então, vamos conectar
o atraso a isso. Então atrasou o código por quanto tempo essa animação vai
levar, passando por isso. E depois que estiver concluído, vamos falar e
defini-lo como falso. Então agora, se eu clicar em
jogar e você for para esse personagem e
me deixar não se alguém aqui. Então, se eu bater agora, você
pode ver que está funcionando. Então isso está correto.
Agora eu posso bater e isso pára minha animação
depois de tocada sexualmente. Assim, você pode tornar essa animação novamente lenta e mais rápida
acessando os ativos dois personagens
para Luke, por exemplo. Se você aumentar essa animação
de
esfaqueamento, é claro que ela vai parar essa animação muito mais rápido. Então, agora ele é controlado
pelos quadros por segundo. Então agora que temos o
ataque feito, lembre-se aqui, quando você terminar de
atacar os inimigos, porque agora se eu jogar
e eu acertar inimigos, você pode ver que está jogando
para sempre porque eu não especifiquei quando eu vou parar
se eu realmente acertar inimigos, porque este é justamente quando
você não atinge nenhum inimigo. Quando eu bater em inimigos, novamente, farei o mesmo. Então, vou arrastar isso aqui quando esse
loop for concluído. Então, quando você tiver aplicado
dano a todos os inimigos, vou parar
meu ataque aqui. E isso acontecerá
muito, muito rápido. Então, parecerá
que você não bateu em nada. Porque, como o código do blueprint está sendo executado tão rapidamente, é insano. Então, agora, se não ouvimos nada ou se você
completar seu ataque, você vai parar de atacar. Então, vamos ver aqui, se eu bater em alguém, você pode ver que agora está parando a animação depois
que eu acertar os inimigos. Ou mesmo que eu não ouça
ninguém, isso vai parar.
71. causando dano indevido: Tudo bem, agora que
codificamos muita animação tecnológica e agora
estamos aplicando danos. Vamos realmente ir para o
inimigo aqui, a base inimiga. Aqui queremos chamar este,
esse evento chamou qualquer dano. E queremos aplicar
dano ao inimigo. Então o que queremos fazer é aqui, queremos primeiro
ir para a estrutura e adicionar saúde para
o inimigo. Acredito que ainda não fizemos isso. Então, vamos para plantas e estruturas e informações sobre animais. E aqui vamos adicionar
uma nova variável, chamar essa saúde. E para este, vamos clicar em float. E para a saúde,
vou arrastar este para o topo. Ok, então vamos salvar isso e vamos voltar para a base inimiga. Agora, compile e salve. Agora, para essa estrutura, você pode arrastá-la para fora
e quebrá-la. E agora você pode ver que temos essa variável de saúde
e, por padrão, a saúde do caracol, eu não sei, podemos colocá-la em 25 ou 15. Vamos fazer isso até 15. Na verdade, o
dano do nosso jogador é cinco agora, então três acertos
matarão o caracol. Então, vamos para os padrões da
classe e aqui e as informações do animal. Então, para este caracol especificamente, ele tem 15 de saúde. E talvez para o porco. Se descermos para o
porco, porco aqui, este porco, vamos colocar a saúde dos
porcos talvez 230. Portanto, é o dobro da força
do inimigo ou do caracol. E também para este, estou apenas mudando
a colisão um pouco. Para este, como
fizemos com o caracol. Talvez apenas diminua como 25. Podemos fazer isso mais tarde. Como podemos verificar
e ver se isso é muito grande e muito pequeno. Então agora vamos voltar
para a base inimiga. Agora a saúde é 30 se
for um porco ou é
15 se for um caracol. Mas agora ele vai
fazer isso dinamicamente. Portanto, o dano que aplicamos aqui
antes e a base
do jogador, o dano ao dano base que
aplicamos é igual ao
danificado que sai daqui, e o jogador faz
cinco em dano. Então o que podemos ver,
o que podemos dizer é essa saúde que é 15
para o caracol agora, subtrair isso, como subtrair
o dano, que é cinco. Então agora a saúde é dez, porque 15 menos cinco é dez. Agora, esta é a saúde atualizada. Esta é a saúde de dez
que resta do caracol. E agora vou te
ensinar uma coisa nova, uma nova coisa legal que muitos
não
sabem para começar, muitos realmente cometem um erro mesmo que haja
avançados para projetos, é como você define, como você define variáveis dentro da estrutura dinamicamente. Porque agora
você tem todas essas variáveis
e isso é legal. Você os definiu aqui
em sua estrutura. Mas como você realmente
muda o valor? Então, agora, deixe-me removê-los. Então agora a saúde
agora é 15. Como você muda para dez dinamicamente aqui
através da jogabilidade? Faça isso arrastando
dessa estrutura. E então você escreve conjuntos. E aqui na parte inferior você diz definir membros em
informações de animais na estrutura. Então agora ele tem que gostar do
quê, qual membro você quer definir? E à direita, se
você clicar aqui, novamente, você pode ver todos os pinos e
eu quero definir a saúde, é
isso que estou
interessado em definir. Então eu quero atualizar essa
saúde nessa estrutura para
esta nova saúde que é dez agora depois de
aplicar o dano. Então, vou conectá-lo aqui. E agora você está, você precisa definir essa variável
novamente porque você pode
ver que isso é como
um quadrado girado, o que significa que isso é apenas
uma variável temporária. Você tem que configurá-lo novamente, e não é como
o pino circular. Então isso significa que preciso pegar minhas informações de animais e definir
essas informações de animais novamente. Agora, todas essas outras
informações aqui, a animação ociosa
se move, bateu e morte. Ele vai
defini-lo como o mesmo. A única coisa que vai
mudar é a saúde. E como isso está sendo executado
pelo servidor, eu realmente quero replicar
isso para garantir que meu cliente também possa ver essa edição porque esse qualquer dano
que você possa ver aqui. Ele diz apenas autoridade, este evento só é
acionado no servidor. Portanto, lembre-se de
replicar essas informações de volta
para o cliente também. E isso é, na verdade,
tudo o que quiser. Não precisamos fazer mais aqui para estruturá-lo
um pouco mais. Talvez eu possa
arrastá-los um pouco e
colocá-lo aqui na verdade. Então tente ser o mais
estruturado possível. Clique neste pino, talvez o
estruture assim, e vou
aproximar tudo, assim. Clique em q. Ok, então agora temos isso, e se você quiser ver se isso está funcionando
ou não, na verdade, precisamos testá-lo também
para ver se está funcionando. Agora posso imprimir aqui. Uma cadeia de impressão. Posso imprimir
a quantidade de saúde. Assim, você também pode fazer isso daqui, para arrastar isso
e imprimi-lo. Você também pode ver se sua
estrutura está realmente atualizada. Para que possamos quebrar isso de novo. E agora podemos imprimir essa nova saúde que você
definiu aqui neste. Então, vamos compilar e salvar. Então, agora, sempre que for atingido, ele lhe dirá o
dano ou o mais saudável. Por exemplo,
vou para este caracol, vou clicar nos quadris. E você pode ver aqui em cima
, diz dez de saúde restantes. E se eu não sei se
este é o mesmo caracol, agora tem cinco saúde sobrando. Agora, se eu bater em outro inimigo, ele tem dez ajuda. Então está correto agora, tem dez de saúde
se eu
ainda não ouvi e se eu bater
novamente, ele tem cinco. Se eu bater novamente, ele tem 0. Então, agora ele está realmente
funcionando corretamente. O problema é agora,
se eu acertar, você diz, você verá que diz
menos cinco, menos dez. Então continua, continua
indo no menos. E temos que consertar isso. Então o que você tem que fazer aqui é quando você está minusando
aqui subtraindo, você precisa usar algo
chamado grampo. Grampo. E vamos selecionar
este chamado float, porque estamos
trabalhando com carros alegóricos. Então, vamos
fixar o valor que ele nunca possa ir abaixo de 0. Então, o que é, qual é o valor? O valor é este
que queremos apertar. Certo? Qual é o mínimo? Não queremos ir abaixo de 0. Portanto, o mínimo é 0. E o máximo é
apenas a quantidade que esse inimigo tem na saúde. Vou arrastar isso e defini-lo para isso como o máximo. Então, o que quer que dissemos
desde o início, então vamos
definir essa saúde aqui. Então, em vez de ir
aqui diretamente para aqui, ele vai
passar por um cliente, certifique-se de que não esteja abaixo de 0. E então vamos aplicar
ou editar essa saúde aqui. Ok, então algo assim. E vamos compilar comigo, clique duas vezes neste
pino para torná-lo um pouco mais organizado,
algo assim. Ok, Compile e Save, e agora vamos clicar em
jogar e testá-lo. Então agora, se eu bater em alguém, então se eu acertar isso e
realmente acertar este aqui, 10500, pode ver agora
ele não pode ir abaixo de 0. Sei que sempre podemos fazer esse caracol morrer
toda vez que eu bater 0. Então deixe-me testá-lo com esses
porcos para que possamos ver 25. E agora você pode ver que ele imprime muitos números e isso é porque eu estou realmente
atingindo vários inimigos. Isso está funcionando agora. Isso tem 2015, este
outro tem 20. Então você pode ver que estou atingindo
todos os inimigos e está funcionando quando estou me sobrepondo
a vários inimigos. Mais uma vez pode ir abaixo de 0. Então, isso está funcionando
perfeitamente agora. Apenas para verificar se a
base do jogador também precisa de fixação. Nós realmente não precisamos
apertar nada aqui. A única coisa, a única coisa que precisamos para aumentar a saúde dos negócios, e provavelmente temos
que fazer isso também para o jogador no inimigo danificar o
jogador, o que mais tarde. Então agora isso está
funcionando. Vou excluir esse código aqui. E este é o,
basicamente, o ****. Então você pode ver que não é
muito complexo. Estamos apenas tomando a saúde, subtraindo o dano dela
e, em seguida, colocando-o
dentro dessa estrutura.
72. Animação Enemy: Agora é hora de fazer a animação do
inimigo. Então, até agora, acabamos de
bater nos inimigos e eles não estão
reproduzindo uma animação. Então, temos que fazer isso agora. Agora, para as animações, temos essa, na verdade,
criamos muito antes porque
criamos a tarefa, você realmente encontra localização
aleatória. E aqui usamos este em
que definimos o
estado do movimento em movimento. Então este aqui
e a base inimiga, podemos realmente
mudá-lo porque
realmente não temos apenas agora o
movimento e o ocioso. Também temos o efeito de sucesso. E vamos apenas
convertê-lo como o jogador, o jogador que temos este, estado de movimentos
não maduros. Vamos realmente mudá-lo para
um estado de movimento também. Acho que isso é mais como
se nos servisse muito
melhor do que um booleano. Então, da maneira como fazemos
isso de novo,
vamos, vamos usar o aqui
e a enumeração. Vamos usar este. Nós realmente não temos que
fazer um novo. Então, dentro daqui,
porque o jogador também
terá uma animação de sucesso, na verdade, não vamos usar isso para o jogador aqui. Nós só vamos
fazer um efeito, mas você
pode simplesmente fazer uma nova enumeração
para o inimigo. Na verdade,
vou usar este porque estamos
usando principalmente a mesma coisa. Vou adicionar esses hits. E, na verdade, também
vou adicionar a morte, mas não vamos
codificar isso agora, mas estou apenas adicionando-a por enquanto. E o que queremos fazer agora, agora vamos voltar
para a base inimiga. Então, na base inimiga, inimiga, vamos agora salvar tudo e vamos adicionar esse estado de
movimento aqui. Então, chame-o de estado de movimento. Vamos mudá-lo para
comer ou enumeração, que é chamado de
estado de movimento E selecionado aqui. E agora vamos arrastá-lo para fora. E isso é o que queremos
definir aqui em vez de estar se movendo. E agora precisamos, em vez de
um booleano, vamos excluí-lo. Precisamos de uma enumeração aqui
chamada estado de movimento. Então, a mesma coisa. E vamos mudar o
nome para o estado de movimento. Vamos conectá-lo aqui. Opa, eu não
bati assim. E agora, novamente, lembre-se que
este é um representante notifica, então precisamos
transformá-lo em uma notificação de representante. E aqui, vamos desconectar isso
segurando Alt e clicando. Agora este é da Interface
Blueprint, então precisamos mudar
o booleano aqui. Podemos clicar
nele e excluí-lo. Então, vamos para a Interface do
Blueprint aqui, e isso é para o inimigo. E aqui definir o estado dos movimentos, vou
excluí-lo aqui e fazer um novo chamado Seleção do estado dos
movimentos de enumeração e chamá-lo de estados de movimento. Agora, novamente, ele vai
acabar por algum motivo. Às vezes, é um pouco chato
que isso incomoda. Às vezes você pode fechar
o motor e as porcas. E, na verdade, às vezes você
pode simplesmente excluir isso aqui. Só vou
excluí-lo. Sim. Agora, clique em Adicionar. Vamos ver se isso funciona agora. Isso funciona agora, não
sei por que ele faz isso. Às vezes,
digamos definir movimento, datas, Compilar e Salvar. Vamos voltar para
a base de jogadores,
na verdade, não a base do jogador, a base inimiga aqui. Então, em vez de um
aqui, o movimento, vamos compilar e salvar para
garantir que tudo esteja correto. Vamos conectá-lo agora. Certo, então defina os
dados de movimentos corretos. Agora estamos passando por isso, Ele está passando pelo servidor, e agora ele vai chamar
essa função onReceive. Então, vamos pegar esse estado em movimento e dizer que o switch tem autoridade. Assim como o que
temos feito até
agora, que tem autoridade. Então, se você estiver, vamos derrubá-los para que
não tenhamos todos esses. A coisa é
que temos apenas o ocioso. Então, vamos tirar esse brilho
aqui e dizer Set flip book. Agora só temos o ídolo e deixe-me copiar colar isso
algumas vezes. Aqui. Só temos três coisas. Temos o ocioso, temos, eles estão correndo, então se movendo. E nós temos o efeito de sucesso. Estaremos tendo
a profundidade mais tarde. Então, para a corrida, vou
usar a corrida à direita. Então, use a corrida à esquerda ou à direita, isso não
importa. Vou usar
a corrida aqui. Para a cabeça. Vou usar este. Então, vamos definir essas animações. Vamos pegar nossas
informações de animais, separá-las aqui. Então, quebre. E vamos levá-lo aqui. Agora, para o ocioso, vou conectá-lo aqui. E para o movimento, vou conectá-lo aqui. E para a animação de sucessos, conectando aqui para a morte, vamos esperar com isso também. Mais tarde, clique nele, oculte os pinos não conectados,
arraste-o para trás e compile e salve. E agora temos
tudo, correto. Agora, certifique-se de se
você esqueceu de fazer isso, certifique-se de entrar em cada
inimigo e certifique-se de que,
nos padrões de classe, você definiu todas essas
animações aqui, contrário não funcionará. Certo? Agora vamos
voltar para a base. E aqui, agora em vez
de estar se movendo, na verdade, vamos abrir o seu, nós realmente temos que
mudar algo aqui. Então, na base inimiga, vá para seu inimigo agora. E dentro daqui. E tarefas aleatórias definidas. Lembre-se de definir
esse estado de movimento para se mover e não se mover. Mas agora, na
verdade, não é mais um booleano. É o estado do movimento. Então, vou manter o controle e clicar aqui para remover isso. E este vamos mudar
para r1, certo? Lembre-se de ouvir a base inimiga. É o certo
que estamos usando para o movimento
na árvore de comportamento nesta tarefa que
vamos mudar para cá. Lembre-se que na árvore de
comportamento também tinha essa em que definimos o
movimento booleano como falso. Então aqui, em vez de ser falso, você pode configurá-lo para
ocioso e você pode ver que ele já está corrigido sozinho. Então, vamos voltar para
a árvore de comportamento. Agora vou
renomear isso em vez de definir movimento booleano. Deixe-me apenas renomeá-lo, voltar às minhas tarefas e renomear isso para definir o estado de
movimentos, porque não é mais
um booleano. É bom manter-se
organizado assim. Agora, tudo está correto. Agora vamos voltar
para a base inimiga. Então agora mudamos tudo
em um estado de movimento. Aqui eu quero jogar
a animação Hit
assim que receber
dano como inimigo. Então, vou arrastar esse
pouco assim. Vou dizer que estabeleça estados de
movimento. Vou chamar isso
do inimigo. Lembre-se que não é
do jogador, é do inimigo. Então, selecionando-o aqui conectando-o e
conectando-o aqui. E vou jogar meu efeito de sucesso assim. Certo? Então, clicando em
jogar apenas para testá-lo e clicar no meu jogador. E acredito que não posso
testá-lo agora. Então, se eu clicar no hit, você pode ver que ele está batendo
e é tudo como bug. Mas às vezes ela pára
a animação porque , na verdade, ela ainda está dentro
da sua árvore de comportamento. Mas você pode ver que está funcionando. Então, vamos testá-lo para o jogador, vamos para o cliente. Então, aqui para o cliente, você pode ver a alteração que
o jogador fez no servidor. Então, para o cliente,
ele também funciona. Se eu olhar para o servidor, posso ver essa alteração
feita a partir do Kline. Deixe-me apenas para ter certeza de que não
tenho nenhum bug, mude-o para jogar como clientes. Então, ambos são clientes. Este é um Klein,
este é um cliente. E deixe-me selecionar este
jogador, omega menor. É sempre bom se você tiver
duas telas porque você pode colocar um cliente em uma
tela e o outro aqui. Porque eu realmente não gosto não
posso fazer isso aqui
para este curso. Tenho que ter tudo
em uma tela. Então, clicando neste
aqui, estou pressionando que você pode ver as alterações aplicando isso, ambos os clientes
podem ver a alteração. Certo. Então isso está correto. Tudo está funcionando.
Não temos nenhuma caixa. Deixe-me testá-lo para o porco aqui. E você pode ver que o porco
também está funcionando para o porco. O problema é que eles estão
se movendo agora. Então, vamos fazer isso muito, muito rapidamente e podemos
realmente fazer uma solução rápida. Então aqui, quando você atacar
e quando for atingido, vamos pegar esse componente de
movimento e dizer Definir o modo de movimento, assim como o que
fizemos com nossa escada. Então defina o modo de movimento. Lembre-se da nossa carta
que a definimos para voar. Mas para este,
vamos defini-lo para nenhum porque realmente não
queremos nos mover. Vamos compilar e salvar. E aqui como esse cliente, deixe-me ir até os porcos. É muito mais fácil ver
aqui atingindo esse inimigo. E você pode ver
agora quando eu acertei,
ele não está mais se movendo. Certo. Bom. E a razão pela qual ele está se movendo de
repente é porque ele ainda está executando
nossa árvore de comportamento. E agora ele definiu o modo de
movimento para nenhum, então ele está preso aqui. Então, isso está funcionando
corretamente e temos
que fazer mais código para
torná-lo mais suave. Então, agora que a
animação está funcionando, vamos nos aproximar. A próxima coisa é que queremos parar
a árvore de comportamento sempre que a cabeça do inimigo porque não
queremos andar por aí.
73. Como interromper a árvore de comportamentos: Ok, então para impedir que a árvore de
comportamento jogue. Então, isto é, lembre-se que esta
é a árvore de comportamento. Ele está reproduzindo toda
a animação ainda
sempre que você for atingido. Mas queremos parar
essa animação. A razão pela qual eu
faço isso é depois atingirmos o inimigo em Maple Story, o inimigo vai
persegui-lo o tempo todo. Então, quando eu clico aqui no jogo
e eu acertar este caracol aqui, esse caracol vai me perseguir. Não vai ser
assim e não
vai ser assim. Na verdade, vai procurar o jogador e ele vai me
encontrar e me perseguir. Isso é o que estamos tentando fazer. Antes de fazermos isso,
vamos parar a árvore
de comportamento não queremos
mais correr isso sempre que
os inimigos atingirem. Aqui. Antes de fazermos isso, vamos pegar o sprite e queremos parar
a lógica sempre que ela terminar
esta animação Hit. Então, novamente, assim como antes
com a animação de ataque, para a animação Hit,
podemos pegar o sprite e dizer flip book. Podemos pegar o comprimento. Então, quanto tempo esse flip
book está jogando? Podemos fazer um nó de atraso. Atrase-o com o tempo que
esta animação Hit for. E depois disso,
vou pegar esse componente de movimento
e vou
dizer “stop movement” imediatamente. Então pare com tudo o que
você está fazendo assim. E depois disso, você quer parar
a árvore de comportamento. Então, neste momento, este está apenas parando o movimento
do inimigo, mas você também quer parar completamente a árvore de
comportamento. E isso é feito obtendo
o controlador do inimigo. Então lembre-se, no multiplayer, você pode simplesmente dizer “get controller”, porque agora estamos
dentro do inimigo. Então, estamos recebendo o
controle para esse inimigo. Nós atingimos. E então vamos dizer
que obtém NME ref. Lembre-se que fizemos obter o
inimigo ref um tempo atrás. Se você não se lembra, tente entrar na interface e dê uma olhada
nessa base inimiga. Este é o inimigo
do árbitro que você fez, que você ouve fazer uma
auto-referência também. Então você pode fazer referência
ao inimigo aqui. Com esse controlador
que você tem. Agora você pode arrastar disso e você quer
obter, agora você tem, você tem o controlador, o que você quer especificar, assim como antes
dissemos obter inimigo ref. Bem, este controlador,
você está falando especificamente sobre
esse controlador de IA. Portanto, temos que especificar
que estamos falando especificamente sobre
esse controlador de IA. Então, para fazer isso, agora, lembre-se que eu poderia
apenas dizer elenco também, porque lançar você
está se referindo a um projeto como este. Mas para o
controlador de IA, é, é um grande
modelo azul, assim como a base de
jogadores e assim por diante. Então, vou criar
sua própria interface. Então clique com o botão direito aqui E nos blueprints, lembre-se aqui que você pode criar
uma Interface de Blueprint. Vamos chamar isso. Vamos chamá-lo de controlador de IA. Então, em vez do controlador do jogador, agora
é o controlador de IA. E aqui vamos dizer que pegue controlador ou, na verdade,
vamos chamá-lo de “get ai”. Prólogo ref. Para este, vamos
fazer uma saída, e a saída é inimiga AIC. Isso é o que chamamos
para o controlador de API. Vamos chamá-lo de controlador de IA. E agora temos essa variável. Agora lembre-se de entrar no inimigo aqui e
para o controlador de IA. E lembre-se de ir para as Configurações de
classe e Adicionar essa interface de
blueprint do controlador de IA. Aqui, Compile Save. Agora você pode ver a função. E aqui vamos
fazer a auto-referência. Então, assim como o que temos
feito até agora, nada de novo. Agora que nós adicionamos isso. Agora podemos fazer uma referência a esse controlador de IA
sem custo. Então, se eu for para a base inimiga, agora posso dizer obter aae,
controlar nossa referência. Ok, agora, como referência do
controlador de ar para parar uma árvore de comportamento, a única coisa que você
precisa fazer é tirar disso e pegar o
componente cerebral daquele ai. Então, obter o componente cerebral
e dizer: Pare a lógica. Agora isso vai parar
a árvore de comportamento. Qual é o motivo? Só vou dizer golpes
para a cabeça do inimigo. Isso realmente não
importa para nós aqui. Então, a cabeça do inimigo
e isso vai
parar esse controlador de IA. Ok, então quando
clico em Jogar agora e vou até o jogador
e acertei o inimigo. Ele vai atingir esse inimigo e você pode
ver que ele pára completamente. Nunca vai
se mover porque eu
realmente parei a árvore de comportamento. Agora você pode fazê-lo se mover
depois, depois de atingirmos. Portanto, não é totalmente estático. Você pode simplesmente copiar esse modo de movimento. Vou voltar
aqui e colá-lo. Agora ele vai de
ninguém novamente para caminhar. Então agora vamos andar
novamente depois de você ter sido atingido. E lembre-se que definimos esse atraso. Então, por mais tempo que sua animação seja para a animação de cabeçalho, você vai atrasá-la. Lembre-se, um
erro fácil que posso imaginar é aqui e os ativos inimigos. Então, por exemplo, para
o efeito de sucesso do caracol. Lembre-se novamente, eu disse
antes que isso era muito importante mudar os quadros por segundo para esse efeito de calor, mesmo sendo um quadro. Porque se você for
configurá-lo para 15, como padrão, esse atraso aqui será muito, muito pequeno, então
nem vamos notar
essa animação aqui. Então, enviá-lo para um,
significando 1 segundo. Portanto, é um quadro por segundo. E vai esperar 1 segundo, e depois vai
jogar isso. Ok, então colocá-lo para
caminhar agora podemos jogar. Agora, sempre que você
for
acertá-lo, ele vai reproduzir a animação da
cabeça e , em seguida, mudará
para o modo de caminhada. Mas agora está
no modo de caminhada, mas realmente não
especificamos que ele
realmente deve funcionar novamente. Então, vamos fazer isso antes de
encerrarmos este vídeo. E lembre-se, podemos apenas usar a carga de movimento definida ou
não estados motrizes. E aqui na base inimiga,
set, estado de movimentos. E vamos defini-lo para funcionar corretamente, porque queremos
estar correndo novamente. Ok, então deve
ser isso para este vídeo. Então, vamos apenas jogar e
ver se está funcionando. Então agora eu tenho o inimigo e ele vai entrar
na carga ambulante. Agora ele vai ficar
preso agora porque não
dissemos para
onde caminhar. E isso é algo com o qual
vamos
trabalhar na próxima lição, onde dizemos ao
inimigo que você realmente vai
perseguir a camada.
74. Perseguir o jogador inimigo: Então agora queremos que o inimigo
persiga o jogador. Então, quando o inimigo for
atingido pelo jogador, ele vai passar por cima e
perseguir o jogador que o atingiu. Então, primeiro,
vamos salvar tudo. Deixe-me realmente fechar
tudo
isso porque está ficando um
pouco demais. Vamos começar
do início aqui. Então, aqui no inimigo, quero que você abra
esse controlador inimigo. E aqui nos
componentes clicando aqui e escreva sensoriamento. Então você pode ver que temos
algo chamado em sensoriamento. Então, vai
sentir nosso jogador. Isso soa como, isso
soa como uma Skynet. Agora fica um pouco assustador. Então, temos os pons sentindo e isso vai
sentir os pontos. Então o jogador, e a única coisa que
vou mudar aqui, você pode ver o que ele pode fazer. Por exemplo, ele pode ouvir ruídos. Então, se você está fazendo como um jogo de esgueiramento como
Metal Gear Solid, você pode ter essa sensação
calorosa ao sol, envia ruídos quando você bate
na parede e assim por diante. muito legais. Mas a única coisa que
vamos mudar aqui
no ângulo de visão periférica, vou colocá-lo em
180 para que ele possa parecer 360. Vamos compilar e salvar. Essa é a única coisa que tínhamos
que fazer . Agora vamos fechá-lo. Vamos abrir a base inimiga. Então, aqui na base inimiga, quando o inimigo
está sendo danificado. Tudo isso fizemos
nas lições anteriores. Então, agora o ponto
está se movendo novamente. Então, o que queremos fazer agora é que
queremos perseguir o jogador. Então, quando você começa a se mover, você
quer perseguir o jogador. A coisa que vamos
usar é chamada ai mover para este. Ai mudou-se para. Então, ele vai
se mover para o jogador. Agora ele vai dizer
aqui o ponto, quem está se movendo. É apenas eu, é o inimigo. Então, vou me arrastar disso e dizer
a si mesmo. Essa é a lagoa. Ok, para
que está se movendo? Ele vai se mover
para o jogador. Mas realmente não temos uma
referência para o jogador aqui. Aqui você pode ver instigado por, e isso é o que eu
estava fazendo o dano, e este é o controlador. Então, este é, na verdade,
o controlador do jogador. Podemos usá-lo na
unidade a partir daqui. E clique com o botão direito do mouse e
diga que promove uma variável. Vou chamá-lo de
controlador de jogador, conectado aqui. E lembre-se de replicar essas informações para
que o
cliente também possa ver isso. Então agora temos a linha de controle da
placa. Agora podemos pegar a
lagoa disso. Então, pegar o controlador do jogador, ficar, ser controlado. Isso é o que você pode
fazer no multijogador. Então você tem o
controle e você pode controlar
esse controle a partir
desse controlador do jogador. Então agora temos o jogador, e agora você pode ver
a localização do ator. Então agora temos a localização
do jogador e ele
vai perseguir em direção a
esse destino. Então, ele vai para
a localização do jogador. Certo, quem está perseguindo?
Quem é o alvo? O alvo é o jogador. Então, é simplesmente este. Este é o Peão do Jogador. Então, vamos apenas
conectá-lo aqui. E como é o raio
aceitável? Quando atingir esse raio, ele vai parar porque
você conseguiu
perseguir o jogador. Vou baixá-lo um
pouco, talvez duas unidades. Então, um pouco
mais baixo do que antes. Certo, vou
mover isso para cá. E só para organizar
as coisas um pouco mais, talvez este esteja
aqui em cima e clique duas vezes nisso para
que fique mais visível,
algo assim. Ok, Então, muito, muito,
muito, muito fácil de entender. Então está indo, então
esta lagoa está indo em direção ao
destino dos jogadores, local. E está perseguindo
esse jogador aqui. Ok, então vou ter sucesso, temos que fazer alguma coisa. Então, o que deve acontecer sempre que
você alcançar o jogador? E isso é algo
que
estaremos melhorando mais tarde. Então, na verdade, não agora. Então, vamos tentar testá-lo. Então, vamos ver aqui, vamos jogar. E agora podemos ver se
eu acertei, por exemplo, esse inimigo e eu podemos correr. Você pode ver agora ele
realmente me alcançou. E se eu fizer isso de novo, deixe-me realmente remover muitos desses inimigos
porque agora que estamos trabalhando com o
inimigo, você vai ver isso. Opa, eu
excluo a coisa toda. Você verá muito
mais claro o que estou realmente trabalhando
com apenas um inimigo. Então, vou apagar todos esses inimigos e vou
adicioná-los mais tarde. Então talvez eu só precise de
um escolhido
aqui só para testar isso,
ambos fora. E posso clicar em Play. Agora, vamos testá-lo. Por exemplo, neste grande,
vou acertá-lo agora. E isso vai me perseguir
para sempre até chegar a mim. Tão coisas muito legais. Agora ele vai se mover para mim e quando ele se mover para mim vai ficar parado para
realmente me prejudicar. Agora ele não faz
mais nada porque não contamos sobre o sucesso o que ele deve
fazer sempre que chegar a mim. Agora eu poderia simplesmente arrastar disso e simplesmente continuar loop para sempre e talvez isso
me dê um erro. Vamos tentar jogar aqui. Tão mal sucedido, pode continuar
me provando. Então, se eu acertar este caracol aqui e ele
me persegue e ele me atinge. E se eu for embora agora, você pode ver que isso
me persegue para sempre agora. Agora é meu animal de estimação.
Não é meu inimigo. Tenho um caracol como animal de estimação. Eu posso ter o porco
como eu tive também. Está indo, eles vão me seguir
para sempre agora. Certo? Como você pode imaginar isso, você também pode criar um sistema de animais de estimação onde você apenas
segue o jogador. Assim, você pode ver todas essas
ferramentas que são úteis para conhecer essas ferramentas para que possamos
usá-las da maneira que você quiser. Certo, coisas bem legais.
Vou excluir isso. Agora, o que eu quero fazer aqui, eu quero realmente fazer isso na próxima lição em
que melhoramos a forma como o inimigo está andando ao redor dele quando eles
alcançam o jogador.
75. Como melhorar a busca do jogador inimigo: Tudo bem, então eu quero melhorar
esse código um pouco. Então, sempre que ele se move
para o jogador, eu não quero continuar me movendo para esse jogador e continuar
perseguindo o jogador. Quero fazer com que o movimento pareça um pouco aleatório,
mesmo que não seja. O que eu quero que você
faça aqui no sucesso, eu quero usar algo
chamado Move tool. E vamos selecionar este chamado movimento para o local ou ator. Ok, então agora ele
se move para o jogador, e sempre que chegar
ao jogador vai executar essa função chamada mover
para o local ou ator. E eu vou usar
este, luxação aqui. Então, vamos dividir
esse local. Intervalo de minutos, vamos
fazer um vetor. E isso nos permite
ver o X, Y e Z. E aqui agora, aqui no
controlador, ele precisa,
ele precisa dos controladores de IA, como você pode ver quando você
segura o mouse sobre ele. Portanto, não podemos dizer “get
controller” e adicioná-lo aqui. Ele não vai aceitá-lo. Ele precisa especificamente
do controlador de IA. Vou dizer controlador de IA. E você pode ver que temos esse chamado get AI controller. E quem é o ator controlado? Lembre-se de que estamos dentro da base
inimiga para que possamos
dizer a si mesmo assim. Então, qual é a localização aqui? Para quem eu estou me movendo também? Agora, para o objetivo,
realmente não precisamos ligar a nada porque diz
mudar para o local ou ator. E vou
usar o local. Qual é a localização que
estamos nos movendo também. Mas eu quero fazer é aqui, eu posso realmente te mostrar. Então, se o jogador
estiver parado aqui, então deixe-me tomar a
Csarina, por exemplo, possamos
visualizá-lo muito melhor. Então Serena está aqui. Então, quando o inimigo
atinge o jogador, quero que o inimigo mova 100 ou algo parecido com
essas unidades para essa direção. E então o
inimigo voltará para esse jogador. E quando você alcançar
esse jogador novamente, eu quero mover 100
para essa direção. Então, ele continua se movendo assim. Porque agora ele
só se move para o jogador e ele ficou preso assim. Mas eu quero que ele se mova o jogador o
tempo todo assim aqui, então ele continua perseguindo o jogador, mas tem um
pouco mais de movimento do que apenas ficar preso
aqui no jogador. Então, se voltarmos para
a base inimiga aqui, então o que vou verificar
quando preciso verificar primeiro, se é como esse inimigo
vem deste lado, você precisa se mover para este lado. No entanto, se o inimigo
vier desse lado, você precisa se mover para este lado. Então eu tenho que verificar de
que lado o
inimigo está vindo. Então eu preciso levar
o jogador primeiro. Preciso saber onde
o jogador está. Podemos fazer isso aqui. Pegue isso de novo. Na verdade, vou
copiar colar esse código aqui. Então, estamos recebendo
o controle do jogador sobre a obtenção dos pontos de controle. Então o jogador, e estamos conseguindo a localização
do jogador. Vou quebrar isso
porque a única coisa que me interessa é esse pivô vermelho, que significa o eixo x. Então, só estou interessado
no eixo x. Não me importo com
o Z ou o y aqui. Então, vamos voltar aqui. Só estou interessado
no eixo x. Agora tenho a localização do
jogador. Também vou precisar da localização do
inimigo. E eu posso apenas dizer obter localização do
ator porque já
estamos dentro do inimigo, então o alvo em si. E deixe-me quebrar isso também. Quebre esse vetor para que eu
possa ver o X, Y e Z. Então eu vou perguntar, este
é x, então são
os jogadores, x. isso
é menor do que a
localização desse inimigo? E o que isso significa
é o inimigo, o inimigo aqui? Vai perguntar,
lembre-se, aqui, se você der uma olhada no x, se eu for nessa direção, vai ser em torno de 0. Então, ele vai entrar
no menos aqui. Se eu for nessa direção, você pode ver que está indo para baixo. Então, estou perguntando agora, é a localização do jogador,
a localização x? É menor que os inimigos? E agora é, porque agora o jogador
parado aqui, o inimigo parado aqui, este X, você pode ver o x aqui
para o jogador é menor do que o inimigo. Isso significa que o inimigo está
realmente vindo dessa direção, se isso for verdade. Então, o que deve
acontecer se o átomo vier dessa direção? E isso é algo que temos
que especificar aqui agora. Então aqui podemos fazer uma filial. E vamos mover isso um
pouco para cá. Assim, podemos fazer um ramo
e ver se isso é verdade. Queremos, como,
se isso for verdade, queremos mover esse inimigo também. Como menos quinhentos, quinhentos menos 100 unidades. Porque lembre-se quando você alcança o jogador e se
dissermos mover o local, você
é menos 100, o que significa que você vai
menos 100 no X, o que significa que você vai
menos 100 no X, o
que significa que o personagem realmente vai, ou o jogador
no inimigo está se movendo 100 para esse local porque
você está minusing aqui. Então é isso que
estamos tentando fazer. Então estamos dizendo aqui, estamos dizendo, então
pegue isso é verdade, depois pegue os inimigos x localização e subtraia
100 disso. E agora esta é a
nova localização x. Y e Z, não estamos realmente
interessados neles, então vamos apenas
conectá-los como estão. Então, agora o que estamos dizendo
é que os jogadores são, agora, é a localização x do jogador? É menor que os inimigos? Ou seja, o inimigo parado aqui e o jogador
parado aqui. Se sim, isso é verdade, então vá em frente e mova esse inimigo menos
o que o x é atualmente, que está aqui, menos 100 unidades. Esse é o nosso novo local de meta, o que significa que seus novos
locais de meta aqui. Então o inimigo vai se
mover daqui para cá. Certo? Então, coisa muito, muito
fácil de fazer aqui. E a outra coisa é, se for falso, precisamos pegar isso e dizer, então você vai
mover 100 mais 100 unidades. Porque lembre-se, se for falso, significa o inimigo
parado aqui. Isso significa que quando você
alcança o jogador, você quer que seu novo objetivo seja mais 100 e x porque você
quer movê-lo dessa maneira. Além disso, 100 faz 800 e
algo aqui, ok? Então, se você estiver de pé do outro
lado, você quer mais 100. Então esse é o seu novo objetivo aqui. Então, se eu arrastar estes aqui, então o x, o y e z, nós
realmente não nos importamos. É apenas o x que estamos ajustando. E esse será nosso novo objetivo. Mas em vez de copiar
colar esse código, agora, se você
se vê fazendo isso, como você pode ver, basta copiar o código de colar e eles parecem 100% iguais, exceto
por um valor. Você pode realmente tornar seu
código um pouco melhor. Você pode fazer algo
chamado de carga Select. Então, o que você pode fazer aqui
é, em vez de fazer esse branch e fazer assim, você pode ver que este é
o mesmo código e é realmente uma prática de codificação ruim porque você está apenas
copiando código, o que é quase o mesmo. Então ele pode fazer isso um
pouco melhor. Então, em vez de aqui, você pode fazer, deixe-me
desconectar isso. E aqui, em vez disso, agora estamos adicionando
ou
subtraindo 100 disso. Podemos derivar disso e dizer
selecione e use este
chamado Select Load. E agora este booleano, vamos
conectá-lo aqui em vez disso. Então agora vai dizer que
é a localização do jogador, este x local menor que
a localização do inimigo. Se isso for verdade, novamente, se isso for verdade,
precisamos subtrair. Então, em vez de apenas fazer isso ,
podemos dizer menos, vou dizer um menos 125. Acho que testei
com esse número. Acho que esse é o melhor. E se não for verdade, que significa que o inimigo
está parado aqui, queremos adicionar 125. Então você pode ver aqui que realmente não
precisamos fazer toda
essa cópia colando. Agora ele vai
fazer isso automaticamente por nós, então não precisamos copiar, colar o mesmo código. Ele vai selecionar,
Tome, dê uma olhada nisso se
for verdadeiro ou falso. E ele vai
fazer esse número, como se fosse menos
ou mais esse número. E não podemos adicionar, como não podemos simplesmente conectá-lo diretamente aqui porque ele
vai defini-lo
para esses números. O que precisamos fazer é pegar esse valor x e precisamos
adicionar esse número em cima dele. Então, aqui precisamos
adicionar esse número. Então, por exemplo,
digamos que o x seja atualmente 600 para o inimigo. Então vai, se
isso for verdade aqui, vai dizer
600 mais menos, o que significa apenas
menos 600 menos 125. E isso vai definir isso
como o novo local x. Se o inimigo aqui, se isso chegar a falso, então isso era verdade
e isso era falso. Diz 600 mais 127, então ele vai
se mudar para esse local. Ok, então fazer isso é muito melhor do que copiar código
de colar. Então, quando você se vê
copiando código, provavelmente
há uma maneira
melhor de fazê-lo. Mais uma vez, você é bem-vindo
para ir ao meu Discord. Estou disposto a ajudá-lo
com todas essas coisas. É bom ter
todas essas coisas boas e
boas práticas para
quando você está codificando. Então você não gosta, então é bom ficar
limpo assim. Tudo bem, então podemos realmente
remover esse ramo. Nós realmente não precisamos mais disso. Então, vamos realmente testá-lo. Então agora nós realmente
temos que fazer algo porque quando você se move
para esse local, temos que repetir o movimento
aqui e seguir terminado. Vamos arrastar esta caneta
e apenas repetir isso. Me mudei para cá. Vou
clicar duas vezes neste pin para fazer redirecionar nós. Na verdade, faça com que pareça um pouco mais limpo, então não é confuso parecer algo assim. Agora vamos compilar e salvar, e vamos jogar e ver o que acontece se
esquecemos de algo. Mais uma vez, vou para isso aqui. E deixe-me realmente
excluir esse jogador, o jogador aqui, jogar novamente. Então, como Luke vai
bater no prego. Vai se mover para mim. Quando chegar a mim, ele
vai se mover 125 para aquele local quando
chegar a mim novamente, 125. Você pode ver que este é
o movimento que
adicionamos e este é phi, arraste-o novamente aqui. Então, quando chegar a mim, ele vai mover menos 125 para que as tags de
localização X atuais sejam mais 125. Ele vai se mover para esse local quando o
filme terminar, ele vai repetir
esse movimento, o que significa quando estiver
parado, por exemplo, se eu voltar ao jogo, quando parado aqui, ele
vai me perseguir de novo. E então, quando
chegar a mim novamente, ele vai repetir
esse código novamente. Então, ele vai nesse
movimento circular o tempo todo. E eu acho que é um
pouco mais suave
fazer o movimento assim
porque agora, quando eu me afastar, novamente, ele vai me perseguir. Então, tudo está
funcionando corretamente. Persegue-me agora, quando chegar a mim, ele vai 125
para essa direção. 125 para essa direção. 125 para essa direção, continua indo e vai
me perseguir novamente se eu for embora. Então, movimento muito legal
e podemos tentar isso com o porco aqui. Você pode ver esse porco se mover como
a animação de ataque de porco. Na verdade, está funcionando bem. Certo. Então, ele vai me perseguir agora. E eles continuam de frente para
mim e agora estão indo 125 nessa direção. E há como se houvesse
um pequeno bug com esse, talvez
precisemos corrigir a colisão da
rampa aqui. Provavelmente é uma colisão
com a estática aqui. Então, o que você pode fazer
aqui na base, você pode clicar na colisão, pode realmente
ignorar tudo exceto o Po1 e
o cliente sendo jogadores. Então, basta movê-los da sobreposição
porque realmente não
precisamos nos sobrepor a nada aqui para essa colisão aqui. E para esta cápsula. Não podemos realmente fazer isso
porque agora está indo, eles vão cair
do chão. Provavelmente. Você pode ver que não há inimigos porque eles estão caindo
pelo chão. Então você tem que ter
isso na cápsula. Então, clicando no jogo agora, vamos ver, este é o
caracol, o porco aqui. Certo, e vamos
mover esse local. Opa, eu não bati nele. Ok,
acho que está funcionando agora, então agora eles não estão
incomodando aqui na rampa. Certo, muito legal. Agora temos um movimento de IA
muito simples e muito simples. E parece muito legal,
parece aleatório também, mesmo sendo um código
muito, muito simples. Portanto, parece aleatório também, mesmo que não esteja
relacionado ao aleatório. Coisas muito legais que
fizemos aqui. E sim, foi
isso para este vídeo. Espero que você tenha se divertido. Eu me diverti criando isso e
vamos passar para o próximo.
76. Como aplicar danos: Ok, então agora estamos prontos para que o Inimigo faça o dano, porque até agora é apenas o jogador que
faz esse dano aqui. Então, apenas o jogador
está causando o dano. Precisamos que o inimigo cause
dano ao jogador também. E para fazer esse dano, nós realmente não queremos
codificá-lo aqui em nenhum dano porque
queremos que o inimigo aplique o dano
mesmo que eles não estejam
sendo atingidos por ninguém. Então, se o jogador estiver
entrando no inimigo, mesmo que o jogador não o
tenha atingido,
ele ainda pode causar dano. Então, vamos fazer
um evento separado aqui chamado Start
aplicou dano. E nós realmente vamos
querer fazer isso
imediatamente sempre que eles
surgirem para o nível. Ok, então vamos voltar para as interfaces e
na base inimiga, deixe-me fazer uma nova função aqui que começará tudo. E vamos chamá-lo de
inicia o dano aplicado. E vamos fazer um
booleano onde dizemos o dano aplicado e isso
pode ser verdadeiro ou falso. Sim, é isso por enquanto. Então, vamos compilar, salvar e voltar para a base inimiga. E o que podemos
dizer aqui é que podemos clicar com o botão direito do mouse e
podemos dizer começar, aplicar danos, e podemos
chamar esse evento aqui. Agora este, novamente, vai
passar pelo servidor para garantir que não seja o
cliente não está trapaceando. Portanto, o servidor inicia a aplicar danos. Normalmente, eu
os chamo de mesmo nome que os eventos normais
e executo no servidor. Confiável. E agora este booleano aqui, precisamos adicioná-lo obviamente
novamente, ser aplicado dano. Agora podemos dizer,
podemos escrever um ramo aqui e dizer se isso
é verdadeiro ou falso. E com isso,
queremos fazer alguma coisa. Então, queremos começar a aplicar o dano sempre que for
verdade e for falso, não
queremos mais
aplicar dano. E quando definimos
isso como verdadeiro ou falso? Então, deixe-me realmente executar essa função de servidor aqui primeiro, dano leve de
inicialização
aqui e conectado. Então, quando queremos
aplicar o dano? Queremos aplicar
o dano sempre que o jogador estiver colidindo
com o inimigo. Então, quando o jogador, se
eu voltar para o inimigo, se eu voltar para um caracol, quando o inimigo estiver colidindo com esta pequena caixa de
colisão aqui, queremos começar a aplicar
dano ao jogador. Antes disso, não
queremos aplicar nenhum dano. Lembre-se, estamos
otimizando nosso código, então não queremos aplicar
o dano 24-sete, só
quero aplicar
dano sempre que o jogador estiver interagindo
com o inimigo. Vou para a base inimiga aqui e vou para a janela de exibição, clicando nesta colisão, descendo até o
fundo e, em seguida clicando no componente n
começa a sobreposição. Então, no
início do componente de um laboratório, o que temos feito
como antes, queremos executá-lo através do
switch tem autoridade para
garantir que seja o servidor que
está executando esse evento. E novamente, quero fazer uma nova sobreposição deste fim de tempo possamos fazer isso ao
mesmo tempo também. Vou verificar se o que está se sobrepondo a
ele é o jogador. Então, novamente, o ator
marcou camada. Sabemos, sabemos que o jogador tem o jogador de tecnologia e
podemos fazer um brunch agora. Eu não acho que já
expliquei isso ainda, mas você também pode fazer uma
ramificação se você apenas segurar, segurar B no teclado
e, em seguida, clicar, você pode realmente fazer
ramificações também. Atalho muito legal
que você pode fazer. Então, se a tag for jogador
aqui para este ator, vamos aplicar
dano e nós apenas estamos interessados em
executar este evento aqui. Então, ele começa a mentir dano
aqui na base inimiga. E vamos
definir isso como verdadeiro. Agora, quando terminarmos a sobreposição, onde você só
deseja copiar, cole todo esse código e queremos
parar de aplicar o dano. Ok, então é assim
que você otimiza. Agora, para o dano aplicado, o que eu quero fazer é
que eu quero
aplicar danos continuamente. Eu vou mostrar a
vocês por que realmente
não estão mostrando por que eu posso explicar
isso muito rapidamente. Então, se o jogador for apenas pegue o
jogador, não o caracol. Então, se o jogador estiver
dentro desse inimigo aqui, sob o jogador, eu estou
andando por aí, estou entrando no inimigo. Estou sendo atingido. Estou perdendo saúde. Mas se eu ficar seguro dentro
dessa esfera e nunca
acabar sobrepondo a ela. Mesmo que eu esteja de pé
por dez segundos, não
vou aplicar danos porque no final e
começar a se sobrepor, você vai aplicar danos. Mas lembre-se, isto é, esse evento só é
executado uma vez porque isso só
é executado sempre que
você começar a se sobrepor. E isso será executado
uma vez porque isso acontecerá, esse evento será executado uma vez. E é aí que você começa a
sobrepor o inimigo. Mas queremos adicionar dano
continuamente a esse jogador se você não estiver se
afastando desse inimigo. Como talvez isso lhe dê um dano cada dois segundos se você estiver parado dentro
desse inimigo. Queremos verificar o tempo
todo se o jogador está
realmente parado aqui e queremos
aplicar dano. Então aqui estamos nós, já estamos
verificando se o jogador está
nesta caixa aqui porque estamos começando a aplicar dano sempre que o jogador estiver dentro dessa colisão e nós pare de aplicar
danos aqui. Lembre-se, novamente, talvez você
já tenha adivinhado quando
quiser aplicar dano
continuamente, então a palavra continuamente, você precisa usar um temporizador. Então, assim como o que fizemos antes. Então defina o temporizador por evento aqui. Vamos dirigir a partir daqui
e torná-lo eventos personalizados. Vamos chamar isso de dano
aplicado. Temos esses eventos personalizados e queremos
aplicar algum dano. O dano que queremos aplicar. Na verdade, vamos fazer
looping e vou
verificar a cada 0,12 era. Então, isso significa que você está aplicando
dano dez vezes por segundo. E isso fará sentido mais tarde, como se nós vamos reduzir isso. Mas o que queremos fazer, vamos movê-lo para cá. O que queremos fazer é de
novo, obter atores sobrepostos. Portanto, estamos interessados em obter
toda a base de jogadores. Portanto, recebendo todos os jogadores
sobrepostos, queremos aplicar
dano a todos eles. E vamos arrastar
disso e dizer para cada um. Esse método, se já
fizemos do jogador
para os inimigos, agora está na direção
oposta. Agora são os inimigos que aplicam
dano aos jogadores. Apenas certifique-se de
ter a base de jogadores selecionada aqui e não a
base inimiga ou outra coisa. Então, para cada um desses jogadores, o que queremos fazer? Agora? Você também pode verificar o
comprimento se for igual a 0, mas isso realmente não faz sentido porque você já
está verificando se os jogadores
estão aqui ou não. Então, para cada um desses
jogadores
que estão dentro
da caixa de colisão. Mais uma vez, queremos fugir
disso e dizer Aplicar dano. Agora a quem eu
quero aplicar danos? O ator danificado? É o jogador. Então
é só esse cara aqui. E temos que especificar
quanto dano cada mistura inimiga. Então, temos que voltar para a estrutura nas informações
do animal. E aqui precisamos adicionar uma
nova variável chamada dano. Deixe-me
arrastá-lo para cima aqui, abaixo da saúde, e deixe-me
mudá-lo para um flutuador. Salve aqui e a base inimiga
agora podemos compilar e salvar. Então agora podemos ir para os inimigos. Então, no porco aqui, podemos definir um dano. Então, vamos clicar nos padrões
da classe, vá para informações sobre animais. E então esse dano, por exemplo, os porcos estão causando 15 de dano. Ou talvez, talvez
digamos que 20 de dano na verdade para os porcos e
aqui para os caracóis. Se voltarmos às
configurações de aula para os caracóis, talvez eles façam,
digamos que eles causem dez danos. Vamos compilar e salvar. Ok, então agora eles
fazem dez danificados, o porco está causando 20 de dano, então dobre o dano. E aqui o que podemos fazer
é pegar as informações do animal, separá-las e sofrer
esse dano adicionado aqui. E agora é dinâmico. Então, seja qual for o inimigo, eles vão causar
sua quantidade de dano. Ok, então qual é o controlador responsável
por esse dano? Então estamos dentro
da base inimiga, então só precisamos do
controlador desse inimigo. Mais uma vez, você pode arrastar e
dizer que obtém controle. E é isso para a lista de tipos de dano muda
para o tipo de dano aqui. E isso é
tudo o que precisamos aqui. Então, agora estamos realmente aplicando
dano a esse jogador. Agora, mais tarde, vamos adicionar um modo deus
para que o jogador não
esteja sendo danificado dez vezes por
segundo, porque isso é essencialmente o que
está acontecendo agora. O jogador está ficando danificado
dez vezes por segundo. Mas vamos adicionar o modo
Deus mais tarde. Portanto, há um período de tempo em que o jogador não
será danificado. Mas, por enquanto, isso é
tudo o que tínhamos que fazer. E vamos passar
para a próxima lição.
77. Danos que recebem jogadores: Tudo bem, então agora temos que
codificar o jogador recebendo o dano
do inimigo. Então, agora vamos voltar
para a base de jogadores e vamos para o Event Graph. Na verdade, vou arrastar
o gráfico de eventos aqui e clicar com o botão direito do mouse e dizer guias
fechadas à direita. Então, só temos isso aberto agora. Então agora só temos
o ataque feito, e agora realmente
precisamos causar qualquer dano dentro daqui. Vamos clicar com o botão direito do mouse
e causar qualquer dano. Agora temos esse evento. Assim como no inimigo Aqui, em qualquer dano, precisamos
subtrair a saúde do jogador. E, na verdade, não tenho certeza se fizemos isso.
Não me lembro. Então, vamos para a
estrutura e, em vez de informações
do jogador, e nós não temos. Então, nas informações do jogador, você precisa adicionar uma nova
variável chamada Saúde. Este que você pode pegar, Você pode transformá-lo em
um flutuador, movê-lo para cima. Vou movê-lo para o topo. Na verdade, salve aqui e a base de
jogadores que você precisa
compilar e salvar como
padrão para os jogadores. Só vou clicar aqui, todos
eles têm a mesma saúde. Então, vou colocar um valor
padrão para todos eles. Por exemplo, para a saúde, vamos fazer algo como 70. Não sei, é
apenas um número aleatório. Então, apenas 70. Vamos
compilar e salvar agora. E para as informações divididas, agora
podemos pegá-lo
e quebrá-lo novamente. E o que queremos fazer, só
vou
esconder tudo e mostrar a saúde. Esta é a única coisa em que estou
interessado agora. Então, vou tirar a saúde
do jogador, subtrair, subtrair, subtrair
o dano dele. Então, por exemplo, esse caracol
causará dez danos. Então ele vai dizer aqui, seja lá o que for que definimos. Então 17 menos dez serão 60 aqui. Então esta é a nova
saúde, assim como antes, precisamos definir a
saúde aqui. Então, arrastando dessa estrutura, precisamos escrever conjunto,
selecionar membros do conjunto. O que queremos atualizar
dentro dessa estrutura, precisamos atualizar as variáveis de
saúde. Vou selecioná-lo aqui
à direita, colocá-lo aqui. Portanto, esse é o novo valor. E assim como antes, antes de eu fazer isso de novo, vamos fixar esse valor para que
ele nunca fique abaixo de 0. Vamos clicar com o botão direito do mouse e dizer subir e selecionar
este chamado cargas de grampo. Portanto, o valor mínimo é 0. Na verdade, deixe-me me conectar
ao valor aqui em cima. O valor mínimo é 0. E o valor máximo. Agora você não pode simplesmente
entrar aqui e conectar isso porque
agora, na verdade, ele realmente vai. Então, o que você pode fazer para
esse máximo, novamente, você pode arrastar dessa
saúde e conectar-se aqui. Então, esta é a saúde máxima. Então você pode
conectá-lo dentro
daqui e apenas conectá-los. Eu vou arrastar isso para baixo,
na verdade, deixe-me movê-lo um pouco para frente e arrastar
isso para baixo assim. Então, ele vai fixar o valor e tentar o seu melhor para
torná-lo o mais limpo possível. Às vezes, é um pouco
difícil na verdade, e algo assim. Certo? Então, algo assim. Estamos fixando o valor agora, certificando-se de que ele
não está abaixo de 0. E você novamente, você tem que
definir aqui na estrutura externa, você tem
que definir essa estrutura de informações do jogador
novamente e replicá-la. Assim, o cliente também pode vê-lo apenas para ter certeza de que as
informações não estão incomodando. E agora o jogador está
recebendo esse dano. Então, novamente, você pode
imprimi-lo na tela porque não
temos UI agora, faremos isso mais tarde. Mas você pode quebrar essa estrutura e adicionar a saúde aqui para que possamos exibir
essa nova saúde. Você pode imprimi-lo na tela e ver se está funcionando. Então eu vou
jogar esse jogador, vou
entrar no inimigo. Você pode ver que está me prejudicando e vai
me prejudicar dez vezes por segundo. Lembre-se que temos esse
temporizador no inimigo dizendo aplicar dano
dos 0,1 segundos. Então, dez vezes por segundo. Você pode ver que
nunca está abaixo de 0, então isso está correto. Está sempre parando sempre que
eu não colido mais. Mas você pode ver que
talvez tenhamos um pequeno problema aqui porque quando colide
com minha colisão atacante, na
verdade está aplicando
danos a mim. E eu não quero fazer isso. Eu só quero aplicar
dano ao meu personagem, então temos que consertar isso. Ok, então eu joguei com as colisões e só para
poupar um pouco de tempo. Então, aqui na base do jogador, na cápsula tentou fazer
suas colisões como minhas. Então, apenas para
explicar um pouco para que possamos entendê-lo também. Portanto, estamos gerando eventos de
sobreposição. Aqui. A única coisa que
esta cápsula é quatro, então esta é a cápsula do jogador. Só queremos aplicar
dano ao jogador. E lembre-se quando você vai até o inimigo e clica
nessa caixa de colisão, esta é a caixa que
precisa aplicar dano a nós. Você também pode ver esta caixa
se clicar nela e clicar em ocultar no jogo e
removê-la para
poder vê-la no jogo. Então, se você clicar em Jogar agora, você pode ver essa caixa
ao redor do inimigo e esta é a caixa que vai
aplicar dano a nós. Então esta caixa aqui,
lembre-se, esta caixa, se você for para a colisão, é uma dinâmica mundial. Então, essa é a coisa mais
importante com a qual precisamos nos sobrepor. Não é ****, então
a cápsula é ****. Mas esta é uma dinâmica
mundial. Então, indo para uma base de jogadores, precisamos bloquear o mundo. Dinâmico. Bloqueio, o que significa que eu
quero gostar de interagir com ele. Isso não significa, não
significa que ignoramos isso, ignorar isso sobre
um bloco é que eu quero
realmente fazer um evento a partir dele. Então, vamos bloquear a dinâmica mundial,
o que
significa que vamos
interagir com ela, assim
como o mundo estático, porque a estática é, são essas telhas no chão
e se você remover isso, você vai cair
pelo chão. Tudo o resto que podemos realmente
ignorar, tão distraído, então não temos veículos, corpos
físicos, outros poemas. Nós realmente não precisamos interagir com outros pons aqui agora. Eu acredito em loucos. Porque o dano está realmente vindo dessa dinâmica mundial. Não é realmente a cápsula dos inimigos. Era a cápsula dos inimigos então, correto, precisamos
não ignorar a lagoa. Mas agora
vem dessa colisão, que é uma dinâmica mundial. Então é por isso que estou
ignorando tudo e só mantendo esses dois. Agora, para isso, não
estamos gerando
nenhum evento de sobreposição. Então, vamos pular
este. Para o ataque. É uma dinâmica mundial e estamos ignorando tudo
porque a única coisa que estamos usando essa caixa de ataque
é causar dano ao inimigo. E queremos
causar danos sempre que esta caixa aqui estiver interagindo
com essa pequena colisão. E lembre-se novamente, isso
é uma dinâmica mundial. Então, queremos
interagir como quando nos
sobrepomos com a dinâmica mundial, queremos aplicar dano, que é o inimigo aqui. O inimigo é colisão. Então isso faz sentido.
Vamos até o inimigo agora. Então, a cápsula dos inimigos, estamos bloqueando tudo, mas estamos nos sobrepondo
com os pontes e o cliente sendo camadas. E vamos para a colisão. Aqui. É tudo dinâmico. Na verdade, estamos ignorando
tudo, exceto ****. Porque a maneira como o inimigo **** está fazendo o dano é
entrando no jogador. E na verdade não está
entrando nessa caixa de ataque aqui. Está entrando em nossa cápsula
e nossa cápsula está em cima. E é por isso que eu preciso
aqui no inimigo para se sobrepor com a resposta de
colisão de peões. É muito importante
dar uma olhada em todas
as colisões. Que tipo de objeto eles são? Se fosse peão, então eu tinha que ir aqui
e me sobrepor com o peão. E se fosse, digamos que fosse colina sendo jogador e eu queria
causar dano, então eu tive que ir em frente e me
sobrepor com o jogador de escalada. Tentei dar uma olhada nisso, tentei brincar e ver como funciona. Então,
vamos salvar tudo. Agora. Vamos clicar em Play. Vamos jogar este jogador. Se você estiver interagindo
com minha caixa aqui, não
estou recebendo nenhum dano. Isso é bom para você. Interaja comigo. Estou recebendo
danos porque está interagindo com
minha cápsula aqui. E aqui. Se eu, agora, você pode ver se eu
voltar apenas ao meu ataque, colisão de
ataque,
não está aplicando dano a menos que esteja
realmente entrando em mim. Então isso está funcionando como pretendido. Agora, esse código para o jogador que recebe o
dano também está funcionando. Então, vamos realmente
excluir isso por enquanto. Então, agora que
fizemos isso, realmente não queremos
aplicar danos o tempo todo. Então, vamos criar algum tipo
de modo deus na próxima lição.
78. Modo de Deus para recriar: Ok, então vamos adicionar um
modo deus para o jogador. Vamos para a base de jogadores agora. Vamos criar uma nova variável
chamada modo Deus. Então, seja o modo Deus, e é apenas um booleano
que podemos usar aqui. Temos esse booleano
chamado modo Deus, e queremos definir esse modo Deus sempre que estamos
ganhando dano aqui. Então, pouco antes de eu realmente
calcular tudo isso, eu só queria pegar minha variável Modo Deus e
quero configurá-lo como verdadeiro, porque agora estamos no modo Deus. Não queremos ser
danificados assim. E lembre-se de replicar
isso para o cliente também. Então você pode ver que você está dentro
do estado do modo deus. Então, para o modo deus aqui, temos que defini-lo como verdadeiro, mas temos que defini-lo
como falso em algum momento. E você tem que colocar algum
tipo de duração. Então, vamos realmente
criar uma nova variável chamada tempo de modo de guarda. E vamos mudá-lo para um flutuador. Vamos compilar e salvar. Para o guia, a hora da China. Vou configurá-lo para 1,5 segundos
para que o inimigo não possa me danificar
pelos próximos 1,5 segundos. Vou pegar isso
e dizer atraso assim. E vou
definir um atraso depois de calcular minha saúde. E então aqui vou
definir meu Modo Deus como falso. Ok, então agora estamos sentados
para verdade quando recebemos danos e depois de 1,5 segundos
estamos definindo como falso. Ok, então aqui, vamos
voltar para o inimigo agora. E aqui você realmente tem que
verificar como um booleano. Porque agora estamos apenas aplicando dano dez vezes por segundo. Mas, em vez disso, você vai aqui. Você está fazendo um, obtém atores
sobrepostos e você está ganhando
todos os jogadores. Agora, para cada um desses jogadores, você precisa verificar se o
jogador está no modo Deus. Então, tomando isso e
dizendo, em primeiro lugar, obviamente você precisa especificar se comunicar com esse
jogador, base de jogadores. Então, temos que dizer Get layer REF, o que temos
feito há muito tempo. Vamos conectá-lo
como, na verdade, deixe-me desconectar isso por enquanto, para que
possamos ver o que estamos fazendo. Então, agora estamos fazendo
isso e dizendo o modo Deus. Então, estamos recebendo essa variável do Modo
Deus. E somente quando o
modo deus não é verdadeiro, podemos causar danos. Então podemos dizer nozes, booleano. Então, se o modo Deus é falso, se não estivermos no modo Deus,
vamos fazer um ramo. Se não estivermos no modo Deus, podemos seguir em frente e
aplicar danos assim. No entanto, se estivermos no Modo Deus, não aplique dano,
não faça nada. Assim, esse é
todo o código do modo Deus. Então, novamente, muito poderoso para
usar booleanos assim. E sim, então agora temos que
conectar isso novamente. Quem é o ator danificado? Pode arrastá-lo para aqui deste
jogador. Você não precisa fazer
isso daqui agora. Você pode fazer isso daqui. Isso está um pouco mais limpo agora. Agora vamos tentar
testar e vê-lo. E acredito que
excluímos nossa string de impressão. E deixe-me, deixe-me, na verdade, podemos apenas imprimir uma corda aqui. Então imprima string e
vamos imprimi-la aqui. Na verdade. Vamos quebrá-lo primeiro. Vamos pegar a saúde
e imprimi-la. Então, pouco antes do atraso, vou imprimir. E então vou
levar esse atraso, voltar para essa cadeia de impressão, voltando a esse atraso aqui. Então, vou imprimir
esse valor antes de atrasar. Vamos ver o que ele faz. Então, vamos clicar em jogar. Eu entro no inimigo, estou recebendo dano para 60. E somente após 1,5 segundos
após o modo jardim, estou sendo atacado novamente. Esse código está funcionando agora. Incrível. Vamos excluir
isso e conectá-lo novamente. Ok, então agora temos a funcionalidade do Modo Deus
adicionada ao jogo.
79. Jogador acertar VFX: Então, agora precisamos adicionar
um efeito piscando para quando o jogador for atingido. Então, aqui na base de jogadores ,
estamos dentro daqui novamente, temos que fazer algum tipo
de efeito danificado para
o efeito piscando. Então, vamos aqui e
fazer novos eventos. Agora temos que fazer isso dentro
da nossa Interface de Blueprint, mas não tenho certeza com quais variáveis preciso trabalhar agora. Então, vamos torná-lo
como uma variável personalizada ou eventos personalizados e podemos simplesmente mudar isso para uma Interface de
Blueprint mais tarde. Vou chamá-lo de dano VFX, o que significa efeitos visuais. E eu sou como
neste vídeo, vamos apenas fazer
o jogador piscar quando você estiver recebendo dano
do inimigo. E, obviamente, novamente, temos que
executar isso através
do servidor para
garantir que o cliente esteja fazendo
o que é permitido. Vou executá-lo
através do servidor confiável e vou chamar o servidor aqui
chamado VFX danificado. Certo, e aqui embaixo, agora, esse efeito de dano, até
agora estamos usando as variáveis de notificação do representante. Mas vou me lembrar
aqui para o salto. Então, se eu subir para o salto, usamos um multicast. E se você não se lembra, isso é
há muito tempo que usamos isso. Um multicast está fazendo a
mesma coisa que um representante notificar. Então, mostrando todas essas
informações para o cliente. Mas o multicast só
custará essas informações para jogadores ou
jogadores
já conectados ao seu lado. Então, o jogador está
muito longe de você não verá o que
o multicast está fazendo. Isso é bom usar para um efeito de
dano porque você está apenas piscando por dois segundos ou onde quer que seja, quanto tempo é. E então esse
efeito piscante vai desaparecer. Portanto, não importa para os jogadores que estão a dez quilômetros de você ou jogadores que ainda
não estão conectados. Tudo bem que eles não
vejam essa mudança porque é apenas um efeito piscando e você voltará
ao normal novamente. Então, vamos fazer
um evento personalizado e chamado VFX de dano multicast. E vamos executar isso
no servidor. Confiável, real,
não no servidor. Vamos executá-lo em multicast. Confiável. E o multicast vamos executá-lo
pelo servidor. vez, lembre-se, um multicast, você não pode executá-lo em nenhum
outro lugar , exceto pelo servidor. Então, vamos chamá-lo aqui efeitos V danificados
MC. Você não pode, você não pode
chamar isso aqui em cima. Isso não funciona porque
esse não é o servidor. Esse é o
servidor e o cliente. Então, descendo aqui, colocando esse multicast
aqui rodando pelo servidor. Agora, o multicast vai fazer
isso , esse efeito piscando. Então, para o
efeito piscante, muito, muito simples. Vamos começar a trabalhar com ele. Vamos pegar esse sprite. E quando ele quer fazer
está aqui no sprite, queremos mudar essa cor. Se você clicar na
cor do sprite, você deseja alterar esse alfa, o que faz com que seu
personagem seja transparente. Se eu cancelar aqui, se eu
clicar em um dos meus personagens. Então, se eu clicar em Tsarina
e eu for para viewports, aqui, eu clico nela, e clico na cor do sprite. E então eu levo o volume para baixo. Você pode ver aqui que o jogador está recebendo realmente
não o volume, o Alpha, desculpe, meu mal. O alfabeto aqui você pode ver
que o jogador fica invisível. O problema é agora
que o jogador passa de totalmente visível para ficar
totalmente invisível. Portanto, não há
intermediários e precisamos disso. E a coisa que está
causando isso é por causa desse material mascarado, sem iluminação, um material sprite. Na verdade, temos que mudar isso. Então, vamos tentar
mudá-lo aqui também. Então eu posso te mostrar
quando você clica nele, você não consegue ver nada. E isso ocorre porque você
precisa clicar aqui nessas configurações. E então você precisa clicar
em Mostrar conteúdo do desenvolvedor, mostrar conteúdo do mecanismo
e mostrar conteúdo de login. Então, clicando em
Mostrar dos três, você pode ver essas
pastas aparecerem. Nós realmente não
precisamos usá-los. Mas agora, se você for para
Serena e colorir aqui, você pode ver agora que você pode ver muito mais materiais se
estiver certo, sem iluminação. Porque estamos trabalhando
com pixel lot, então só estamos
interessados em não iluminados. Use este chamado
translucidez ou
material sprite translúcido não iluminado em vez de máscaras. Escolhendo esse. Você pode
ver agora, quando eu clico nessa cor brilhante e
eu tiro meu alfa para baixo, haverá um valor
intermediário, que ele não fique diretamente
invisível para visível. Na verdade, há um nível
intermediário aqui, e podemos fazer esse efeito
piscando subindo e descendo como este, o jogador fica danificado. Ok, vamos colocá-lo de
volta em um e deixe-me clicar nessa seta para
voltar ao padrão. Eu só quero voltar à minha máscara porque essa
é a padrão. Vamos alterar
isso por meio de código. Então, voltando para o meu jogador aqui. Então, primeiro precisamos
mudar o material. Então, indo aqui,
vendo material definido, selecionando-o aqui. Agora. Especifique qual material é esse. Agora não queremos, novamente, mudá-lo diretamente por aqui. Lembre-se, estamos
no multicast e gosto
ou não de ter que levar todas as minhas variáveis
para o evento muito básico aqui. Então, este material, você pode
arrastá-lo e colocá-lo aqui. Você pode continuar
adicionando-o aos seus eventos. E este é o principal evento
que vai executá-lo, que está aqui. Porque sempre que você
ganhar algum dano aqui, vamos chamar
nossos danos de efeitos. E você vai executá-lo aqui. E é aqui que você
seleciona o material. E queremos selecionar o
chamado translucidez. E desça na parte inferior, material de
sprite
translúcido não iluminado. Certifique-se de que o apagado. Ok, então agora mudamos nosso material, ok, e agora? Agora queremos mudar o Alfa, mas queremos fazer
um efeito piscando. E isso é feito
através de um temporizador. Podemos usar um temporizador
novamente para fazer isso. Então defina o temporizador por
eventos. Faça um aqui. E isso vai fazer
um loop algumas vezes. E quanto tempo, quanto
tempo ele vai fazer um loop? E encontrei uma boa maneira de fazê-lo para que possamos tomar o modo
deus aqui. Lembre-se de que o modo Deus é 1,52. Então, se você colocar aqui, isso
só fará esse efeito
piscando a
cada 1,5 segundos. E acho que é,
preciso torná-lo muito mais rápido. Então eu preciso dividir esse número. Achei o caminho, como se o melhor número fosse 16. Então, ele vai fazer isso
como dividir isso por 16, o que significa 1,5 dividido por 16, e isso é 0,09. Então é como escrever 0.09 aqui. É quase como escrever 0.1, o que significa dez vezes por segundo. Ok, então ele vai
piscar muito aqui, então você pode fazer isso dessa maneira. Então, sempre que você mudar
seu temporizador do Modo Deus, ele
mudará de acordo. Então, podemos fazer isso aqui. Então
, é meio dinâmico agora. Então, vou colocar meu
material aqui em baixo. Então, em vez de fazer isso aqui, vou arrastar
esse material de conjunto. Sinto-me desconectado daqui. Vou deixar
que ele seja conectado aqui assim e
preciso fazer um evento. Então arraste
daqui e diga danos. Vamos fazer um evento personalizado
primeiro, o loop afeta o dano. E agora podemos
conectar nosso material. Então, primeiro queremos que nosso
material seja translúcido. Então queremos levar isso
brilhante e definir a cor, a cor definida para a
cor Sprite, é chamada aqui? E agora queremos definir
essa cor brilhante também. Agora, não podemos realmente
mudá-lo aqui novamente, lembre-se que você tem que
passar por isso. Então arraste daqui, coloque-o dentro deste evento. E agora, em vez de
dizer nova cor, vou dizer cor. E novamente, arraste-os por esses eventos até que
ele chegue aqui onde
você pode alterá-lo. Certo, então, para a cor, vou clicar aqui. E vou
mudar o Alpha. É nisso que estou
interessado em 0,5. Então, é metade do transparente. Então, nosso personagem de jogador
será meio transparente. Ok, então estamos mudando a
cor e o material. Então agora o jogador está
meio transparente e, em seguida,
queremos atrasá-lo. Então, vou colocar um
nó de atraso e quero excluir. Deixe-me pegar este temporizador do
Modo Deus novamente. Eu queria atrasá-lo, digamos dividido
por 16 novamente aqui. E, na verdade, eu
quero dividi-lo por 16. Estes não podem ser os mesmos. Quero dividir isso por oito. É como escrever aqui. Por exemplo, você deseja
executar isso a cada segundo e deseja atrasar
isso em 0,5 segundos. E então você deseja
copiar colar este código porque agora você está transparente. Mas eu quero voltar
ao meu modo normal porque lembre-se de que estamos
fazendo um efeito piscando. Então, indo para o meu modo transparente e depois vou
voltar ao normal. E eu só quero metade do
tempo do que está lá em cima. Então, vamos realmente
mudar isso para oito. Então, vai dizer 1,5
ano dividido por oito. E aqui para o atraso, vou
torná-lo muito mais rápido. Então dividido por 16. Assim, você pode tentar
passar por isso e ver o que funciona para você se
quiser que ele pisque mais rápido. Obviamente, você tem que
aumentar esses números. Se você quiser piscar mais devagar, você precisa reduzir
esses números. Então, vamos
atrasá-lo em 16 aqui, ou o tempo do Modo Deus dividido por 16. E então vamos definir os materiais para o que
eles eram antes. Eu só vou
copiar colar isso e agora podemos simplesmente definir o
material aqui. Não temos que passar por todas essas coisas,
acredito que não. Então, vamos tentar isso. Então, se você acabou de escrever sem iluminação, você tem exatamente como
este chamado mascarado em material brilhante Vamos. Este é o padrão. E a nova cor. Aqui no vermelho está um, verde, um, azul. Isso significa que é uma cor branca e o alfa também é um. Então todos, tudo
aqui é um. E deixe-me compilar e salvar. Então agora vamos verificar se temos tudo e
não conseguimos nada. Então, vamos tentar. Vamos tentar jogar o jogo. E se eu entrar no inimigo, você pode ver que estou realmente
tendo esse efeito piscante. Há um pequeno erro. Na verdade, estou ficando escuro. Não vou gostar das
minhas próprias cores, então vou clicar aqui. E isso é porque
isso não é branco aqui. Então 111, agora é branco
porque se não for branco, sexualmente escuro aqui
e se estiver escuro, seu personagem ficará escuro e você não poderá
ver seus pixels. Então, indo 1.5110 e alfa. Agora vamos tentar novamente. E você pode ver agora
que você pode ver os pixels quando você está piscando,
assim. Ok, então agora está
realmente correto. E em algum momento
nós realmente queremos parar esse efeito piscando. Então o que queremos fazer é aqui, queremos pará-lo depois que
o tempo do Modo Deus acabar. Então, após esses 1,5 segundos, não
estamos
mais no nosso tempo de modo instinto e queremos pará-lo. Então, vamos criar um novo
temporizador para isso e digamos definir um temporizador por eventos. E para este, vou
arrastar deste evento, criar um evento personalizado. Vamos chamá-lo de parar de
danos, os efeitos. E este é muito simples. Só vai gostar
depois de 1,5 segundos. Então conecte o deus mais
tempo a esse temporizador. Então, depois desse Modo Deus, tempo acabou, vamos
tomar esse controle. Então deixe-me clicar com o botão direito aqui, promova isso para uma variável. E vamos chamá-lo de danificar
o identificador de efeitos. E vamos conectar
esses assim. Então agora temos uma
variável disso. Agora, depois que o tempo do
Modo Deus acabar, vamos pegar este temporizador, que é este aqui. Vamos
pegá-lo e dizer
tempo claro
e invalidar ou por Handel, o que significa excluir
este stub, esse cronômetro. Então, depois que o modo deus terminar, vamos parar
esse código aqui. E, obviamente, não
queremos fazer o loop disso. Isso só vai ser executado uma vez. Ok, então vamos compilar e salvar. Então, vamos experimentá-lo.
Vamos clicar em Play e deixe-me correr para o inimigo. Vou piscar. E depois que a
madrinha acabou, eu não estou piscando mais. E se eu entrar
no inimigo
novamente, vai piscar. Vou voltar novamente. Deixe-me ,
na verdade, este é o cliente. Deixe-me voltar ao
jogo como servidor escutado. Quero jogá-lo como
servidor e clientes. Vou
minimizá-lo só para ter certeza que não comprei nada. É sempre bom testar as
coisas no multijogador. Então, como o jogador agora, como cliente, estou piscando e ele está funcionando como servidor. Estou nos piscando trabalhando em ambos. Certo, então está funcionando bem. E, novamente, você pode
mudar para o cliente, garantir que tudo esteja funcionando. Só estou dando uma
olhada nos dois aqui. Então Serena e Luke, se eu entrar nele, estou piscando. Certo, então funciona. Incrível. Então, agora o código funciona. Você sempre pode tentar
organizar isso um pouco, então eu aconselho você a fazê-lo. Deixe-me apenas isso
mais perto. Mas este, podemos arrastá-lo até aqui para que
não seja muito confuso. E com este
sprite, rápido aqui, pode cuidar do nó de redirecionamento, bem
como aqui. Você pode fazer um
nó de redirecionamento como este. E para este, você também pode
fazer uma nota reescrita. Algo assim aqui. Então, parece um pouco
mais organizado. Este eu posso
realmente puxar aqui. E este sprite, você também pode
fazer uma nota de redirecionamento. Então, sempre bom
manter-se organizado. Não posso dizer isso o suficiente
porque em algum momento seu projeto será muito grande e isso será
muito difícil de ler. Então, algo assim. Agora você tem tudo
isso acabado. Ok, então agora este é
o efeito de dano. E agora, para este efeito de dano, agora você pode, agora, para
os efeitos de dano V, você pode transformá-lo em um evento de interface de blueprint. Mas vamos realmente
esperar com isso
na próxima lição porque
vamos adicionar um impulso. Então, vamos passar para
a próxima lição.
80. impulse do jogador: Tudo bem, então como última coisa
para o dano aqui, acho que precisamos adicionar um
impulso ao dano. Então, quando o jogador
atinge o inimigo, quando entro no inimigo, vez de apenas piscar, também
quero
empurrar meu personagem, então isso dá esse impulso. Então, vamos fazer isso. A maneira como você faz isso é tomando o
movimento do personagem e você diz definir impulso e, na verdade,
não definir impulso. Deixe-me procurar,
acho que se chama adicionar impulso aqui, adicionar impulso. E você quer adicionar
esse impulso aqui. Então deixe-me arrastar isso de volta
e adicionar o impulso aqui. Assim mesmo. Então agora, para este anúncio, por esse impulso novamente, temos
que arrastá-lo por
esses eventos aqui,
como antes. E agora você pode definir o impulso. Agora você precisa se
lembrar de verificar essa mudança de velocidade aqui. E vamos compilar e salvar. E agora adicionamos
algum impulso agora, mas esse impulso,
você pode experimentá-lo. Por exemplo, escrevo 500 no z e você pode
ver o que acontece. Você pode tentar clicar em Play, sempre bom testá-lo. Então, o que quer que você esteja
fazendo, experimente. Você pode ver agora quando
eu acertei o inimigo, estou sendo empurrado para cima
no z por 500. Assim, estou adicionando impulso. Certo? Agora podemos fazer algo
divertido aqui pelo impulso. Agora, vou usar o mesmo método que
tenho usado antes. Então deixe-me ver onde eu
realmente usei esse método. Pode ser a base inimiga aqui. Por aqui. Na verdade,
verificamos onde o inimigo está em pé
em comparação com o jogador. E estamos movendo esse inimigo. Na verdade, quero
fazer a mesma coisa. Então, para o jogador, como se
você estivesse vindo por esse caminho, eu quero empurrar meu
jogador para trás. Se eu estiver vindo por aqui, quero empurrar meu jogador para
trás dessa maneira. Então, dependendo de qual
lado do inimigo você está atingindo o inimigo
ou o inimigo atingindo você. Você quer ser empurrado para
trás para esse lado. Assim como a base da ONU, vamos usar
esse mesmo método. Então vou voltar
para minha base de jogadores aqui. E a maneira como podemos fazer isso é que eu realmente vou
mover isso um pouco para baixo, então eu tenho mais espaço aqui. Agora vou conseguir
a localização do jogador. Portanto, obtenha a localização real. Lembre-se de que estamos dentro
do jogador agora. Portanto, obtenha a localização real com uma auto-referência
e os alvos. Vou
quebrá-lo porque estamos interessados
apenas no valor x, porque o valor x
é esse aqui. Só estávamos interessados nisso. Agora preciso da localização para o meu inimigo, e
podemos obtê-lo daqui. Então, não fizemos isso até agora. Assim, podemos fazê-lo
daqui instigado por, lembre-se de que estamos
recebendo dano
do inimigo para que possamos obter o
controlador para o inimigo. Assim, posso clicar com o botão direito do mouse aqui, promover isso para um controlador ou variável e chamá-lo de controlador
inimigo. Vamos conectá-lo agora. E posso clicar aqui e
replicá-lo apenas para garantir que os
clientes possam ver o valor dessa variável. E agora temos o controlador
inimigo. Assim, podemos pegar esse
controlador e C é controlado ****. Então agora temos o
peão do inimigo. E podemos dizer obter a localização do
ator. Então agora temos a
localização do inimigo. E eu quero
quebrá-lo novamente porque
só estou interessado no eixo x. Agora vou me
perguntar aqui, este x
é para o jogador? É menor do que o que
é para o inimigo? Bem, isso significa novamente, é se meus inimigos estão aqui, e se meu jogador
estiver parado aqui, estou basicamente perguntando aos jogadores x valor
menor do que os inimigos. E neste caso, é
falso porque meu personagem, se eu puder acertá-lo e não acertar o, agora não
consigo acertá-lo aqui. Então deixe-me encontrá-lo aqui. Serena. Assim. Agora, para o jogador será falso agora porque os inimigos x são realmente
mais baixos que o meu jogador. Aqui no jogador,
agora estamos perguntando, meu jogador
está
mais baixo que meu inimigo? O que é falso? Então, vamos novamente aqui do impulso
antes de fazermos qualquer coisa, vamos dirigir daqui
e dizer make vector. Assim como antes. Em vez de copiar
colar nosso código, se voltarmos ao
conjunto base inimigo de pente voltado para o nosso código, podemos usar
este select float. Então arraste daqui e
diga Selecionar cargas. Agora, o que você pode fazer é aqui e a
interface que você vê aqui, fizemos a vantagem aqui
porque queríamos o local mais o que
estávamos nos mudando. Nesse caso, você está
apenas aplicando uma força como se estivesse apenas aplicando um
impulso, por exemplo, 500. Então, realmente não nos
importamos com os valores para
x e y e z. Só
queremos que ele seja estático. Então aqui para o z, vamos adicionar
algo como 300. Então, estávamos ganhando um
impulso de 300 para cima. Para o x,
não vamos pegar isso e dizer
mais isso e assim por diante. Porque este é apenas
o impulso estético, por exemplo, algo como 300. É, por exemplo, 300 ou menos 300 dependendo de qual
direção estou vindo. Então agora temos que determinar, vou conectá-lo aqui. Temos que determinar
qual direção é qual. Então, vamos dizer aqui,
estou aqui. Vamos ver, vamos ficar
aqui como o jogador. Agora estou perguntando, meu valor x é
menor que os inimigos? Vou dar uma olhada
clique neste jogador. Você pode ver que é 615. Clique neste inimigo é 710. Então, agora, sim, meu x para o jogador é
menor que os inimigos. Então, na verdade
, será verdade
neste caso quando você
entrar. Então, é verdade agora. Então, estou caminhando
aqui para o inimigo. Na verdade, quero
ser empurrado para trás. E agora meu retrocesso é, na verdade,
apenas menos 300 porque
posso ver empurrar o jogador para trás está indo no menos. Vai diminuir esse número. Então aqui vou
escrever menos 300. E, obviamente, se você estiver
do outro lado, então vai
ficar falso, ou seja, agora
preciso fazer isso aqui. Falso significado aqui. Agora você está indo
em direção ao inimigo. Você está começando a ir
afastado e empurrando
o jogador para longe. Este lado aqui
vai dizer mais 300, o que significa que você vai ser
afastado desta forma aqui. Portanto, não faz sentido aqui. Digamos que um, 100. E agora vai
aplicar menos 300 ou 300 no impulso. Certo? Então vamos organizar isso um
pouco melhor, assim. Ok, então agora temos esse código aplicado e acredito que
não perdemos nada agora. Então, vamos clicar em Play
e ver o que acontece. Agora sou o jogador. Estou
caminhando em direção ao inimigo. Vou ser
empurrado para este lado. Isso está correto.
Agora, vou desse outro lado
aqui.
Isso está correto. Vou ser
empurrado para este lado. Se eu for desse lado, deste
lado, vou ser empurrado para
este lado aqui. Então agora estou sendo empurrado na direção correta agora. Certo? Então agora podemos fazer,
às vezes você pode fazer coisas
engraçadas como
você pode ver aqui. Você pode adicionar um impulso. O inimigo o afasta
enquanto você está pulando. Então, temos muita força. Se você quiser, você pode baixar a força de valor z para 150 talvez, vamos ver o que isso se parece. Talvez seja demais no z. eu posso fazer algo assim. Ou você pode simplesmente, eu
acho que foi engraçado. Talvez seja algo
como 250 em vez de 300 ou conserte
algo assim. Você vê isso às vezes como quando
você já tem velocidade, você pode ser afastado. Se você quiser, você pode definir sua própria velocidade para 0
antes de ser danificado. Isso resolverá o problema, mas acho que isso é,
isso é bom aqui. Agora você pode ver aqui
isso, este porco aqui. Se eu acertar e eu for aqui, às vezes ele incomoda
aqui na rampa. E isso ocorre porque, assim como tentar assistir ao vídeo anterior onde consertamos o caracol para que
ele não latiu por aqui. Nós realmente não fizemos isso
pelo porco porque o porco é, você pode ver que é dinheiro agora. E nós realmente não
consertamos isso para o porco, apenas para o caracol
porque o porco está realmente correndo até aqui. Mas você pode, assim como antes, quando o consertamos
no vídeo anterior, acredito na
primeira seção, são o inimigo. Quando fizemos o inimigo, você pode simplesmente
aumentar a esfera, esfera de
colisão e depois
derrubar o inimigo. E isso resolverá o problema. Ok, então agora temos
esse efeito de empurrão. Estou piscando sempre que
estamos sendo danificados. Então agora estamos prontos, como se
tivéssemos feito todo o efeito de
dano. Deixe-me apenas organizar isso aqui. Deixe-me puxar isso aqui. Então, agora que terminamos
tudo isso, podemos realmente começar a trabalhar
na morte dos jogadores. E depois disso, acredito que
podemos fazer a interface do usuário. Então deixe-me arrastar isso para mais perto, certifique-se de que a
base inimiga também esteja organizada. E acredito que tudo
está bem. Se você quiser, você pode
comentar tudo. E, novamente, você pode
organizar todas essas coisas aqui
dentro das categorias. E acho que tudo
está bem. Podemos puxar isso para baixo assim, fazer com que pareça um
pouco melhor. Não sei,
algo assim. E sim, foi
isso para este vídeo. E vamos salvar tudo e vamos passar
para o próximo.
81. Morte do jogador: Vamos agora trabalhar na morte
dos jogadores. Então, até agora temos feito o efeito de calor e quando
entramos no inimigo, estamos recebendo golpes
e perdendo saúde. Mas não trabalhamos
na morte até agora. Então, isso é o que temos até agora. Vamos agora sair do jogo e
começar com as mortes. Então, temos muitas
coisas para fazer aqui. Então, vamos para a base
de jogadores primeiro. E dentro daqui queremos
fazer um novo evento personalizado. E estes são os efeitos de
dano V. Na verdade, vou
comentar
isso para não ficarmos confusos aqui. E eu vou chamar
isso de danos aos efeitos. Então temos o dano aqui. É aqui que queremos codificar. O principal. Então deixe-me
mover esse efeito de dano para baixo. E este é o ataque. Vou comentar
isso também. Caindo esse saco. Certo. Então, aqui para isso, qualquer dano. Deixe-me dar uma olhada aqui. Então, aqui estamos calculando a saúde e
estamos definindo a nova saúde. E o que queremos fazer aqui, queremos verificar se a
saúde é 0 porque queremos chamar o evento da morte
sempre que for 0. Então, vamos primeiro fazer
o evento da morte. Em que ele deveria consistir? Então deixe-me mover isso para cá. Vamos fazer um novo evento chamado e podemos simplesmente
transformá-lo em um costume. Na verdade, ele só vai
conter um booleano, então já sabemos disso. Então, vamos para a base de jogadores da
interface aqui. E vamos chamá-lo de morte. E podemos adicionar uma entrada de
um booleano chamado B está morto. Então o jogador está morto. E aqui podemos chamar esse evento chamado morto ou morte,
não, não morto. E aqui o que podemos
fazer é chamar eventos personalizados chamados
realmente o que eu descobri. Tão coisas muito legais. Se você clicar com o botão direito do mouse,
em vez de escrever personalizado, poderá escrever pontos T e
nos pontos T certos, você obtém automaticamente
esses eventos personalizados. Então,
atalho muito rápido aqui para fazer os eventos personalizados e vamos entrar nas mortes
do servidor. Então, passando pelo servidor, faça com que ele seja executado no
servidor confiável. E vamos executar o
do servidor aqui em cima. E então temos que fazer com que
o booleano b esteja morto. E vamos passar por aqui. Agora, o que podemos fazer aqui, podemos clicar com o botão direito do mouse e
promover para uma variável. E podemos chamá-lo de ser. É isso, tudo bem, então este, o que eu quero fazer, eu quero, então quando somos atingidos pelo
inimigo e tivermos 0 de vida, queremos definir nossa animação de
morte. E, a propósito,
mudei
assim, até agora no vídeo. Eu te disse antes que precisávamos extrair nossa animação de morte. Mas percebi que era
melhor transformar essa animação de morte
em um único quadro. Então, se você está assistindo isso, provavelmente
terá apenas um quadro. Então, vamos, deixe-me excluir
tudo isso aqui. E deixe-me importar apenas esta animação de morte cerebral aqui que você tem em
seus materiais de curso. E deixe-me aplicar a textura de papel
2D e criar um sprite, chamá-lo de “S death”, e fazer um
flip book rápido daquela chamada morte ou morte. Vamos chamá-lo de
morte em vez de dívida. E os quadros por segundo
serão apenas um. Acho que não
importa para este. Vamos fechá-lo
agora temos isso. Vou ir rápido aqui para Luke e Serena e
o jogador de blueprints. Vou adicioná-los
aqui e a animação da morte, só para
ter certeza, também certifique-se de que você os adicionou aqui quando abrir os padrões completos da classe do editor de
blueprint. E exatamente o que temos
feito até agora. Então aqui em baixo nas informações do jogador. E vou adicionar
minha animação de morte novamente aqui para Serena. Ok, então nós adicionamos isso agora, compilar e salvar tudo. Então, queremos jogar isso, este flip book aqui
sempre que estamos mortos. Então, voltando para a base de
jogadores, agora, sempre que isso for, então novamente, estamos fazendo uma
mudança visual, definindo um flip book. Então precisamos
passar por uma notificação de representante, já que este é o servidor
e esse rock notifica, a única coisa que vai fazer. Vamos primeiro tomar isso morto
e garantir que seja verdade. Então, quando for verdade,
quando você está morto, queremos chamar o estado de movimentos
definidos, ou o jogador que o
movimento estado de morte. Certo, então estamos
chamando a morte e só para ter certeza de que
temos esse conjunto. Então, indo para os
movimentos de agitação e aqui que não
dissemos isso até agora, vou copiar
colar este flip book. E vamos conectar a morte aqui. E se você ainda não editou, em, editá-lo ainda, lembre-se
aqui no, este é um estado de
movimentos de enumeração, e este é o
que fizemos anteriormente. Então, se você quiser editar, se você não tiver editado antes, você pode ir para o estado do movimento de
enumerações, e você pode adicionar morte aqui, e ela aparecerá
na lista aqui. Tudo bem, então para a animação, vamos clicar aqui e temos uma animação de morte para
o, para a estrutura. E vamos clicar nele para
que ele apareça. E podemos
arrastar e adicionar. Se não aparecer,
lembre-se de que você também tem uma seta aqui. Você pode clicar para cima e para baixo. Às vezes eles se escondem. Se você não precisar deles, você pode realmente clicar em Ocultar
pinos não conectados e ocultá-los um
pouco mais limpos. Você pode deixar isso um pouco mais limpo. Parece um pouco confuso
agora, algo assim. Ok, compostos salvos
agora temos isso adicionado. Vamos voltar ao
Event Graph. Então, sempre que o jogador estiver morto, então sempre que isso estiver definido como verdadeiro, ele vai reproduzir
nossa animação de morte apenas para garantir que
o jogador não possa se mover. Vou pegar
o Componente Movimento de Personagens e dizer “stop movement” imediatamente. Eu só queria ter certeza de que o personagem não está
se movendo, assim. Ok, então agora que está conectado, vamos também garantir
que o jogador não possa se mover sempre
que estiver morto. Então, indo para o Event Graph, eu vou primeiro para o meu, este movimento para a direita e para a esquerda, levando isso está morto. E novamente, assim como antes de
escrever um BOOLEANO NÃO. E a partir daqui, basta
clicar neste pino Adicionar, então você pode adicionar mais deles. Agora pode realmente
conectar isso também. Portanto, sempre que o jogador, se o jogador estiver subindo, você não pode se mover para a esquerda e para a direita. Quando o jogador está atacando, obviamente você não pode
se mover para a esquerda e para a direita. E também quando você está morto, você não pode se mover para a esquerda
e para a direita é que temos
que adicioná-lo a coisas que não queremos que
o jogador use. Então, por exemplo, aqui
também aglomerando para cima e para baixo. E podemos dizer e
aqui e booleano aqui. E podemos adicionar esses ataques e conectá-lo aqui em vez disso. Então, precisamos estruturar
isso um pouco. Agora está ficando um pouco
confuso, mas tudo bem. Sempre podemos limpá-lo em breve. Deixe-me copiar colar. Isso também está morto, e podemos editar para o salto. Então aqui para o salto, você
não pode pular se estiver morto. E a última coisa
é o ataque. Então o ataque está aqui em baixo. Você não pode atacar
se estiver morto. Certo? Assim mesmo. Só para ter certeza de que não
temos nenhum bug. Então, verificamos com os
booleanos assim. Ok, então agora você
não pode atacar, ok, então temos isso morto e o que deve acontecer
sempre que você estiver morto? Vamos fazer isso mais tarde. Então, quando queremos
chamar esse evento aqui? Queremos chamá-lo
sempre que a saúde for 0. Então, qualquer dano aqui, o jogador está ficando danificado. E estamos recalculando
a saúde aqui. Então agora temos a saúde
atualizada aqui. Então, vamos pegar isso
e dizer pausa. E agora temos essa saúde. E posso dizer igual, isso é igual a 0. O que deveria acontecer? Vou
exibir os outros pinos. Então, o que deve acontecer
sempre que a saúde for 0, podemos fazer uma filial aqui. Então, quando a saúde for 0,
queremos chamar nosso evento de morte. Então, escrevendo a morte, chamando esse evento aqui e
definindo-o como verdadeiro. Ok, então agora isso é verdade. Sempre que for falso, queremos fazer outra coisa, o que significa que não estamos mortos, acabamos de ser atingidos. Então, na verdade, vou
remover isso
daqui porque provavelmente
precisamos adicioná-lo aqui. Não queremos dar, não
queremos remover
o Modo Deus e também temos esse atraso antes de
verificarmos se o jogador
está morto ou não. Porque lembre-se, se você
fizer isso, é assim, então você vai
atrasar o código. Então você está calculando
a saúde, você vai atrasar o código. E se você estiver morto,
você vai morrer depois desse atraso, o que não faz sentido
porque você já está morto, mas há atrasos na sua morte
e isso não faz sentido. Então, vamos realmente olhar, clique em Control X para cortá-lo e
colá-lo aqui. Estamos apenas calculando
a saúde assim. E agora aqui em baixo
podemos fazer esse código aqui. Se sua saúde
não for igual a 0, vamos atrasá-la aqui
e remover o modo deus. Ou se você já está morto. Então, se a saúde
for 0, então
vamos direto para
o evento da morte. E ainda queremos manter o Modo
Deus como verdadeiro aqui. Porque quando você está
morto, não
queremos que o inimigo o atinja. Então, ainda estou mantendo
o modo deus ativado. Ok, então vamos ver aqui em baixo. Então, a profundidade vai se relacionar. Vamos realmente jogar o
jogo e ver o que acontece. Então deixe-me clicar em Play. E agora podemos colocar esse personagem, você está
sendo danificado. Na verdade, deixe-me colocar a saúde do meu
personagem para que eu possa testar isso e não
preciso ser atingido muitas vezes. Então deixe-me verificar o que
eu coloquei o dano. Lembre-se no inimigo, para o caracol e o porco, você adicionou dano. E deixe-me verificar
qual foi o dano. O dano para o caracol
aqui na informação do animal. O dano foi dez
e foram 20, creio
eu, para o porco. Então deixe-me colocar minha
saúde para o jogador. Aqui nas informações do jogador. Deixe-me colocá-lo para 20. Então eu recebo um golpe pelo porco, mas recebo dois golpes pelo caracol. Então, clicando em Play para que eu
possa testar isso rapidamente. Agora podemos ver. Eu morri. E, na verdade, meu túmulo aqui está
piscando quando estou morto. Eu não gosto disso,
então está piscando aqui. E eu realmente não
gosto disso. Então, temos que reestruturar
o que matou um pouco. Porque quando ficamos
danificados aqui no, qualquer dano, esta é a base inimiga. Aqui na base de jogadores. Estamos recebendo um impulso e estamos recebendo
esse efeito piscando. Na verdade, quero fazer isso
sempre que não estiver morto. Porque quando estou morto,
não quero piscar. Não quero que meu túmulo pisque. Então, na verdade, temos que
separá-lo porque eu realmente
gostei do impulso aqui. Gosto do impulso, mas não
gosto de piscar. Então, temos que separá-lo. Então, vamos separar esse efeito. Então, aqui nos efeitos de dano, vou fazer um evento personalizado, e este será um impulso. Então, na verdade, vou
transformá-los em Interfaces de Blueprint. Então, vou para a
interface e a base de jogadores aqui. Vamos fazer um agora
chamado impulso de dano. E o outro que tínhamos. Então, vamos voltar. O outro é
danificado por efeitos e leva a cor e o
material como entradas. Então deixe-me fazer um novo
chamado danificar os efeitos. Certo, então o impulso
leva um vetor. Então aqui embaixo, vetor, e eu vou
chamá-lo de impulso. E o outro, o dano
através de efeitos toma uma cor. E você pode ver aqui, se
você clicar na cor, você pode ver que tipo
de variável ela é. O material é interface
material e este é uma cor linear. Assim, você pode voltar
para a interface e escolher aqui material. E foi chamado de material. Eu não acho que haja algo chamado interface
material. Na verdade, era uma interface de
material, então temos que selecionar
esta selecionada aqui. E a outra era
uma cor linear aqui, e esta é uma cor linear. Ok, então só chamando
essa única cor. E agora vai ser,
novamente, eu vou excluir isso,
Compilar e Salvar, vou voltar a ganhar dinheiro, e eu tenho que excluí-lo talvez. Então, vamos chamá-lo de cor da
camada em vez disso. E este, material do jogador. Ok, então Compile e salve. E agora vamos voltar
e chamá-lo aqui. Chame isso de dano,
os efeitos aqui. E o material entra aqui, o alerta linear entra aqui e o impulso
foi separado. Então, vou
clicar no servidor um e removê-los de pulso, ele o removerá daqui. E este multicast, vou remover
o impulso
também porque
não o queremos aqui. Vou remover esse impulso daqui e
colá-lo aqui em cima. Em vez disso. Vou fazer um novo
evento que lembre que
acabamos de fazer o impulso de dano. Então, vou chamar esse evento de impulso de
dano. Novamente, passe-o pelo servidor como o impulso de dano de Harvey. E este
aqui terá esse vetor. Vou
conectá-lo assim e conectá-lo aqui
chamado servidor-1. E vamos executá-lo
pelo servidor primeiro aqui em baixo. E vamos chamar o dano
do servidor nas pesquisas. Ok, então agora eles estão conectados. Agora nós os separamos. E deixe-me reconectar esse multicast antes
que eu esqueça este, na verdade, este, estou
fazendo errado aqui. Precisamos adicionar um multicast. Então, novamente, em um impulso de
dano multicast. E novamente precisamos de um
vetor aqui embaixo. E vamos executá-lo por meio de
um multicast e confiável. E temos que executar o multicast aqui através deste servidor. Então, este aqui. Ok, então agora temos essa edição. Vou fazer
um pouco mais de espaço. Então, temos espaço para esse evento. Assim mesmo. E agora vamos ver se estamos
perdendo alguma coisa. E eu acho que isso está
parecendo bom até agora podemos mover isso um
pouco mais perto, não faz sentido
tê-lo tão longe. Assim. Tudo bem, então agora temos o impulso
danificado separado. Então, o que podemos fazer aqui em cima, agora, vai
dar um erro porque realmente não
temos
um impulso aqui. Então, vamos descer
e dar uma olhada. Então nós danificamos o impulso, impulso, os efeitos, ok? Este está dando um erro. Vamos excluí-lo. Não sei por que não está excluindo
o impulso. Então, vamos procurar
danos. Impulso. Quero que meu impulso esteja aqui. Pelo meu impulso, quero que ele
esteja aqui. Então, isso está correto. Vamos apenas conectá-lo. Mas quero minha cor
e não estar aqui, mas quero tocar minha cor
sempre que não estiver morto. Então eu não quero o efeito
piscando. Eu não quero tocar meu
efeito piscando aqui em cima quando eu estiver morto. Então, vamos reproduzir o
efeito piscando aqui em vez disso. E foi chamado de efeitos UV de
danos aqui. E para o dano
via efeitos novamente, você precisa selecionar um material, ou removê-los aqui. Então, novamente, clique em Configurações, mostre o conteúdo do desenvolvedor,
mostre o conteúdo do mecanismo e mostre o conteúdo do plug-in. E agora você pode
selecionar o material e foi chamado Sharon, sluice e C são translúcidos e descem e
encontrá-lo aqui material de sprite translúcido e
não iluminado e
mudar a cor do jogador para 1,5110 no alfa. Rápido, ok, então agora
temos como antes. E se eu descer e
dar uma olhada aqui, então o material está definido para o
que dissemos e então vamos colocá-lo de
volta para a mesquita apagada, que era nossa cor normal. Ok, então isso parece bom. Agora vamos realmente testar e
ver se isso é bom agora. Então, vamos jogar. Agora estamos sendo atingidos. Isso é bom. Eu não gosto não gostar dos efeitos
piscando, então isso é bom agora. E vou experimentá-lo
como servidor também. Então Platão como servidor de escuta. E só para ter certeza. Ok, então agora somos um tubo e
isso parece ótimo. Então isso é tudo o que tínhamos que
fazer para a morte do jogador. E no próximo, vamos
criar o menu I, para possamos realmente ter
alguma interface de usuário e atualizar nossa saúde.
82. Como criar a interface principal: Vamos agora projetar a interface do usuário
principal para o jogo. Então, até agora não
temos uma interface do usuário no jogo. Então, vamos para a interface do usuário. E aqui Vamos
clicar com o botão direito do mouse e ir para Interface
do usuário e criar
um blueprint de widget. E selecione este,
widget, widget do usuário. E vamos chamar isso de um WB feito. Portanto, esta é a interface principal. Clicando duas vezes nele aqui. Primeiro, novamente, temos que procurar por Canvas e precisamos adicionar um Canvas antes de fazermos
qualquer coisa dentro daqui, o que eu quero criar
agora é que
quero criar nossa Barra de
Saúde aqui embaixo. Então, o principal resultado
que estamos
procurando é realmente fazer isso aqui. Portanto, é sempre bom visualizar e saber o que você está
fazendo antes de fazê-lo. Então, quando olho para isso, temos uma sobreposição porque
temos barras de saúde em
cima de um fundo. Isso significa que temos uma sobreposição
e depois temos duas barras. Então, o Health Bar e a barra de experiência
uns sobre os outros. E posso dizer a mim mesmo, esta é uma caixa vertical. Lembre-se de que usamos a caixa vertical e isso porque eles
estão se alinhando verticalmente. E sim, vamos tentar dois. Vamos tentar começar aqui. Então, primeiro precisamos de uma
sobreposição porque precisamos um fundo com
barra de saúde em cima dela. Então, quando você adicionou,
vai até aqui, deixe-me apenas, você pode redesenhar
o ponto de ancoragem aqui. Lembre-se de fazer isso. Então, na sobreposição, coloque o ponto
de ancoragem abaixo aqui, porque é aqui
que queremos. E deixe-me arrastá-lo para baixo por enquanto, aqui em algum lugar. Então, aqui queremos adicionar primeiro o plano de fundo e o
plano de fundo é apenas uma imagem. Então, procure por um editor de imagens
em cima da sobreposição. Clique nessa imagem
e vamos mudar essa imagem para que
você possa ver que eu recebo
muitas coisas estranhas e isso é porque ativamos todos aqueles na lição
anterior. Portanto, oculte o conteúdo do
plug-in show, oculte o conteúdo do mecanismo de exibição e oculte mostrar conteúdo do desenvolvedor. Vamos voltar aqui e clicar
nessas imagens para que possamos
ver nossas próprias apenas. E vamos selecionar o
botão chamado, preto quadrado plano. Este aqui. Você pode preencher a coisa
toda aqui, então uma linha horizontal
e verticalmente. Então, ele preenche a coisa toda. Vou duplicá-lo. Controle D para duplicar, ou podemos clicar com o botão direito do mouse e clicar em Duplicar e
selecionar esta imagem. Agora, agora eu quero mudar este para os apartamentos quadrados
azuis do botão. E eu quero fazer
o y para cinco, na verdade apenas cinco, você não
pode ver nada mudado. E isso ocorre porque temos esse alinhamento
vertical selecionado. Vou selecionar
esse alinhamento superior. Então, estou apenas decorando
meu fundo. Posso remover todas as
linhas tracejadas clicando aqui. Então, estou apenas decorando
um pouco. Vou clicar em Control
D na imagem aqui em cima. E vou
alinhá-lo na parte inferior. Então agora eu tenho esse design
incrível. E o que queremos
fazer agora é ter sorte. Se eu der uma olhada nisso antes. Precisamos agora de uma
caixa vertical onde temos essas duas barras de progresso umas
sobre as outras. Então deixe-me
procurar uma caixa vertical, adicione-a à sobreposição aqui. Agora, vamos
procurar a barra de progresso. Então, barra de progresso aqui, você pode arrastá-la para
a caixa vertical. E o que você pode
fazer agora é que você pode, agora você pode ver, não se
pode ver muito porque você tem que
adicioná-lo na verdade. Então, no estilo da barra de progresso e eu
acho que para a caixa vertical, deixe-me realmente alinhá-la
aqui no centro primeiro,
estes são os bugs verticais
Clicando na barra de progresso. Vou alterar a imagem
de fundo. Deixe-me mudá-lo para
este, quadrado preto, plano
escuro, então é um pouco mais
escuro do que essa cor aqui. Então o que eu quero fazer
é que eu realmente quero alinhar minha caixa vertical aqui
todo o caminho horizontalmente. Então minha barra de progresso está
alinhada por todo o caminho. E o que eu quero que você faça agora é ir aqui para a direita e para a esquerda. Então aqui à direita. Então, estou
empurrando-o da direita, estou empurrando-o. Portanto, não está aqui nas bordas. Vou preenchê-lo com
talvez 203030 talvez, e para a esquerda 30 também. E podemos tentar adicionar, vamos voltar aqui
para a barra de progresso. Vamos para a imagem da conta e a
imagem do letreiro. E vamos adicionar
um vermelho para a saúde. Então esta tecla vermelha 14
também, uma vermelha. Então agora você pode ver
que é muito maior. E se você aumentar
essa porcentagem, você pode ver aqui que essa
porcentagem está preenchendo, mas não é realmente lido
como o que escolhemos. E isso ocorre porque você tem que descer
a barra de progresso e a cor de preenchimento e opacidade por algum motivo, não
tenho ideia do porquê de ser azul. Então você pode fazê-lo. Aqui, se você acabou de escrever 111 ou você pode simplesmente aumentar
e diminuir esses controles deslizantes, basta torná-lo branco aqui. E se for branco, você pode ver a verdadeira do botão ou a cor da
barra de progresso aparecerá. Portanto, esta é a barra de progresso. Muito legal. E agora está se
alinhando em lote aqui. Então, caixa vertical,
estamos alinhando aqui. E para a barra de progresso, acho que isso é bom por enquanto. Sempre podemos alterar o tamanho
se for muito grande mais tarde. Então, até agora está parecendo bom. No entanto, estamos realmente precisando uma sobreposição porque lembre-se, temos o texto em
cima da barra aqui,
então, na verdade, precisamos de um texto aqui,
então realmente precisávamos de
uma sobreposição primeiro. Então, vamos arrastar uma
sobreposição dentro
dessa caixa vertical e colocar essa barra de progresso
na sobreposição. Assim, também podemos adicionar texto sobre ele aqui
e a sobreposição. Portanto, temos barra de progresso
e um texto em cima dela. No texto, vou
alinhá-lo no meio. E vamos chamá-lo de 100%. Então, por exemplo,
essa é a saúde. Vou mudar o texto para, vamos tentar semi negrito. Semi negrito, na verdade em negrito, talvez Source Sans Pro Bold. E eu acho que vamos realmente
ir com o preto. Preto. E este do tamanho, vou reduzi-lo para 14. Texto tão pequeno aqui. Vou dar um esboço. Então, aqui nas configurações do esboço, então vou colocá-lo em um. Então, ele tem um esboço. Se você quiser, você também
pode adicionar sombras. Então, primeiro aqui
na cor da sombra, você tem que ir para o Alfa. E se você escrever uma, as sombras aparecem completamente. E se você escrever 0, deixe-me levantar seus 0,35. Significa trinta e cinco
por cento de sombra. E eu vou mover
o deslocamento de sombra dois para dois, então está
um pouco mais longe. Você pode ver se você adiciona mais, ele vai ficar um pouco
mais longe do texto. Então 22 é bom para mim. Ok, então o que você pode fazer agora, você sempre pode diminuir o tamanho diminuindo
este y aqui. Acho que é muito grande. Então diminuindo o
y. Então algo assim, talvez como 42. Sim, acho que isso é
bom para você também. Também vou copiar
colar isso aqui em cima. E agora parece bom. Então, este é o nosso Health Bar. Agora, o que podemos fazer
é compilar e salvar, e podemos duplicá-lo. Assim, podemos clicar na sobreposição. Podemos clicar em Control D.
Agora duplicamos. E deixe-me adicionar um espaçador entre esses dois espaçadores
entre as sobreposições. E esse espaçador é
talvez dez e o y. Então há um pouco de
espaço entre eles. Talvez 1515 seja bom. Então este é o bar experiente. Então, em vez de vermelho, vamos
mudá-lo para amarelo ou verde. Esse geralmente é o
padrão de experiência. E vamos mudá-lo de volta aqui sob o Health Bar, era 42. Então deixe-me copiar isso
e colá-lo aqui por 24242, assim. E para o bar experiente. E talvez diga algo como 23 experiência que você tem de 150, o que
é necessário para subir de nível. Então, algo assim. Então, agora temos essa interface do usuário disse. E, novamente, lembre-se de
clicar na sobreposição, mudar sua âncora para aqui embaixo. E você pode tentar ajustar
essa posição no x e y. Vou
habilitar as linhas tracejadas que eu possa realmente ver
onde ela está colocada. Não sei,
algo assim não importa por enquanto. Vamos compilar e economizar
para a resposta. Queremos fazer algo
assim onde diz que você foi morto e depois diz
o que você foi morto. E então você pressiona
OK para responder. Então, novamente, precisamos uma sobreposição para colocar algum
texto em cima dele. E precisamos de um botão
com uma sobreposição porque temos um botão
e um texto em cima dele. Então, vamos voltar aqui e
vamos adicionar uma sobreposição primeiro. Procurando por sobreposição,
vou minimizar isso aqui. Vou
adicioná-lo à tela. Esta sobreposição será
colocada no meio aqui, meio, aqui em cima. E vou escrever
0 e a posição. E você pode ver que
não se alinha no meio o que ele alinha aqui neste canto. Então você pode ajustar esse
alinhamento aqui, posso ver que é 0,5 se você quiser alinhá-lo
perfeitamente no meio. E talvez para a posição y, eu posso dizer 100s,
então está aqui embaixo. Então, agora o que você pode fazer aqui
na sobreposição, novamente, você pode adicionar uma imagem
na sobreposição. Você pode preenchê-lo horizontal e
verticalmente e adicionar este plano quadrado
preto. E, novamente, você pode clicar em Control D para copiá-lo aqui. E então você pode mudá-lo para este e
alinhá-lo verticalmente. Você pode alinhá-lo na parte superior. E vou mudar
o tamanho para cinco. Aqui. Mais uma vez, estamos fazendo esse design. Clique em Control D e
alinhe-o com a parte inferior agora. Então, temos este de novo. E vou remover
essas linhas tracejadas. O que você pode fazer agora é adicionar texto em cima dele, e ele está dentro
de uma caixa vertical. Então, adicionando uma
caixa vertical à sobreposição. E agora podemos adicionar dois textos. Então, este texto. E o segundo, o primeiro vai dizer, você foi morto por. Então ele vai dizer pelo
que, por exemplo, caracol. E o outro
vai dizer, pressione Ok para responder assim. No primeiro texto aqui, vou mudar a
fonte para semi negrito aqui. E o tamanho será 12. E então eu vou alinhá-lo aqui para o meio,
na verdade, na mesma coisa com este, vou
alinhá-lo ao meio. E para este segundo,
vou mudar
a fonte para negrito. Vou mudar
o tamanho para 18. O primeiro, eu quero
adicionar uma sombra também. Então eu vou aqui
e para a sombra agora, se você quiser fazer a mesma
coisa para ambos,
você pode selecionar
um, segurar Control, selecionar a próxima, e você pode simplesmente fazer a
mesma edição para ambos. Então aqui na
cor da sombra e no Alpha 0,35. E para o deslocamento da sombra, vou dizer para dois. Então, é um pouco mais o que
você pode ver, há um efeito de sombra sutil
agora em ambos os textos. Agora pode ver que eles não estão
realmente no meio, mesmo que você
os alinhe ao meio aqui. E isso ocorre porque, lembre-se de que eles estão dentro
de uma caixa vertical. Portanto, a caixa vertical precisa
estar no meio também. Clicar aqui e colocar essa caixa vertical no
meio resolverá o problema. Agora podemos fazer
isso um pouco maior para não ter esse espaço
condensado de contexto. Então, tente
redimensioná-lo como quiser. Isso depende de você. Isso realmente não importa. Algo assim.
Talvez pareça bom. E deixe-me
redimensioná-lo assim. E agora você pode adicionar um
espaçador entre esses dois. Acho que eles estão muito próximos. Então, deixe-me adicionar um espaçador
entre esses dois textos. E o espaçador pode ser feito
ou algo como cinco. Então, há um pouco de
espaço entre eles. Então agora o que precisamos, na verdade, precisamos desse botão aqui. Então você pode ver que precisamos
desse botão ok. Este botão ok
está realmente em um, precisamos adicionar uma
caixa vertical porque temos este ano e verticalmente
temos um botão. Então, na verdade, precisávamos colocar toda
a sobreposição
em uma caixa vertical. Então, a caixa vertical
coloque-o aqui e você pode arrastar essa
sobreposição para dentro dela. Apenas certifique-se de que
esta caixa vertical, você não a
colocou nessa sobreposição. Esse erro pode acontecer. Apenas minimize isso e
certifique-se de tê-los aqui
onde eles deveriam estar. Vamos arrastar esta caixa
vertical agora. Agora temos uma caixa vertical. Podemos fazer as
âncoras mais tarde. Vamos adicionar aqui na
caixa vertical, temos essa sobreposição. Vamos adicionar outra sobreposição
Com o botão e o texto. Então, vamos procurar o botão aqui, e vamos procurar texto. Aqui. Temos o botão e
o texto do botão. Vamos adicionar um botão azul, então este chamado
Blue Square flat. E, novamente, você pode clicar com o botão direito
do
mouse em Shift enquanto clica com o botão direito do mouse em copiar e
segurar Shift enquanto clica com o Ou você pode
clicar com o botão direito do mouse
e clicar em copiar e você pode ver a
ligação aqui também. Eu serei Colar. Vou fazer a
mesma coisa aqui. Em vez disso, altere essa
caixa arredondada em uma caixa. Direita, segure Shift,
clique com o botão direito do mouse em CoBie, segure Shift, clique com o botão esquerdo E para essa margem, 0,5. E eu estou escrevendo 0,5 para que
ele possa ser colocado corretamente. Então, vou
clicar com o botão direito do mouse aqui, copiar colar esta margem. E para essa cor de tonalidade,
para a normal, vou movê-la para o
branco para que não haja tonalidade. E para a Harvard, vou
colocá-lo um pouco aqui. E para o peito, vou colocá-lo um pouco
mais escuro do que o pairado. Este é um deprimido.
Agora, eu acho que isso é bom. Ok, então nós temos isso e para a iluminação,
então, para o botão, na verdade esta sobreposição, toda
a sobreposição,
é, está
alinhado corretamente agora. Então, vá para este botão, alinhando-o aqui,
preenchendo-o horizontalmente. E que tipos de pellet
verticalmente, tudo bem. Para este texto, vamos
alinhá-lo no meio. Vou mudar
essa fonte para negrito e alterando o tamanho para 14. E vou
adicionar uma sombra novamente, 0,35 e colocar a
sombra depois de 222. Então, temos a mesma consistência, o mesmo design, e
podemos escrever bem aqui. Portanto, é preciso haver um
espaço entre o botão. Então, vamos fazer um espaçador. Vamos adicionar um espaçador entre
essas duas sobreposições. Podemos fazer talvez como 20 ou 15. Acho que 15 é bom. Agora você pode ver que o botão é grande e isso ocorre porque você precisa clicar
na caixa vertical. Agora, lembre-se que você
fez isso para preencher. Então aqui você fez com que ele
se sinta realmente também. Você vê aqui que fizemos sentir
horizontal e verticalmente, o que significa que se clicarmos
na caixa vertical e
redimensioná-la, ela deve redimensionar. Mas esse não é realmente
o caso agora. E isso ocorre porque temos
que clicar em preencher aqui. Então, agora, ele está definido como automático. Na verdade, temos
que configurá-lo para preencher, então ele vai preencher todo
o espaço. Eu gostaria de fazer a dinâmica da minha interface assim, para que eu possa
simplesmente,
em vez de popular, em vez de fazer o
re-dimensionamento aqui nas imagens, eu gosto de
preenchê-la para poder clicar
no elemento pai do pai e eu posso
redimensioná-lo como eu quiser, e será
muito mais fácil para você. Certo? Isso, na verdade,
isso também é bom, como avançado, porque
mais tarde, quando você tem vários jogadores e
nomes e assim por diante, eles podem ser mais longos do que a sua interface do usuário. Portanto, isso se estenderá
automaticamente, por mais tempo que o
nome seja, e assim por diante. Portanto, esta é realmente uma prática
muito, muito boa. Então deixe-me
algo assim. E eu acho, sim,
acho que há bom. Então, vamos agora uma linha está corretamente Clique
na caixa vertical. Você pode ver que a
âncora está aqui. Clique na âncora,
colocando-a no meio superior e escrevendo 00 na posição. Mais uma vez, vou alinhar aqui 0,5 e escrever 100 e o y. Então ele empurra para baixo aqui. Então é isso que
parece até agora. Vamos compilar e salvar. Então, agora criamos a interface do usuário
e acho que ela parece boa. Vamos salvar tudo, compilar e podemos adicionar mais coisas
se precisarmos de mais coisas. Mas, por enquanto,
acho que isso é bom. Vamos passar para o próximo vídeo.
83. Como adicionar a IU principal à porta de vista: Agora vamos adicionar a interface do usuário ao controlador
do player. E lembre-se, a interface do usuário
é do lado do cliente e fazemos isso
no controlador. Então, dentro do controlador
do player, fazemos toda a interface do usuário. E é do lado do cliente, o que significa que é só
você como jogador. Você só verá sua própria interface do usuário. Outro jogador recebe
seus próprios olhos novos. Portanto, não é como se você
não estivesse compartilhando, você está apenas
olhando para o seu próprio. Isso é o que o lado do cliente significa como executar
no cliente proprietário, ele só é executado no seu PC, no seu, na tela. E não faz
sentido compartilhar. Uma interface do usuário realmente não faz sentido. Você só pode ver
sua própria saúde. E se você quiser que os outros vejam
a saúde dela, você sempre pode compartilhar essas
informações, se necessário. Então agora, aqui e o controlador
do jogador, o que fizemos antes foi
inicializamos o widget, que significa aqui na seleção de
personagens. Então, sempre que clicamos em jogar, a seleção de personagens aparece. Quer fazer agora também. Não é como se não quiséssemos adicionar o menu I à janela de exibição diretamente porque temos a tela de seleção de
caracteres. Mas o que queremos fazer é adicionar interface
do usuário principal após a tela de seleção de
caracteres. Mas queremos inicializar
o widget também. Então, vamos primeiro pegar
este novamente, criar widgets. E novamente, fazemos isso no cliente que executa
com o cliente proprietário. Aqui, vamos selecionar o menu que eu acabaria de fazer
como salvamento composto. E vamos clicar com o botão direito do mouse
promovido para uma variável, vamos chamá-la de WB made. Isso é tudo o que
tínhamos que fazer aqui. Não queremos adicioná-lo
à viewport porque,
se você fizer
isso, ela também adicionará a interface
do usuário principal à
janela de exibição. Você pode ver que ele
adicionou a interface do usuário principal. Nós realmente não queremos fazer isso. Então, vamos remover isso. E se você não adicionar à janela de exibição, poderá vê-lo
editá-lo como uma variável, mas você não disse
ao mecanismo que realmente o
deseja na janela de exibição. E não queremos isso sob
vista da porta agora. Mas queremos fazer é
sempre que você
clicar ou selecionar um
dos caracteres, ele adicionará a interface do usuário
principal à janela de exibição. Então, o que
podemos fazer é fechar isso. Lembre-se aqui na
tela de seleção de
personagens no gráfico, nós projetamos esses
dois eventos quando você clica em um dos personagens. Então, vamos realmente fazer isso aqui. Vamos, já temos
o controlador do jogador. Então, podemos simplesmente chamar esse
WB principal que acabamos de fazer. E aqui você pode procurar por
x e nossa pesquisa para a qual você pode escrever agora
estamos removendo a tela de seleção de caracteres quando selecionamos o personagem, mas queremos adicionar isso
à janela de exibição também. Então, queremos adicionar nosso
personagem, nossa interface principal. Vou copiar
colar isso aqui embaixo. Então, agora, se selecionarmos
Luke ou Serena, vamos adicionar
isso às viewports. Eu só vou
fazer isso virar, fazer com que isso pareça um
pouco melhor. Algo assim. Ok, então
agora vamos adicioná-lo. Então, sempre que clico em jogar, selecionarei loop, por exemplo. Você pode ver que agora tenho
minha interface do usuário na tela. Novamente, eu realmente não
quero que isso esteja disponível sempre que eu apenas gerei porque esta é a mensagem de morte
ou mensagem de resposta. Então, o que podemos fazer é
ir para a interface do usuário principal. Podemos selecioná-lo aqui, selecionar
este pai, a caixa vertical. Você pode ver que este é o único. E o que queremos fazer
com este aqui, aqui embaixo e a visibilidade. Vamos mudar a
visibilidade para oculto. Não queremos
vê-lo imediatamente. Então, vamos esconder isso
assim como essa barra de progresso. Então, a saúde está em
100% para começar. Então, na verdade, estou aumentando a porcentagem padrão para 100. E eles experimentaram que
um está na parte inferior, como a experiência 0
quando você começa. Quanto ao número, isso é
100 por cento para começar, e para este, é 0 de alguma coisa. Eu ainda não sei, então
não vamos adicionar nada aqui. Agora, quando você clica em Jogar,
agora você pode ver que está correto. Agora, ele não exibe
essa mensagem aqui em cima. E podemos ver nossa saúde
e nossa experiência aqui. Vou redimensionar
isso um pouco. Acho que isso é muito grande. Algo assim. Meu TOC está sendo acionado. Eu realmente não tenho TOC, mas talvez eu tenha
algo assim. Acho que é muito
melhor. Parece bom. Podemos mover isso um
pouco para cá no y. algo assim.
Certo, parece perfeito. Agora temos a saúde
e a experiência parece interessante. E depois temos a morte. De qualquer forma, eu realmente
quero que apareça sempre que morrermos. E faremos isso quando estivermos trabalhando com
o jogador responder. Então isso é o que temos até agora. E a próxima coisa que podemos fazer
é atualizar essa barra de saúde. É muito fácil porque
já tínhamos essa lógica. Então, vamos passar
para o próximo vídeo.
84. Como atualizar a barra de saúde: Então, para atualizar a barra de integridade, vamos voltar para a interface do usuário
e ir para a interface do usuário principal. Esta é a Barra de Integridade que
atualizaremos aqui, portanto, para que a barra de
progresso facilite. Então, aqui no gráfico para codificar, você pode ver que tudo isso
tem nomes de lixo. Então, vamos mudar esse nome da barra de
progresso para Praga. Normalmente chamo isso
como uma barra de progresso. E, em seguida, saúde. Então, sabemos que é a
barra de progresso para a saúde. E este, vou
mudar o nome para TXT para texto e saúde. Vamos mudá-lo para a experiência de
Praga. Usaremos isso
mais tarde, não agora. E este chamado
TXT experience, Compile e Save para
este botão aqui. Vamos também alterar o nome
enquanto estamos o botão de edição. E só, ok,
este aqui
em cima, também
queremos mudar mais tarde também
queremos mudar mais tarde porque vamos
mudar o nome. Vou chamá-lo de TXT. Morto por, vamos
chamá-lo de morto por compostos. Salvar. Agora você pode ver aqui para este texto que
também queremos configurá-lo, mas se você clicar
nesta barra de progresso, por exemplo, e
ir
para o gráfico, você pode ver que a
barra de progresso é uma variável aqui. Mas também queremos
alterar esse texto aqui. Mas se você clicar no gráfico, não
haverá texto. E isso ocorre porque
os textos por padrão não são variáveis e você
tem que levar esta aqui chamada variável S, e então ela aparecerá
aqui no gráfico. No entanto, existem
muitas imagens. imagens são por padrão variáveis, mas às vezes você
precisa limpar seu projeto para que você precise clicar nessa
imagem, por exemplo, e removê-la como uma
variável porque você
realmente não precisa para modificar
isso no jogo. Também para o plano de fundo aqui, posso removê-lo se quiser, posso limpar isso também. Então, remover esse plano de fundo
é uma variável. Basta remover todos esses aqui. Esta compilação e salvamento. E você pode ver que seu projeto
é muito mais limpo se você tiver
apenas as variáveis
com as quais trabalhará. Então, deixe-me excluir
esses eventos padrão e vamos fazer um chamado, Vamos criar um evento personalizado e vamos chamá-lo de atualização de integridade. Então, o que eu costumo fazer para a interface do usuário, nunca crio Interfaces de
Blueprint. Quero dizer, você pode, você pode simplesmente entrar e criar um para ele. Mas isso realmente não
faz sentido porque você geralmente não tem muitos eventos. E você terá que fazer
muitas interfaces. Como se você tivesse que fazer
um para cada interface do usuário. E eu não quero fazer isso, então geralmente faço eventos
personalizados para eles. Então, aqui para a
integridade da atualização, o que queremos fazer, queremos pegar a barra de
progresso para a saúde e dizer a porcentagem
definida. Essa é a coisa que
queremos atualizar. E você pode
ver como é chamado. Se você clicar na
barra de progresso e descer aqui, você pode ver que ela é chamada de porcentagem. Então, se você apenas
pesquisar, procurar por porcentagem, se você
não sabe como é chamado, você verá este aqui. Portanto, queremos definir
a porcentagem, mas também queremos
atualizar esse texto chamado health, também chamado setText. Então, queremos definir
esse texto também. Então, para essa porcentagem, vou passar por esse evento e podemos
chamá-lo novamente de outro lugar. Deixe-me apenas chamá-lo
por cento em vez de pessoalmente para esses textos, será apenas uma porcentagem do que quer que
esteja passando por isso. E você verá o que
quero dizer mais tarde. Mas, por enquanto, vamos arrastar
daqui e dizer presente. E para o carro alegórico você tem
algo chamado como porcentagem. Então, ele vai converter
isso como um percentual para texto. E então podemos conectá-lo aqui. Então, ele será exibido
como uma porcentagem aqui. Agora sempre podemos tentar testar
e ver se isso está
funcionando corretamente. Então, agora que temos
essa venda composta, então lembre-se de lidar com a interface do usuário dentro
do controlador do jogador. Então deixe-me voltar para o controlador do player
blueprints. E dentro daqui. Então, em última análise, queremos chamá-lo aqui
da base de jogadores, porque a base de jogadores, estamos verificando como se
estivéssemos calculando a saúde aqui. E, na verdade,
queremos exibir isso, como atualizar a interface do usuário daqui. Ele vai da base de
jogadores para o controlador do jogador e
para este no final. Então, vamos criar o que está
no controle do jogador agora. Então, agora no controlador
do jogador, estamos inicializando widgets. Temos esse personagem e
temos o jogador gerando. Então agora aqui embaixo, vamos fazer outro. E vamos chamá-lo. Vamos criar
um personalizado e podemos transformá-lo em uma Interface de
Blueprint. E um pouco, eu só queria
ver o que podemos fazer aqui. Então, entre em seu
cliente surpreendido, atualize,
atualize, barra de integridade e deixe-nos chamar esse evento. Então, levando aqui no WB principal, lembre-se, o evento aqui
está dentro da interface do usuário principal. Então, já temos uma variável
em nosso controlador de jogadores. Acabamos de inventar aqui. Acabamos de criar essa variável. Então, agora podemos usar essa
variável e podemos chamar esse evento
chamado atualização de saúde. Vamos chamá-lo dizer que saúde. E agora você pode encontrá-lo aqui. Em seguida, queremos fazer é apenas ir e levar essa
porcentagem nela. E é disso que precisamos. Tipo, vamos realmente
mudar este em
um cliente proprietário em execução e confiável. Então, agora o que precisamos fazer é queremos esse evento
personalizado aqui. Vamos transformá-lo em uma interface de
blueprint. Vamos voltar às interfaces, para o controlador do player. E aqui, vamos
como chamamos isso? Atualize a barra de integridade. E vamos chamá-lo aqui,
atualiza a barra de saúde. Vamos adicionar um flutuador aqui
e chamá-lo de porcentagem. Acredito que foi chamado de presente e
vamos chamá-lo aqui agora, digamos Atualizar Barra de Saúde. E podemos chamar esses eventos de
interface. E agora o que podemos fazer
é chamar esse cliente um
lado, atualizar a barra de integridade. E vamos passar por isso. Então, agora, precisamos
chamar através da base de jogadores. Então, vamos chamá-lo aqui. Então, para atualizar a saúde, vamos agora voltar
com a base de jogadores está aqui. Então estamos subtraindo
e estamos calculando. Precisamos fazer isso aqui. Então, na verdade, precisamos mover isso um pouco mais longe. E agora precisamos do controlador
do jogador. E deixe-me ver o que
fizemos aqui. Tínhamos o controlador inimigo. Nós não temos o controlador
do jogador, então podemos realmente fazer
uma referência a isso, digamos obter o controlador, porque já estamos dentro
do jogador para que possamos
obter o controlador como isso e, em seguida, digamos que
obtém controle de camada nossa referência porque queremos usar este controlador de jogador aqui. Onde está isso? Este aqui? Especificamente, estamos nos referindo
a esse PC Maple Story. E a partir daqui
vamos chamar essa atualização de integridade
Health Bar, acredito que foi chamado
e é uma mensagem. Então lembre-se da mensagem
aqui porque é uma
função de Interface de Blueprint aqui que fizemos. Portanto, é uma mensagem quando você
clica nela, Compilar e Salvar. Então agora precisamos conectar
algo dentro
dessa porcentagem
e para este, então o presente, lembre-se, você não pode
simplesmente me deixar quebrar isso aqui. Na verdade, não precisamos
fazer isso o tempo todo. Podemos apenas usar este. Deixe-me desconectar isso por enquanto. Então, agora usando essa saúde, não
podemos simplesmente
conectá-lo em porcentagem. Porque para a interface do usuário, se você der uma olhada na barra de
progresso, para a interface do usuário, sua barra de progresso está
indo, vamos ver aqui. Vai de um para 0, então não vai para 100%, vai para 0 para um. Então, se você tiver uma
porcentagem dividida por 100 para atingir esse número. Caso contrário, se você apenas conectar 100%, sempre será
100
assim porque o número máximo é realmente um e
o mínimo é 0. Então, 0 a um. Lembre-se de não 0 a 100. Então, vamos voltar para
a base de jogadores. E então o que eu preciso fazer, vamos fazer um novo evento
chamado max health porque precisamos tomar uma porcentagem e,
para fazer um percentual, precisamos saber
o que era antes. Vamos fazer uma variável de saúde máxima. E em vez de
fazer isso aqui, você pode realmente fazer
isso nas informações do jogador. Então, vamos para as estruturas como uma informação do jogador e
vamos criar uma nova variável de saúde. Vamos chamá-lo de saúde máxima. E digamos que, às
vezes, como em RPGs, você pode atualizar essa vida máxima. E essa saúde é
como estamos apenas usando essa saúde para
modificá-la o tempo todo. Mas isso faz com que a
saúde
permaneça sempre no máximo e você pode atualizá-la com
atualizações mais tarde. Então, temos a
vida máxima e vamos realmente ir para o composto
base do jogador salvo. E na
base de jogadores você tem que
definir o que é essa vida máxima. Então, vamos defini-lo para 20. saúde máxima é 20. Vamos agora. Deixe-me compilar tudo. Vamos voltar para
a base de jogadores. Então, agora temos o máximo de
saúde como uma porcentagem. Você tem que tomar essa saúde
restante e dividi-la, dividi-la pela vida máxima. Agora você receberá esse número
percentual que você pode conectar aqui. E agora que você tem essa integridade de
atualização em porcentagem, agora isso vai
passar pelo controlador do jogador. Então você está chamando isso
do controle da placa de sua saúde vai
para o controlador do jogador, vai
passar pelos clientes. Porque lembre-se, a interface do usuário
está do lado do cliente, então ela vai passar
pelo cliente e
atualizará a integridade que está aqui. E também está usando esse
número que você tem. Por exemplo, quando você estiver no número
máximo de saúde
estará aqui em 1 e a barra de progresso aqui 1 quando você
fizer apenas como porcentagem, acredito que ele o
multiplica por um 100. Então, ele o coloca aqui no texto. Mas, na verdade, temos que
testá-lo e ver se ele está
funcionando corretamente. Agora, como porcentagem. E agora você
pode conectá-los e perguntar, é, essa saúde está aqui? É igual a 0? Então, vamos
dizer novamente igual a 0. Podemos simplesmente excluir aqui
e conectar isso em vez disso. Você pode continuar
o que fez antes. Agora você vai atualizar
a barra de progresso,
salvar tudo. E antes de continuarmos,
acredito que foi isso. Na verdade, vamos tentar
ver se funciona. Então, está em 100 e este
vai me bater. Então, na verdade, podemos ver que
temos um erro aqui. Mas vamos tentar corrigir isso mais tarde. Então, vamos realmente ver
o que isso foi causado. Este aqui. Você pode ver
que ele me bate e eu tenho 50 sobrando porque me
atinge por 50. E quando eu tenho 0,
sou esse túmulo e
nada está acontecendo. Então, isso está realmente
funcionando perfeitamente. E se eu aumentar minha saúde, então digamos que vamos às informações
do jogador e
aumentamos as
colinas máximas para dizer 50. E também começamos com 50. Então, vamos jogar agora. E agora você pode ver
que está funcionando perfeitamente. E se eu for aqui, isso
vai me prejudicar muito mais. E então ele vai me matar. Então agora isso está
funcionando perfeitamente. A barra de porcentagem está correta
e a porcentagem aqui, o texto aqui também está correto. Para esse bug na letra, eu realmente preciso corrigir isso. Então, quando você pula, algum motivo não está agarrando. Vejo que está
ficando preso aqui. E deixe-me tentar pular na escada com
este porco aqui. Então, está funcionando
se eu não estiver me movendo, mas está escutando. Se eu pular de lado, o
que é muito estranho, talvez tenha algo a ver com as colisões que adicionamos. Então deixe-me, na verdade,
deixe-me ver aqui. Então, quando estivermos aqui no fundo, deixe-me ir para a colina
sendo para cima e para baixo. Então, estamos fazendo algumas
escaladas e estamos, temos essa função de desembrulho
chamada isClient sendo. Quanto ele realmente imprime uma string aqui para ver se isso, como se estivéssemos perdendo as colisões que temos. Então agora ele vai dizer Olá. Sim, você pode ver isso
diz muito às vezes. Na verdade, não são
quatro vezes se eu fizer isso por dez segundos. Então eu posso explicar. Você pode ver aqui,
vamos pular sobre ele. Na verdade, é um diz duas vezes, um do servidor e
outro do cliente. E obviamente temos
outro do servidor. Então, na verdade, faz
três vezes aqui. Temos múltiplas colisões, como se não fosse suposto
fazer isso três vezes. Portanto, esse código só
precisa ser executado uma vez. Portanto, há algo com as colisões que
precisamos ajustar, o que está causando esse problema porque só precisamos
colidir com ele uma vez. Então deixe-me clicar
nesta cápsula para o jogador e dar uma olhada. E estamos ignorando
tudo, exceto a dinâmica e a estática. E deixe-me tomar essa colisão de
ataque. Talvez tenha dito que
a colisão de ataque, estamos ignorando tudo,
exceto pela dinâmica mundial. E deixe-me dar uma
olhada na escada. Então deixe-me voltar
para as plantas para a linha sendo
cego sendo baseado, dando uma olhada na caixa de
colisão para este , Aqui está sobrepondo
tudo. E esse componente de renderização
está definido como sem colisão. Portanto, isso não tem colisão. Então o jogador, só para garantir que o sprite também não tenha
colisão. Na verdade, ele tem colisão
, mas sem eventos de sobreposição. Então deixe-me tentar
esta caixa de colisão. Deixe-me ir a fantasia e
fazer o que podemos ignorar a dinâmica mundial e
vamos tentar clicar em Play
e ver o que acontece. Agora você pode ver que está
realmente funcionando. Então, vamos testar isso algumas
vezes apenas para garantir que isso não
bloqueie de repente. Deixe-me jogar como cliente. Então, deixe-me puxar o cliente aqui e ter certeza de que
ele está funcionando também. Isso está funcionando. Está
ajustando nossa localização. Certo. Então, tudo está funcionando. E o problema era que
tivemos duas colisões
alinhadas com ele. Então, para a colisão, foi aquele que
estava colidindo com ela. Porque lembre-se de que a
colisão de ataque é uma dinâmica mundial e a colisão de escada se sobrepor
à dinâmica mundial. Então, temos que ignorar
a dinâmica mundial, o que significa que precisamos ignorar
essa colisão de ataque. E isso não vai mais
estragar tudo. Então esta foi a correção aqui,
uma correção muito simples. Então, basta configurá-lo para o
cliente e removê-lo. Então ignore isso bem dinâmico e isso resolverá o problema. Então, com isso, corrigimos esse problema e também
atualizamos a IU da Barra de Integridade. Vamos para o próximo
e atualizar o imposto sobre mortes.
85. Como atualizar o texto da morte: Agora vamos voltar para a interface
do usuário e ir para a principal. Aqui queremos
atualizar esse texto. Então diz que você foi
morto por e diz caracol. Então, temos que atualizar
esse texto aqui. Então clique neste texto novamente, lembre-se de configurá-lo para
variáveis para que possamos editá-lo e entrar
no gráfico aqui. E vou chamar este,
fazer um evento personalizado e
chamá-lo de exibir mensagem de morte. E também podemos ver como se
pudéssemos exibir a mensagem e também podemos
atualizar esses textos. Então, pegando esse texto, primeiro, precisamos
exibir essa mensagem. Lembre-se de que ele está oculto por padrão. Vamos pegar o que queremos fazer. Acredito que precisamos
transformá-lo em uma variável também. Queremos que essa caixa
vertical seja exibida. Lembre-se de que o definimos para oculto. Então precisamos, vamos
mudar o nome dele. Então VB para caixa vertical e
deixe-me chamá-lo de responder. Responda ou mensagem de morte. Vamos chamá-lo de mensagem de morte. E vamos colocá-lo em uma variável
para que eu possa vê-lo no código. Então, indo para aqui
e tomando isso, agora o que podemos dizer é
definir a visibilidade. E agora o que podemos
fazer é configurá-lo como visível. E vamos conectá-lo. Então, agora está visível. E a próxima coisa que queremos fazer é exibir esse texto aqui. Então setText realmente mudou o texto que exatamente como o que fizemos aqui com este. No entanto, com este, agora vou
te ensinar uma coisa nova. Então você tem algo dinâmico. Então, vai dizer que
você foi morto por caracóis. Então, vou copiar colar este texto e colocá-lo aqui. Então eu estava indo,
você foi morto. Você foi morto por caracol. No entanto, esse caracol,
às vezes é um porco, às vezes é um novo inimigo que
você adicionou ao seu jogo, então não é
necessariamente um caracol. Então, quando você tem textos
dinâmicos como esse que precisam mudar
durante o jogo, você tem que arrastar aqui e usar algo chamado texto de formato. Use isso em vez disso. Se você tiver algum texto dinâmico que
não seja estático o tempo todo, vou colar meu
texto novamente aqui. A coisa que você
quer ser dinâmico. Portanto, esse texto é estático. Tudo isso, a
única coisa que quero mudar é esse caracol aqui. Às vezes, é um
porco ou às vezes é outro inimigo
que você adicionou. Então, para fazer isso, você tem que
escrever esses parênteses encaracolados. Esses dois parênteses encaracolados. E no meio, você pode
simplesmente escrever o que quiser. Pressione Enter e você
pode ver que você tem uma variável aqui que
você pode conectá-la. Agora. Você pode escrever o que
quiser dentro daqui. Por exemplo, aqui o que
estamos tentando fazer é definir o nome do inimigo. Então, vou
chamá-lo de qualquer nome. Você pode ver que ele
muda de acordo. Então você pode escrever qualquer coisa
dentro do parêntese encaracolado. Este é o texto dinâmico
que precisamos mudar. Este texto será o nome
do inimigo e não especificamos nenhum
nome de
inimigo antes. Então, vamos voltar
para a estrutura. Lembre-se que temos esse
animal, informações de animais, muito útil. Podemos ter informações dos animais. Então deixe-me chamar isso
realmente não caracol, deixe-me chamá-lo de nome. Então, temos o nome do
inimigo aqui. E deixe-me mudar
isso para uma string. Compostos economizam e me deixam
colocá-lo aqui no topo. Agora, quando você fizer isso de novo, lembre-se que você pode ir para
inimigo, base inimiga, Compilar e Salvar. Agora você pode vê-lo em
todos os inimigos. Então, indo para o caracol, por exemplo, nos padrões da
classe. Agora temos essa variável de cadeia de
caracteres de nome aqui. E você pode
chamar esse caracol. E vamos ao porco aqui
e definir o nome dele. Vamos chamá-lo de “pick”. Você pode até dar um nome como você pode chamá-lo de vencedor ou
o que quiser fazer. Mas lembre-se, isso
é para todos os porcos. Então todos serão chamados
de Victor. Então, vamos chamar esse porco. E vamos fazer isso. Ok, então agora temos o
nome aqui e é uma string. Então, vamos clicar aqui
e dizer string. E vamos chamar
esse nome de inimigo, tangente em uma corda. E agora podemos
conectá-lo aqui embaixo. E você pode ver
agora que você pode direcionar uma variável através desse
texto de formato. Então, agora que temos isso, lembre-se de que isso é UI, então temos que ir ao controlador
do player e depois chamá-lo aqui. Mas para tornar seu
código um pouco melhor, você pode ir, vamos voltar para o principal aqui. Como esta mensagem de
morte de
exibição aparecerá sempre que
sua saúde for 0. Lembre-se de que você
já está verificando a saúde aqui
na integridade da atualização. Assim, você pode simplesmente
facilitar para
si mesmo em vez de apenas fazer outro evento aqui e o controlador do jogador
dizendo atualizações, mensagem de
morte ou
algo assim. Você já está verificando
a saúde. Então você já sabe
dentro daqui, sempre que for 0 e
sempre que for 0, ele exibirá
essa mensagem de morte. Isso é o que você precisa. Então, aqui na porcentagem, podemos
dizer que é igual a 0. E podemos fazer um
ramo depois disso. E se for 0, você vai chamar isso chamado
Exibir mensagem de morte. Então, podemos apenas dizer
exibir essa mensagem. E agora você tem isso. No entanto, você precisa direcionar isso novamente em todos
esses eventos. Então eu vou arrastar
esse nome inimigo viajar por aqui. Agora ele vai para os drivers
do controlador do jogador por aqui, o cliente. E aqui você tem que
passar por este, mas não pode fazer
isso porque esta é uma função de interface de blueprint
chamada Update Health Bar. Vou voltar para o controlador de
interface chamado Update Health Bar. E vamos adicionar uma corda
aqui chamada nome do inimigo, Compilar e Salvar inimigo ou
o controlador do jogador. Agora podemos conectá-los. E lembre-se agora
que está todo o caminho na base de jogadores. Então, vamos voltar para o
jogador, base de jogadores. Agora, você pode vê-lo
na base de jogadores. Vamos até o código. E você pode vê-lo aqui agora
quando atualizamos a saúde. Então, na verdade, vou ter que
dar o nome também. Então, clicando aqui, lembre-se de que o adicionamos. Portanto, este é, na verdade,
a informação do jogador. Nós o adicionamos às informações do inimigo ou
informações de animais. Então, para a informação dos animais, este aqui
precisamos chamá-lo. Então, vamos fazer isso no jogador. Então, como chamamos isso? Lembre-se, ele é armazenado
na base inimiga, plantas de base. Temos algo
que podemos fazer para chamar o plano base inimigo pois este jogador conectado é realmente um antigo
que eu preciso excluir. Então, temos
algo do qual podemos chamar o inimigo ****? E sim, nós temos, lembre-se
que temos o controlador inimigo. Este é o que
definimos aqui. Sempre que recebemos, como
quando recebemos dano, isso é do inimigo. Então, já temos o
controlador do inimigo e podemos ver que ele é
controlado, e é assim que
conseguimos a base inimiga. Porque agora podemos dizer que recebe referência
inimiga assim. E a partir daqui podemos
dizer informações sobre animais. Agora podemos obtê-lo aqui. E agora podemos quebrá-lo e
podemos obter o nome
tão simples quanto esse. Então, clicando neste
nome aqui, assim. Então, temos que incluir
isso em nosso código. Então podemos ver aqui, podemos incluí-lo aqui. Então deixe-me mover tudo
isso assim. Deixe-me incluir aqui em baixo, podemos
limpá-lo um pouco. Está um pouco confuso agora. E podemos conectar o
nome dentro daqui. Então, agora, o que realmente está
funcionando corretamente? Espero que possamos testar isso, é
claro, antes de acreditarmos nisso. Então, agora vamos só tentar
organizá-los um pouco melhor. Algo assim. Você também pode movê-los para
mais perto assim. E clique duas vezes aqui para
fazer um nó ferroviário, faça com que pareça um
pouco melhor. Assim aqui. E você pode até mesmo, para este, você pode até clicar duas vezes
aqui e fazer isso em vez disso. Então, algo assim,
parece um pouco mais limpo. Sim, isso parece bom. Então, agora podemos compilar e salvar. Então, agora estamos definindo o nome. Ele vai passar pelo controle do
jogador. Aqui. Vai passar,
vai passar
pelo evento cego , vai passar pela integridade
da atualização, que vai
passar por aqui. Todo o caminho até esse fim
vai passar por aqui e definir esse nome inimigo. E vai ser dinâmico porque você
já definiu no caracol qual é o nome
do caracol e no porco, qual é o nome do porco. Então, agora ele deve funcionar. Mas, no entanto, não podemos
testar isso agora. Na verdade, a economia que já
configuramos para exibir é apenas a resposta
que ainda não definimos. Então deixe-me acertar o
pagador para que eu possa morrer mais rápido. Agora você pode ver isso diz, você foi morto por Porco. Pressione Ok, para responder. E então você pode clicar em
OK, temos um pequeno bug. Você pode ver que o botão não pode ser pressionado em cima deste
texto ok, e só ser
pressionado aqui. Então, vamos consertar isso. E eu quero fazer isso
um pouco maior. É um pouco pequeno demais. Então, vamos voltar ao menu. Vou ao designer. Quer fazer isso um
pouco maior, que você possa clicar
na imagem, esta, e tornar o tamanho um pouco maior e aumentar a caixa
vertical
para que o botão fique maior.
Algo assim. Agora, o que podemos fazer é
por isso, ok, aqui, lembre-se da coisa como
quando os erros e ele bloqueia seu botão aqui e não
há conjuntos de blocos. Você tem que ir até aqui
para a visibilidade deste texto e defini-lo para nenhum
hit testable self somente. E isso significa que você não pode
acertar isso com o mouse. Então seu mouse ignorará isso. E dessa forma você pode se
concentrar no botão. Portanto, lembre-se de fazer isso com elementos que estão
bloqueando ou botões. Por exemplo, se você estiver fazendo uma loja no jogo ou algo assim
e tiver ícones, você tem que fazer isso
para os ícones. Então agora você pode ver
que posso clicar
no botão mesmo que
eu esteja no texto. Só vou
dizer o nome aqui. Então, agora tudo está
funcionando corretamente. A próxima coisa que queremos fazer
é quando você clica nisso, ok, vamos responder
ao jogo.
86. Player Respawn: Vamos agora trabalhar na
resposta para o jogador. Então, vamos voltar
aos planos e ao jogador, base de jogadores. Então, dentro daqui,
codificamos tudo isso, qualquer dano até agora. E nós matamos
os jogadores onde quer que o jogador morra, mas nunca especificamos quando você não
estará mais morto. E queremos estar mortos
sempre que você clicar no botão OK
dentro da interface do usuário principal. Então, vamos realmente fazer isso primeiro. Vamos agora primeiro
para a interface principal aqui. E dentro daqui, quando
você clica neste botão, então clicando no botão aqui e desça até o botão. E então você pode ver todos esses eventos tão desclicados sempre que você clica
no botão, clique neste plus
para fazer esse evento. Então, sempre que você clica neste botão OK, o que deve acontecer? Eu só queria fazer
minha morte ser falsa. Agora, como prática, agora que
estamos até agora neste curso, tente fazer isso sozinho. Tente definir um, tentei se comunicar com este blueprint e tente
defini-lo como falso você mesmo. Se você quiser, se você falhar aqui, você sempre pode seguir comigo. E agora vamos fazer isso juntos. Você pode pausar o vídeo se
quiser fazer isso sozinho. Então, o que queremos
fazer agora é que queremos nos comunicar com
a base de jogadores. Queremos pegar o,
os pons de alguma forma. Na interface do usuário, lembre-se de que isso
é do lado do cliente, portanto, cada ponto, cada
player conectado tem essa interface do usuário. Então eu posso apenas
clicar com o botão direito do mouse e dizer: Obter peão de camada. Então, ganhe o jogador proprietário, pegue o controle do jogador, pegue o Peão do Jogador Proprietário recebe o Controle de Peões em ****.
Hit possuir plataforma. E você pode ver que diz que Peão
do Jogador
está associado a essa interface do usuário. E a partir daqui podemos
dizer Obter referência de jogador. E o que podemos fazer agora é que
podemos chamar isso de morte aqui porque isso é feito
dentro da base de jogadores bp. Então podemos simplesmente chamar
isso de eventos de morte. E é uma mensagem porque é uma função Blueprint Interface. E podemos simplesmente defini-lo como falso. E lembre-se, temos que
definir essa mensagem de morte para ser oculta novamente porque outra coisa será exibida
na tela. Então defina
a visibilidade como oculta, assim. Opa, assim. Ok, então agora isso está corrigido. Ok, então agora dissemos que
a morte é falsa. Então, vamos voltar para
a base de jogadores. Eu não tenho certeza do que
fizemos aqui na verdade. Sim, só
gostamos que não fizemos muito. Só definimos isso como
falso e verdadeiro. É isso aqui para verdade,
como quando você está morto, vai mostrar
isso
para virar livro para você. Então, o que queremos fazer aqui, deixe-me fazer uma filial. Então, o que ele deve fazer quando
você não é mais isso? Então, quando você está respondendo. Então, em primeiro lugar, quero redefinir minha saúde para 100
porque agora é 0. Então, vou levar meu aqui nas Propriedades,
minha estrutura. Mais uma vez. Eu quero configurar minha bolsa de saúde, então defina os membros aqui e selecione
isso, selecione a saúde. Agora queremos definir a saúde. que você quer configurá-lo? Você quer configurá-lo
para a vida máxima. Então, vou quebrá-lo agora. Lembre-se que fizemos uma variável de saúde
máxima. Então agora só queremos nos conectar que faz saúde
dentro daqui. Deixe-me esconder
esses outros pinos. Ok, então agora estamos
definindo a saúde para o máximo de saúde e estamos de
volta à saúde total novamente. Então, vamos conectá-lo. Então, vamos conectá-lo ao falso porque se
você não está mais morto, isso é o que as dobras significam. Aqui. Temos que lembrar, temos que definir as
informações do jogador de volta aqui assim. Então, agora temos
todo o revés de saúde. A próxima coisa que precisamos fazer, precisamos atualizar a interface do usuário porque, mesmo que estejamos
configurando essa variável, lembre-se, assim como antes de você ter que atualizar a barra de progresso. Então, isso mostra que você
está com 100 de vida. Mais uma vez, o que podemos fazer por isso, podemos copiar, colar isso aqui. Então pegue o controle, pegue
o controlador do jogador. Então esses dois aqui ou eu posso
simplesmente escrevê-lo se você quiser. Então, estamos recebendo o controlador
do jogador aqui. E o que você pode fazer aqui é
o que o controlador do jogador, novamente, você pode chamar a barra de integridade de
atualizações. Aqui como a mensagem. Acredito que foi
a mensagem aqui. Sim, isso estava correto. E eu realmente
chamei isso de mensagem? Sim, eu fiz aqui. Só quero ver se cometi um erro aqui em cima. Então, agora está correto. E para a porcentagem, novamente, você pode tomar a saúde
dividida pela saúde máxima. Então, novamente, como
antes, pegue isso, separe e tome
essa saúde e divida-a pela
saúde máxima, como antes. Então, o mesmo código aqui. E então você pode
conectá-lo à porcentagem. Quanto aos eliminados, nós realmente não precisamos disso. Como se você não fosse exibir essa interface do usuário quando estiver vivo
e não estiver morto. Portanto, não
importa o que
diz porque está escondido de qualquer maneira. Então, eu realmente não
vou fazer isso aqui. Então, tudo bem, agora
atualizamos a interface do usuário. O que vem depois? A próxima coisa é,
você tem que responder. Então, onde você
está respondendo? E vamos lembrar, como há algum
tempo fizemos este, acho que no início
do curso,
definimos o local de geração do jogador e o definimos para
o início do jogador. Então, vamos usar este conjunto de locais de geração de
jogadores. Então, vamos aparecer lá. Eu desço, está aqui. Vamos definir o
local de geração do jogador como este. E o motivo, como
se você ficar confuso, às vezes ouve o set player
spawn. Deixe-me mostrar-lhe. Então, aqui, você poderia ter selecionado a mensagem
e nenhuma mensagem. E esta é uma função de
Interface de Blueprint. E talvez você se pergunte por que você
não selecionou esta mensagem aqui? Por que você selecionou este? Não há como se você fosse assim que esse é o plano em que
estamos codificando. E se a função Blueprint
Interface, se for realmente feita
dentro da base do jogador. Então, se eu for para isso, as interfaces e
a base de jogadores aqui, você pode ver que já
fizemos isso dentro
daqui definir o local de geração do jogador. Quando você está chamando isso dentro do blueprint em que você fez, você realmente não
precisa selecionar a mensagem. A mensagem é apenas
para comunicação. E você teria selecionado a
mensagem se estivesse chamando a mensagem
do controlador do jogador
de outro lugar, você teria selecionado a mensagem. Mas se você está chamando
isso dentro de si mesmo, então eu vou selecionar este
sem a mensagem. Ok, então agora você está
gerando o jogador. E lembre-se que ainda estamos
tendo o modo deus. Nunca removemos
o modo deus aqui. O modo deus
só está sendo removido quando você não está morrendo,
mas quando você está morto. Nunca defina isso como falso. Então deixe-me copiar colar este
código aqui que o atraso, agora após o atraso aqui. Então, a razão pela qual estou
dando ao jogador atrasado, então estamos respondendo e você está realmente tendo o
modo Deus enquanto está respondendo porque eu não
quero receber danos imediatamente
quando eu responder. Então, estou dando ao
jogador a chance de
responder e não receber dano. E acredito que foi isso. Não tenho certeza se
esqueci de algo. Deixe-me, na verdade,
apenas clicar em Play. Vamos ver o que acontece. Então, quando estamos morrendo, deixe-me realmente ir ao porco. Morremos mais rápido aqui. Estamos mortos e diz que você
foi morto pela imprensa de porcos. Certo. Quando eu pressiono Ok, você pode ver que eu respondo. E deixe-me morrer novamente
para ver se isso está escutado ou não. Está funcionando corretamente. Agora, novamente, você pode ver que
esses estão incomodando. Você pode novamente tentar
redimensionar e reduzir a escala,
sofisticar as caixas de colisão. Esses são os
que às vezes
os fazem insetos aqui nas rampas. Então, agora, quando eu clico em OK, você pode ver que eu posso responder. Na verdade, quero que meu jogador pisque quando
respondo porque quero saber que estou no meu modo
Deus quando respondo. Então deixe-me pegar esse efeito
piscante, que fizemos aqui, e nós o adicionamos aqui, na verdade danos por efeitos. Deixe-me copiar uma
cópia dela aqui e
deixe-me colá-lo logo
depois, logo antes. Na verdade, logo após eu responder, posso fazer isso aqui. Então, quando eu respondo,
eu toco esse efeito. E então eu removo esse
modo Deus depois desse efeito. Deixe-me clicar em jogar. E quando eu morro, clico em OK. Você pode ver que eu tenho
esse Efeito do Modo Deus. E então eu respondo, acho que isso é um pequeno efeito. Na verdade, vou esconder
essas caixas de colisão. Mais uma vez, não precisamos mais
deles, acho que não. Então deixe-me clicar
nesta colisão de ataque e escondê-la no jogo. E entre na base inimiga aqui e clique
nesta colisão e
também esconda-a no jogo, compile e salve tudo. Então, agora que tudo
está funcionando, você pode tentar testar o jogo e ver se tudo está
funcionando como deveria. Sempre podemos levar esse cliente. Então, antes de
eu terminar, eu realmente quero
escrever com ambos. Aqui, veja se o cliente e o servidor podem
ver o que está acontecendo. Assim, você pode ver que o servidor pode realmente ver o cliente morreu. E como o servidor agora, é um pouco difícil
ter os dois em uma tela. Então, agora ambos morreram. E se eu clicar em OK enquanto
o cliente responde, ok, e se eu clicar em
OK, é o servidor, eu respondo também e
estou piscando corretamente. Quando eu ataque, isso está
funcionando quando eu verifico aqui, está funcionando quando
acordei a escada. Está funcionando para ambos. Certo. Então deixe-me experimentá-lo
como cliente agora. Jogue como cliente para
garantir que tudo esteja
funcionando antes de seguirmos em
frente selecionando a Tsarina
aqui neste cliente. E no segundo cliente, vou selecionar Luke. E deixe-me
entrar nesse inimigo. Aqui. Estou morto. Vou andar aqui. Eu também fui feito. Certo. Então, parece que tudo
está funcionando agora. E andando para cima. A carta também funciona. Certo, então não há livros agora, então isso é legal. Tudo está funcionando
como deveria. Então, estamos prontos para seguir
em frente e vamos realmente trabalhar no inimigo agora para que
possamos matar o inimigo.
87. Como corrigir bugs existentes: Continuamos, temos alguns livros que precisamos consertar. E eu escrevi
todos eles aqui. Então, enquanto eu estava testando
o jogo e encontrei os sete dólares e acho que
devemos consertá-los
antes de continuarmos. Então, o primeiro é um
bug da morte durante o ataque. Então, se eu for aqui
e jogar o jogo, e eu entrei nos inimigos, então deixe-me perder
minha saúde aqui. Agora, se eu atacar
logo antes de morrer, você pode ver que eu apareço assim. E isso é suposto
ser um túmulo. E se você quiser, você pode tentar consertar
isso sozinho. Tente pensar onde isso
pode estar? Tipo? O que isso está
acontecendo antes? Porque quando atacamos e
quando morremos ao mesmo tempo, voltamos a este estado ocioso. Então tente pensar, se você quiser por si mesmo onde esse bug
pode estar acontecendo. E você pode usar um nó de string de
impressão para tentar depurar seu código. É sempre bom usar um nó de cadeia de
impressão. Vamos clicar em Ok, e
vamos deixar isso. Então, para corrigir esse bug agora, vamos para o código de
ataque porque ele está essencialmente acontecendo
quando estamos atacando. Então, estamos definindo o ataque como verdadeiro
quando estamos atacando. E depois de algum tempo, então morremos entre aqui, então atacamos e morremos. E lembre-se que temos isso aqui. Este é o ataque concluído. Estamos atrasando o código
com essa animação e, após o código, estamos
definindo-o como false. Então, quando o ataque
está definido como falso, ele está colocando nosso personagem
no estado ocioso, então está realmente acontecendo aqui. A única maneira de
verificarmos a profundidade é aqui em
cima, então não podemos
atacar enquanto estamos mortos. Mas e se já atacarmos? Então, e se já estivermos
aqui e depois morrermos? Isso não está sendo
verificado agora. Então estamos
acabando aqui e estamos acabando por estar
no estado ocioso. Então podemos tentar levar
este ano está morto, este booleano e
tentar verificar aqui também. Você pode verificar aqui
ou você pode conferir aqui. Então atacar tem que ser falso. Então, vamos realmente fazer isso aqui. Acho que essa é a melhor maneira. Então aqui está atacando. Se estiver definido como false, você verificará nosso uso. Você está morto? Na verdade, vamos
notar isso porque isso é melhor ler, acredito, para mim mesmo. Então, se você não está morto, novamente, você pode simplesmente
ir em frente e ídolo. No entanto, agora, se você estiver morto, vamos copiar isso e
colocá-lo nos estados de morte. Assim e isso
deve resolver o problema. Então, se jogarmos agora
e eu perder a saúde, eu ataco enquanto isso. Opa, eu não morri. Eu tomo isso enquanto isso. Você pode ver agora que ele
corrigiu o problema. E se eu clicar em OK,
responderei. Ok, então esse foi o primeiro
livro que consertamos aqui. Então isso é corrigido. O próximo é que os animais estão ficando presos na rampa. E se eu simplesmente copiar
colar alguns animais e já vimos isso
antes lá. Outras lições e eu só
quero resolver esse problema. Então, se eu simplesmente copiar, cole
muitos inimigos, e espero
que isso seja muito rápido. Agora podemos ver aqui, este porco
aqui está preso na rampa. O porco está
correndo para a sala. E o caracol faz
isso às vezes. Então o caracol, você pode ver
o caracol excluir aqui. Então eles estão sendo
bombeados às vezes. Deixe-me realmente corrigir
isso antes de continuar, estou ficando um pouco
irritado com esse bug. Então, vamos para os inimigos. E a coisa é que, na verdade, encontramos
uma solução antes, então só precisamos
fazer a mesma coisa. E a solução foi, se eu for para o caracol, por exemplo, podemos
começar com este. A colisão aqui é,
na verdade, esta cápsula. Aqui está o que está fazendo isso. Então, se aumentarmos o
tamanho desta cápsula, isso evitará o bug. Então descobri que 35 por 35 de comprimento, aumentando esta cápsula para 35 como mínimo
resolverá o problema. E lembre-se que você tem que
arrastar o caracol para baixo. Caracol vai
flutuar assim. Então arrastando para baixo o caracol,
talvez algo assim. Talvez isso seja muito
baixo. Talvez, talvez seja um pouco baixo demais. Eu acho. Menos, menos 25 talvez. Ok, então algo assim. Agora o caracol está aqui em cima
e você notará que o caracol velho
nunca mais se você simplesmente deixá-lo correr
por algum tempo agora. E vamos fazer a mesma
coisa com os porcos. Então, indo para o porco aqui. E vou
clicar na cápsula aqui e aumentar o
tamanho para 35 por 35. Também derrube este
porco um pouco mais. E deixe-me tentar ver
o que isso parece. Está correndo no chão. Parece bom. E agora, se deixarmos
jogar por algum tempo, não vai mais se incomodar. Então, se os porcos vão embora. Então, esta rampa, você pode ver
que eles estão funcionando bem. Então isso deve ser corrigido agora, este é o fixo para isso. Então, aumentando a cápsula e depois arrastando para baixo esse porco. Então eles parecem que estão
correndo no chão ainda. Então isso corrige o segundo
problema que temos aqui. O terceiro é
que os inimigos
não detectam a colisão de ataque. Já tivemos alguns problemas
com isso antes, mas eu não olhei
muito a sério até agora. Eles podem ver se eu
atacar por tecnologia aqui, você pode ver que
não há detecção do meu ataque. E eles só estão detectando meu ataque se eu chegar muito perto. Então, se eu estiver
dentro do inimigo, eles estão realmente me detectando. Mas se eu estiver um pouco
longe do inimigo, eles não estão
sendo atacados. Certo, então temos que consertar isso. Então eu tentei o meu melhor para usar essa colisão, colisão de
ataque SR. Mas como essa
colisão aqui tem o código onde realmente
voltamos para a interface, deixe-me fechar o
caracol e o porco. E se eu for para colisão aqui, lembre-se que fizemos este código
onde aplicamos danos. E, portanto, essa colisão sempre
aplicará danos. Então, como fazer isso, a
melhor maneira vai realmente exigir que façamos outra chamada caixa principal
onde atingimos o inimigo. Então, vamos apenas criar
uma nova colisão. E vamos criar uma
região esférica com esta, vamos chamá-la de caixa de sucesso. Então, vamos
usá-lo como uma caixa de sucesso. Vou
arrastá-lo para fora desta colisão aqui
para esta cápsula. Então, a primeira coisa é entrar
aqui na cápsula. Então, vamos verificar nossas colisões só para ter certeza agora que
temos essa caixa de sucesso. Então as colisões
para esta cápsula, a única coisa que
queremos com esta cápsula, e você pode ver aqui
a razão pela qual estou, estou criando essa
caixa de sucesso e não estou usando essa cápsula porque
lembre-se esta cápsula, nós realmente aumentamos
o tamanho aqui. Este é o tamanho da
cápsula e eu acho que os acertos, caixa de
sucesso são muito grandes, como se pudéssemos usar esta
cápsula para atingir o inimigo. Mas eu acho que esse sucesso é muito grande e
eu não gosto disso. Então você pode ver se eu clico nele e clico oculto no jogo, se eu removê-lo, você pode
ver o tamanho dessa caixa de sucesso. E eu acho que isso
é muito grande, como um
dinheiro de cabeça para um caracol. Então eu não vou usar
essa caixa de sucesso e podemos diminuir o tamanho,
caso contrário , ficará preso
dentro da rampa. Então deixe-me
escondê-lo novamente aqui na cápsula da interface. Na verdade, estava dentro
do caracol aqui, a cápsula, e eu vou
escondê-lo no jogo novamente. Ok, bem-vindo de volta
à base inimiga. Então, o que queremos
fazer esta cápsula, primeiro
vamos ignorar tudo. O que você não
quer ignorar é o mundo estático e
a dinâmica mundial. E isso é apenas para não fazer o ponto cair no
chão porque o chão, essas
colisões de crianças terrestres aqui embaixo, elas são estáticas do mundo. E se você simplesmente remover isso, você realmente
cairá no chão. E já que estou usando isso para colisão
desta cápsula aqui, vou remover,
gerar eventos de sobreposição. Não estou usando isso
para eventos de sobreposição, então estou apenas usando para bloquear esses poços estáticos e dinâmicos para que ele não
caia no chão. Então, essencialmente,
não estamos realmente usando essa cápsula para
eventos de sobreposição. Vamos descer para o calor bucks. Então, esta caixa principal eu
vou clicar em Não, personagem
pode avançar? Vou clicar em Não. E estou definindo isso para custar. Opa, não há colisão. Vou clicar em Control
Z e personalizar aqui. E vou
ignorar tudo exceto pela dinâmica mundial. E lembre-se aqui no jogador, então eles atacam a
coalizão que temos. Se você descer e
olhar para o tipo de objeto, vale a pena dinâmico. E é por isso que estou,
estou me sobrepondo à dinâmica porque quero me
sobrepor à minha colisão de
ataque. Isso é definido para dinâmica mundial. Certo? Então é isso que estou
sobrepondo listas. Então agora isso está correto e
deixe-me ir até o sprite, certifique-se de que ele não
gere nenhum evento de sobreposição. E eu vou para a colisão aqui. Então é isso que está
danificando nossa lagoa, que é nosso jogador. E, na verdade, vou mudar isso em vez da dinâmica mundial. Vou mudar
isso para um **** porque essencialmente não
estamos usando esta potente cápsula aqui. Então eu posso
mudar isso para um ponto. Então esta é basicamente
nossa colisão Po1 aqui. Certo, então vamos lembrar disso. Vamos lembrar que o
colocamos para peão aqui. Então deixe-me ir agora para
a base de jogadores. E aqui no componente da
cápsula, certifique-se de
ignorar tudo novamente. A única coisa é
a estática mundial e a dinâmica mundial com a qual
você está se sobrepondo. E lembre-se, acabamos de
mudar
este, essa colisão que nos
prejudicará para ****. Então, na verdade,
precisamos nos sobrepor a ele outro lugar, não sofrerá
nenhum dano dele. Então, estamos nos
sobrepondo a ele. E para o sprite, não gerará
nenhum evento de sobreposição. E para essa colisão de ataque, ela só se
sobrepõe à dinâmica do mundo. E vamos voltar e
ver se isso está correto. Portanto, está se sobrepondo
à dinâmica mundial. E esta é a nossa caixa de sucesso e nossa caixa de cabeça está definida
para a dinâmica mundial. Então isso está correto. Agora há sobreposição uns aos outros porque isso
é dinâmico, isso é o que dinâmico. E ambos estão se sobrepondo
à dinâmica mundial, o que significa que eles estão se
sobrepondo um ao outro. Portanto, essa colisão deve
estar totalmente correta agora. Então, vamos agora clicar em jogar
antes de fazermos isso, você pode clicar nesta colisão de
ataque. E você pode remover oculto
nos jogos para que você possa vê-lo. E também pode ir para o inimigo, clicar na caixa principal. E você pode tentar
remover um jogo escondido. E também vamos ao porco
e ajustar essa caixa escondida. E para esta caixa de cabeça,
eu só vou, vamos fazer talvez o
mesmo que esse
tamanho de colisão aqui, então 25. E, novamente, você pode segurar Shift e clicar
com o botão direito do mouse para copiá-lo e colá-lo aqui. E então vou colocar a localização
da mesma forma aqui. Então clique com o botão direito Você pode copiá-lo
aqui, colá-lo aqui, e agora a colisão está aqui. Então esta é a caixa principal. Vamos fazer a mesma
coisa pelo caracol. Então deixe-me ir para a janela de exibição, clique na caixa principal, na verdade,
a colisão copie isso, cole-o na caixa de cabeça. Copie isso aqui, Esse é o local e
cole-o na caixa principal. Vamos clicar em Jogar agora. E agora você pode ver que essas são as caixas de cabeça agora que é
muito melhor do que antes. Então agora você pode ver que estou
sendo danificado assim. Certo, então isso é bom. Deixe-me tentar de novo. Você pode ver que estou
sendo danificado aqui. Como mesmo estando
nessa colisão, isso é realmente outro bug, então não seja enganado aqui. Então deixe-me realmente apenas, você pode ver aqui, eu
realmente não estou sendo
danificado agora. Se eu ficar dentro da minha caixa de
ataque assim, você pode ver que está funcionando,
então não está colidindo. No entanto, há um pequeno,
há outro bug. E se eu atacar agora, você pode ver que estou
batendo meus inimigos. Ok, então está funcionando totalmente agora. Há outro bug agora. Você pode ver se eu fico danificado. Agora, estou sendo
danificado na minha religião de ataque, o que não deveria acontecer. Isso, por algum motivo, isso só acontece
sempre que eu fico danificado. Você pode ver. Mas se eu
apenas redefinir o jogo, este é o nosso próximo bloco. Então, se eu apenas redefinir o jogo
e eu me mudar para cá, você pode ver que eu não estou
sendo danificado. Preciso remover
alguns dos inimigos. Na verdade, tenho muitos. Então deixe-me excluir
muitos deles agora. É um pouco, é um pouco difícil
de mostrar com todos esses centímetros. Então deixe-me colocar um
caracol aqui em vez disso. Algo assim. E deixe-me clicar em Jogar agora. Então agora, se eu ficar no caracol, você pode ver que eu não estou
sendo danificado na minha caixa de colisão de ataque. No entanto, sempre que
ficamos danificados,
agora, de repente,
estamos sendo danificados. Outro ataque, caixa de colisão. Há um pequeno bug. De repente, mudanças. E este é, na verdade,
nosso próximo. Então aqui, a caixa de alcance de
ataque inimigo. Então, de repente, isso
nos ataca em nossa colisão de ataque. Então passei meia hora
tentando dar uma olhada no
que poderia ser. E pensei que talvez
fossem as caixas de colisão. E isso
não era verdade como as caixas de colisão,
elas estão corretas. Não faz sentido
que seja um bug lá. E, na verdade, isso é um
pequeno, pequeno e tolo erro
do meu lado. Talvez você já tenha
lembrado disso enquanto está fazendo os vídeos. Eu poderia ter esquecido,
mas você pode tentar consertá-lo
sozinho se quiser. Mas, de repente, como
quando somos atacados, estamos de repente
apenas recebendo
sexo em nossa caixa de colisão. E a razão para
isso é que se você for para o inimigo, vá para
o Gráfico de Eventos. Lembre-se que fizemos esses eventos de
colisão. Então, quando nosso jogador
colide com o inimigo, estamos aplicando dano. Então isso está acontecendo
corretamente agora, como desde o início. Então, sempre que
entrarmos no inimigo, e isso não significa
para nossa caixa de colisão, mas não entraremos no
inimigo com nossa cápsula. De repente, estamos aplicando danos a este também. Isso ocorre porque
nunca dissemos quando
parar de aplicar danos porque
temos essa sobreposição final. Mas isso realmente não
faz como se estivesse correto. Mas aqui em cima, lembre-se que
fizemos isso começar a
aplicar danificado. Isso é o que está sendo executado. Então isso está definido como verdadeiro. E se for verdade,
vai aplicar danos. Mas quando o definimos como false, nunca
especificamos o que fazer aqui quando
está definido como false, então ele continua aplicando
danos o tempo todo. Na verdade, temos que dizer a ele
para parar de aplicar danos. Então deixe-me fazer isso. E isso é apenas um
pequeno erro por mim. Acho que só estava falando naquele vídeo
e não notei. Deixe-me promover isso
para uma variável, este temporizador promovido e
chamá-lo de aplicar dano, manipular. Ok, então vamos pegar
essa alça e dizer claro e invalidar o
temporizador por alça. Então agora ele vai
parar esse temporizador toda vez que definirmos isso como falso. Assim, toda vez que
sairmos
do componente, os componentes
de colisão o definirão como falso e não
aplicarão mais danos. Então, temos que colidir com ele
novamente para aplicar o dano. Então, vamos tentar clicar
em Jogar agora. E agora. Isso está funcionando
corretamente como antes. Mas se eu ficar danificado e
ficar na frente dele, você pode ver que ainda está funcionando. E isso ocorre porque
ele tem que entrar na minha cápsula novamente antes
que ela possa causar danos. Ok, então isso está funcionando
agora como deveria. Este foi o próximo bug aqui. Isso é corrigido. A próxima é que o jogador não
pode ser danificado na corda. Então, se eu estiver de pé no ícone
da corda foi danificado, e este é um bug muito
fácil de corrigir. Então, se você simplesmente for para
a base inimiga e você para a colisão aqui, for para a colisão aqui,
como se o inimigo estivesse
colidindo com o ****,
mas você também quer colidir mas você também quer colidir com o cliente sendo jogador. Lembre-se, nós fizemos
esse personalizado. Então, isso é apenas corrigido. Então essa foi uma solução muito rápida. Ok, então a outra
coisa é, agora, deixe-me adicionar mais inimigos ao redor dos golpes para que possamos
ver o dinheiro muito mais rápido. Então deixe-me clicar em Play. Ok, então se eu estiver aqui, você pode ver qual é o problema. Estou sendo danificado assim. Mas eu quero realmente empurrar
meu jogador da corda aqui. Então, se eu apenas for para minha
camada, base de camada e
tivermos esse dano, então estamos recebendo dano, mas quero que meu jogador
pare de estar na corda. Então, o que vou fazer
aqui na escalada, vou levar
este é escalar. Lembre-se que inventamos aqui
em nosso código de escalada, fizemos que um chamado é colina ser sempre que
você está escalando. Então, se eu puder encontrá-lo na verdade. Agora, este, nós
chegamos aqui em baixo. Assim como escalar
aqui, está escalando. Fizemos que um
conjunto está subindo. Então, vamos realmente usar
esse aqui em baixo. Então, basta perguntar o código, se você receber algum dano. Você
já está subindo sendo, se estiver, queremos fazer outra coisa. Se você não estiver,
vamos em frente e faça o que fizemos antes. Então, se você já está subindo, deixe-me pegar isso é escalar e defini-lo como falso porque eu não
quero mais escalar. E então vamos
voltar e fazer o que quer que seja vamos tentar
ver o que isso faz. Então deixe-me ir neste suporte
de corda aqui. E você pode ver agora
que está funcionando corretamente. Há um pequeno bug agora que
gostamos quando nos movimentamos, é como pausar nossos flip books para que
as animações não sejam reproduzidas. E lembre-se,
no cliente,
se você voltar ao seu código, você tinha algo aqui. Usamos chamado pausa,
escalada, flip book. E usamos essa pausa sempre que não
estamos nos movendo na corda, estamos posando o flip
book para que não
pareça que você está subindo enquanto
você está parado. Então, precisamos fazer isso também. Então deixe-me ir aqui
e continuar aqui. Em vez de apenas fazer isso, vamos fazer, pode subir de volta. Excelente neste. Ele pode subir aqui. Vamos pegar este também. Então set pode subir para ser falso. O conjunto está subindo para
ser falso e definido. Vamos ver a pausa aqui. Pause, suba, flip
book para ser falso. Assim, tanto a subida da lata
está subindo e pausar o flip
book de encadernação está definido como falso. Então deixe-me mover o
código, algo assim. Então estamos fazendo isso, inicialmente
estamos apenas removendo a mecânica
de escalada. E estamos, acho que
estamos prontos para ir agora. Então, vamos tentar
jogar a corda. E você pode ver que está
funcionando corretamente agora e eu posso pular
na corda novamente. E se eu fizer isso, fique
aqui e fique danificado. Se esse caracol me bater. Então, quando eu fico danificado aqui, você pode ver que ainda está funcionando. Ok, então esse bug está corrigido agora, a morte e o dano. E na verdade há
um pequeno livro ainda, como se você estivesse de
pé na corda. Você pode ver, eu pareço assim. Se eu realmente morrer na corda. E isso está
essencialmente acontecendo porque se voltarmos aqui e vamos para ISClient
sendo, na verdade a função unwrap está subindo
se eu puder encontrá-la aqui. Então, é, quando a
escalada é falsa. Ele vai
defini-lo para isso aqui. Deixe-me me esconder. Este ano. Vai definir nosso livro flip de
salto aqui. Mas não queremos fazer isso. Queremos jogar a morte. Vamos tentar pegar isso. Booleano está morto aqui. Vamos verificar se você já está
morto aqui, na verdade eu vou
dizer não isso porque é melhor ler. Então, vamos
conectá-los por enquanto. E agora estamos dizendo,
você está subindo? Sim, estou. Você não é bem assim se
você for atingido por um inimigo e estiver
caindo da corda, então isso será falso. Você não está mais escalando. Certo, não estamos mais
jogando Bing. Então você vai
verificar, você está morto? Se você não está morto, ok. Vamos em frente e
faça a mesma coisa antes, onde você cai. No entanto, se você estiver morto. Então deixe-me arrastar isso aqui. Se você é isso, deixe-me apenas atacar isso. Se você é isso agora,
vamos levar isso aqui, o modo de movimento definido. E vou colocá-lo
para andar em vez de cair em colisão novamente, temos que voltar a
esta colisão de peões porque antes de sermos
o jogador de escalada, temos que voltar para o
peão canal de colisão aqui. E em vez de definir o
flip book para pular animação, podemos apenas dizer o modo de movimento. E que os modos de movimento definem estados de movimentos para o jogador aqui na
base int player, defina o
modo de movimento como mortes. Então agora estamos mortos porque
isso vai ser falso, o que significa que se você não estiver morto, ok, você vai
fazer a mesma coisa. No entanto, se você é que você
vai fazer isso aqui em baixo onde você define o modo de caminhada ou o modo de movimento para caminhar, e então você vai
defini-lo para a morte aqui. Então, vamos reproduzir esse código. Deixe-me realmente gerar um pouco mais inimigos só para que
possamos testá-lo mais rápido. E agora vamos ser
danificados um pouco aqui. E agora na corda, você pode ver que eu sou realmente um túmulo. Agora, isso está funcionando corretamente
e se eu clicar em Ok, e eu posso andar por aí, posso fazer a
mesma coisa que estava fazendo antes. Estou sendo empurrado para fora da
escada. Se eu estiver de pé sobre ele. Quero dizer, você pode
apenas fazer seu jogo não ser empurrado para cima na carta. Isso depende de você. Você também
pode receber danos
sob a carta. Bem, eu acho que parece
muito melhor se você apenas empurrá-la da carta e você pegar esse túmulo
sempre que morrer. Então, isso está funcionando
corretamente agora. Então esse foi o sexto. E o sétimo é Responda
Ok, o botão é focalizável. O que quero dizer com isso
é se eu clicar bem
aqui em cima , e então eu morrer. E isso é algo na interface do usuário. Então, fy, dy e clique no espaço
no meu teclado ou Enter. Você pode ver que estou
clicando no botão. Então, se eu clicar no espaço e se
você não quiser fazer isso, não
quero fazer
isso para este jogo. Então você pode ir para a interface do usuário, ir para o menu principal. Agora, nesse
menu principal, o menu I. E aqui para este botão,
se você clicar nele, há algo chamado
é focável e diz que às vezes o botão só
deve ser
clicável pelo mouse e nunca
teclado focável. E isso é o que está acontecendo. Então, se eu clicar
nele com o mouse, e depois
poderemos clicar com o teclado como
espaço para clicar. Certo. Você pode mantê-lo se quiser, mas vou removê-lo, que significa que só posso
clicar nisso com o mouse. Não consigo clicar em Enter no
meu teclado ou em um espaço. E às vezes é
irritante como se você tiver um sistema de inventário, você só quer clicar
nas guias com mouse e não com
seu inter e espaço. Talvez você esteja
tentando pular no jogo. E você não pode pular porque isso está sendo
focado e está clicando, ok, em vez de
pular e assim por diante. Então, vai fazer
um pouco de bagunça. Mas neste caso
, não há problema em tê-lo como focalizável quando você está morto. Portanto, ele pode clicar no
espaço para responder. Mas acho que vou apenas removê-lo. E eu também estou apenas ensinando sobre essa interação
aqui para que possamos remover isso é focalizável e vamos compilar e
salvar, e foi isso. Então, se apenas clicarmos, vamos realmente reproduzi-lo como
o servidor escutado também. Não fizemos
isso só para
ter certeza de que estou na
carta da escada e faço isso. Isso está parecendo correto. E se eu apenas pegar o cliente e vamos
ver o que está acontecendo. Deixe-me minimizar isso um
pouco para que haja espaço. Ok, então agora
somos o cliente e o cliente também
sendo afastado. O servidor pode ver isso. Ok, então está
funcionando corretamente. E deixe-me ver se eu morro aqui. E eu faço. Ok, então isso está
funcionando corretamente. Agora, vamos clicar em OK, e vamos fechar isso. Então, todos os bugs são
corrigidos e você pode ver que não leva muito
tempo para corrigir esses bugs, mas sempre é bom
experimentar seu jogo. Se você quiser depurar, use o nó de cadeia de impressão, tente ver se é
sua colisão, tentou verificar com booleanos. Por exemplo, se os jogadores que não
queremos fazer uma determinada ação. Então, há algumas coisas
que você pode verificar. E agora posso fechar isso. Corrigimos todos os bugs. Vamos salvar tudo e vamos passar para
a próxima lição.
88. Como remover a perseguição do jogador na morte: Agora vamos fazer o
inimigo parar de perseguir o jogador sempre que
o jogador for isso. Então, vamos para a nossa pasta Blueprints e para o inimigo e dentro da base inimiga. Então, dentro daqui
temos essa lógica que os inimigos
perseguem o jogador, mas o inimigo ainda está perseguindo o jogador sempre
que os inimigos que são os jogadores que temos que
torná-lo tal que o inimigo pára perseguir o jogador
sempre que os jogadores. Então, vamos fazer isso aqui. Temos essa lógica
Ver a IA se mover para, então estamos nos movendo para o
personagem e o que o inimigo alcança o
jogador aqui em sucesso. Em vez de apenas
ir para diretamente, vamos tentar verificar se o
jogador está morto ou não, porque já temos isso. Então, isso será fácil. Deixe-me mover tudo isso para o lado para que possamos
escrever algum código aqui. O que eu quero fazer é apenas
verificar se o jogador é esse,
lembre-se que já temos
esse controlador de jogador. E podemos dizer que é
controlado peão. Aqui precisamos de uma referência
à base de jogadores. Então, dizer obtém referência do jogador. Então, assim como o que temos
feito antes. E vamos conectá-lo aqui. E aqui eu quero usar este
chamado é aquilo, que nós fizemos isso. Então pegue esse booleano. E vamos escrever outro booleano só para que seja melhor
para legibilidade. E vamos pegar isso
e dizer ramo. Então agora estamos perguntando se
o jogador não está morto, então vá em frente e faça
o que você fez antes. Então, indo para esse novo local. No entanto, se o jogador estiver morto, queremos fazer outra coisa. Agora deixe-me arrastar esse código
um pouco mais perto. Agora que temos esse código aqui. Talvez algo assim. Ok, deixe-me aproximar
isso agora. Certo, então temos esse código aqui. E agora podemos dizer se
o jogador está morto,
então não morto é falso, o
que significa que o jogador está morto. Só queremos lembrar antes fazermos isso com a lógica do stub, então paramos a árvore de
comportamento deles. Agora podemos fazer o contrário. Então, podemos começar
com a lógica. Então, ele pode simplesmente copiar
colar isso se você quiser apenas copiar colar aqui. E vamos conectá-lo. Então, queremos iniciar a lógica. Mais uma vez. Queremos iniciar
a árvore de comportamento. E agora ele vai fazer o
loop da coisa toda de novo. Então, vamos tentar clicar em
Play e ver se ele funciona. Vamos jogar aqui como o servidor. Então, vou bater em
algo aqui. Vou ser atingido. Então, neste momento, eles
estão me perseguindo. E, na verdade, vou
ler todos esses dois. Agora eu morro. E vamos ver se eles vão. Você pode ver que eles não estão
realmente perseguindo muito mais. Todos esses que eu bati
seguiram seu próprio caminho. Então, na verdade, está
funcionando corretamente agora. Então agora paramos de
perseguir o jogador. Sempre que, os jogadores
que tão mal sucedidos, estamos verificando se o
jogador está morto ou não. E se o jogador não estiver morto, então vamos fazer um loop desse evento aqui
que fizemos antes. No entanto, se os jogadores
que vamos apenas
executar a árvore de comportamento
novamente, o que está aqui, que significa que vamos correr para encontrar localização
aleatória e
o que fizermos antes,
antes de atingirmos o inimigo
.
89. Morte e resposta inimigos: Então, aqui dentro
da base íntima, vamos agora trabalhar
na morte inimiga. Então agora terminamos
a morte do jogador, mas agora precisamos da morte inimiga. Então, assim como o jogador, vamos em frente e fazer
um novo evento aqui. E, na verdade,
vamos fazer isso dentro da Interface do Blueprint. Então, vá para as interfaces
na base inimiga, e vamos adicionar uma nova
função chamada morte. E novamente, precisamos de um
booleano como antes, e vamos chamá-lo de B está morto. E isso está incomodando novamente. Vou excluí-lo. Não sei por que isso acontece com
tanta frequência agora. Vamos apenas dizer que b está morto. E vamos chamá-lo de morte. Assim como o jogador. Vamos voltar para
a interface agora. E aqui Vamos
clicar com o botão direito do mouse e dizer morte e chamar esse evento. Então precisamos de um evento
personalizado novamente, ele rodando pelos servidores e verifique se o
cliente não está trapaceando. E vamos executá-lo
pelo servidor e confiável. E agora podemos executar
o servidor um
aqui em cima , então morte do servidor. E vamos adicionar um booleano
aqui para que possamos conectá-los. Chama-se, D está
morto, assim. E agora podemos fazer
algo aqui embaixo. Então, deixe-me promover
isso para uma variável. B está morto. E já posso pensar que
precisamos mudar isso para uma notificação de naufrágio
porque precisamos
reproduzir a animação da morte para o,
para o inimigo e o representante notificar. Lembre-se de que vamos
notificar todos
os clientes sobre
a mudança visual. Assim, todos os clientes podem ver a animação para o
inimigo quando ele está morrendo. Então isso é o que
precisamos agora. Então, aqui em cima, agora vamos adicionar antes de
fazermos qualquer coisa aqui, vamos realmente subir aqui
e ver quando o inimigo dado. E vou esconder
os pinos não conectados aqui
para que pareçam mais limpos. Então aqui estamos calculando a saúde e estamos
configurando aqui, então está por aqui. Estamos atrasando a animação, estamos parando o movimento. Então estamos parando a lógica. E vamos realmente fazer isso aqui. Então eu quero fazer isso logo
após isso atrasar. Então, quando atingimos o inimigo, ele vai ficar atrasado. Vai terminar de reproduzir essa animação Hit
antes que ela morra. A menos que você tenha uma cópia, como copie isso e reconecte isso aqui e deixe-me colocá-la aqui depois que essa lógica superior
não faz sentido. Isso não faz diferença. Quero dizer, isso não
faz diferença. Mas acho que é mais limpo
parar o movimento, parar toda a lógica
imediatamente antes desse atraso. Às vezes, como
não faz sentido
organizar suas anotações para que elas
entrem na ordem correta. E agora vai atrasar essa animação e logo
antes de eu começar a andar, mas porque talvez eu esteja morto, então eu não quero começar a
trabalhar imediatamente. Então, aqui está uma boa posição para verificar se o inimigo
está morto ou não. Então, antes de começar a andar, verifique se o inimigo está
morto ou
não porque não faz sentido começar a
andar se você está morto. Então deixe-me selecionar tudo isso e movê-lo aqui para o lado para que eu tenha algum espaço para trabalhar. Agora, vamos pegar as informações dos animais. Ou podemos realmente
pegá-lo daqui e dizer pausa. E então podemos tomar a
saúde e dizer igual. E vamos arrastá-lo até aqui e ocultar pinos não conectados. Posso apenas clicar duas vezes para criar um nó de redirecionamento e
torná-lo muito mais limpo. Ok, então agora podemos dizer aqui, então se a saúde for igual a 0, queremos jogar
os eventos da morte. Se não for 0, vamos seguir frente e fazer o que
fizemos antes. Então aqui, sempre que for
0 e os jogadores mortos, vamos jogar o evento da morte aqui. E a base inimiga está
morta está definida como verdadeira. E também precisamos pegar
a caixa principal e
a colisão e desativar essas
colisões apenas para
garantir que não possamos acertar um inimigo morto. Então, tomando isso e
dizendo sobreposição, e você pode perceber
que está aqui embaixo, temos algo chamado eventos de sobreposição
degenerados definidos. E o que estamos tentando fazer é se você clicar nesta caixa de sucesso, e se você for aqui, estamos apenas tentando
desabilitar este, gerar eventos de sobreposição porque se ele foi desabilitado, não podemos gerar
eventos de sobreposição e, portanto, não podemos mais
acertar o inimigo. Então, vamos definir isso como falso. Deixe-me apenas copiar colar este mais e conectar este. Então, temos a caixa de cabeça e a colisão definida como falsa para que não
possamos atingi-las. E depois disso, precisamos, precisamos ter um tempo de
resposta ou um atraso antes de
gerarmos o inimigo novamente. Então deixe-me fazer
uma nova variável aqui chamada timer de resposta. E vamos flutuar. E vamos pegar esse
temporizador de resposta e dizer atraso. Agora vamos atrasar
com esse temporizador de resposta. E por enquanto, vamos
defini-lo para cinco segundos. Então, vamos compilar e salvar. E por padrão, vamos escrever
cinco segundos assim. Então, depois de cinco segundos, o inimigo responderá. Se você quiser. Você também pode adicioná-lo
à estrutura. Então, todos, todos os inimigos. Terá seu próprio temporizador de resposta. Você também pode fazer isso. Só vou
colocá-lo aqui, não muito importante agora. Então, apenas cinco segundos
para todos os inimigos. No entanto, se você quiser
torná-lo mais dinâmico, você pode adicioná-lo aqui
à estrutura. E para cada inimigo você pode
ter um temporizador de resposta separado. Agora, o que vamos atrasar o código com qualquer
quantidade de segundos eu vou mover isso
aqui, na verdade assim. Ok, então depois
de atrasá-lo com alguns segundos aqui, precisamos redefinir a saúde para 100 ou seja lá o que
fosse antes. Porque agora ainda é 0. Na verdade, precisamos definir qual é a vida máxima
para o inimigo. Então eu preciso voltar para a
estrutura, informações sobre animais. E assim como o que
fizemos pelo jogador, vamos adicionar uma nova variável
chamada max health. E vamos adicioná-lo aqui abaixo dessa saúde e
muda para um flutuador. Essa saúde é algo que
mudamos durante o
jogo o tempo todo, mas este
permanecerá estático. Então, vamos salvar tudo. Deixe-me ir para qualquer base
Compile and Save. E deixe-me voltar
para os inimigos. Então, primeiro o porco aqui. Para o porco, vou
definir aqui nos padrões da classe de
informações de animais. Vamos definir a vida máxima
para algo como 30. Então, começando exatamente como este. E vamos voltar
para o caracol aqui. E para o caracol,
vamos começar com 15 como o máximo de vida, assim como este.
Vamos compilar e salvar. E agora vamos voltar
para a base inimiga. E aqui podemos pegar
as informações dos animais novamente. Podemos dizer conjuntos. Lembre-se de que estamos
definindo a variável, então estamos definindo
esse valor de Saúde. o que está redefinindo-o? Estamos definindo isso com
o máximo mais saudável. Então, vamos arrastar aqui
e salvar a pausa. Vamos pegar o máximo de
saúde e conectá-lo à saúde e ocultar pinos
não conectados. Então, o que estamos essencialmente
fazendo é que estamos tomando o valor máximo de saúde que
escrevemos aqui em porco, caracol. E estamos apenas definindo
esse valor de saúde de volta
ao máximo de vida porque
agora o inimigo
respondeu e só
queremos que ele tenha esse valor máximo de saúde. Certo? Algo assim aqui. E depois de definirmos a saúde, lembremo-nos de
pegar essa informação animal e defini-la aqui para a
estrutura como esta. E então queremos especificar onde queremos
gerar o inimigo. Então, vamos realmente
fazer isso aqui em baixo. Vamos criar uma nova variável
aqui chamada responder. E, na verdade, vamos fazê-lo através
da Interface do Blueprint. Então, vamos aqui e fazer uma
nova função chamada resposta. Vamos compilar e salvar. Vamos voltar para a base inimiga. Chame aqui, responda. Vamos, vamos fazer com que ele passe pelo servidor responda como é claro, chamando seu servidor assim, e depois executando-o através
do servidor e confiável. E vamos executar a
resposta aqui em cima. O que queremos
fazer com a resposta, lembre-se aqui em
nossa árvore de comportamento em local aleatório definido, na verdade só queremos
fazer a mesma coisa. Então, só queremos encontrar
um local aleatório. Então, na verdade, pode até copiar colar, na verdade, vamos escrevê-lo
novamente apenas para praticar. Então, vamos pegar ator da classe, conseguir ator da classe. Nós só queremos obter nossa
navegação Bound Mesh, nav, nav mesh,
volume de rejeição, este aqui. Agora queremos obter os limites dos atores para que
possamos ver o tamanho da malha de
navegação. E a partir disso, vamos quebrar as lágrimas porque só estamos
interessados no eixo x. Lembre-se, estamos
fazendo um jogo 2D, então estamos interessados apenas
no tamanho aqui no eixo x. Não me importo com
o Z ou o y. Então não faremos isso. Só queremos usar
esse valor x aqui. O que queremos fazer aqui, queremos dizer obter um ponto
acessível aleatório no raio. Isso é o que queremos usar. Lembre-se, existem outros,
então obtenha um ponto aleatório
no raio navegável. No entanto, eu quero usar
este em raio acessível, porque se os inimigos aqui em cima, o inimigo está aqui em cima. A coisa é que, se
você tiver ele definido para ponto
acessível aqui no
raio, ele irá surgir. Ele continuará surgindo
aqui na plataforma, para que não goste
aleatoriamente. Se você tem alguns
inimigos aqui em cima, eles não aparecem aleatoriamente
aqui em baixo. Então eu quero mantê-los aqui em cima. E é por isso que estou
usando acessível aqui. Ok, então mais raio, vamos apenas conectar este
x porque agora temos os limites dessa malha de
navegação aqui, e este é o nosso raio. E a origem é exatamente
onde o ator morreu. Então, vamos obter a localização do ator. O inimigo aqui, pegue
a localização do inimigo, essa é a origem da qual
você vai procurar. Essencialmente, vamos
criar uma nova variável. O que queremos
fazer aqui é fazer uma coluna vetorial chamada localização de
spawn. E esse vetor
vamos definir para um representante notificar porque estamos tentando
fazer uma mudança visual. Estamos tentando
gerar o inimigo. E dentro desta costela
notifica a localização do spawn. Vamos apenas dizer
definir a localização do ator. Isso é o que estamos tentando fazer. Tentando definir a localização dos
atores para um ponto aleatório
na malha de navegação. Então, estamos
tentando gerá-lo aqui. A localização da atriz e
a localização real é uma mudança visual porque você está mudando a localização da atriz. E é por isso que o colocamos
dentro de uma notificação de costela. Vamos voltar agora
para o Event Graph. E em vez de aqui, é isso
que estamos tentando definir. Estamos tentando definir essa
variável para o local aleatório. Mas, novamente, lembre-se, só estou
interessado no valor x. Deixe-me realmente arrastar
isso aqui. Então, eu tenho mais espaço. Estamos tentando apenas, como se estivéssemos interessados apenas
no valor x aqui. Então, quebre-o aqui e
deixe-me fazer o vetor aqui. Então, estou separando
os valores para poder alterá-los e não
conectá-los diretamente aqui. Para o x, estou interessado em dx, então geralmente apenas conecto o sotaque porque é
isso que queremos. E para o y, quero
manter os atores y. Então, a localização real. Vou quebrá-lo. E estou interessado apenas em
manter os atores, como os inimigos e a
localização constante. Eu não quero
mudá-lo aqui em cima. E quanto à localização z, podemos novamente usar isso, mas podemos usar essa localização
óssea z. E o que eu quero fazer, vou dizer mais, e vamos tentar dizer mais 20. E deixe-me explicar
por que faço isso. Para a localização z. Lembre-se que o z está aqui em cima, este é o local z. Só estou dizendo 20 porque às vezes pode
haver uma chance de
os inimigos se ligarem aqui e ficarão presos
no chão. Só estou dizendo mais 20 sempre que
você encontrar um novo local. Então, vai
dizer que mais um t n vai empurrar
esse inimigo até aqui. E isso vai
gerar o inimigo aqui. E então ele vai
soltar o inimigo aqui. Porque lembre-se,
os inimigos têm gravidade, então eles não
vão ficar aqui em cima. Às vezes. Só estou tentando evitar
o problema em que eles estão surgindo dentro da
nossa malha de colisão. E eu digo mais 20. Então este aqui em cima. E eles são como, eu não
acho que você vai notar. Como nós percebemos quando
eles surgem aqui
porque tem uma gravidade e
cairá aqui. E se você notar, basta diminuir esse número
para algo menor. Se você fizer
algo muito alto, você notará porque ele
cairá do céu. Então eu acho que 20, não será perceptível. Assim mesmo. E
agora vamos conectá-lo daqui até aqui. Deixe-me empurrar isso um pouco
para baixo. Então, agora estamos definindo
o local aleatório, e vamos realmente
usá-lo aqui em cima. Então, depois de definir os quadris para 100, queremos chamar a resposta, é que vamos
respondê-la. Ele vai encontrar
um local aleatório para o inimigo e ele
vai respondê-lo. Então, lembre-se que
paramos assim quando você está morto, você parou a lógica aqui. Então, precisamos começar a árvore de
comportamento deles novamente. Então eu posso novamente simplesmente
copiar colar isso aqui e conectar
e dizer que começa a lógica. Então agora estamos começando
com a lógica novamente, você está executando a árvore de
comportamento. Lembre-se de ativar as
colisões novamente aqui, para que elas não sejam desativadas. Mais uma vez. Vamos conectá-los assim. Então agora, essencialmente,
o que vai acontecer? Vamos realmente puxar o real
completo Ainda não. Vamos para a morte aqui porque não
fizemos nada. E a única coisa por enquanto é ir para esta
função de desembrulho para os mortos. E o que queremos
fazer é realmente pegar isso e verificar se
os jogadores que não são. Então, se o jogador está morto, só
queremos reproduzir
a animação da morte. Então, vamos pegar isso
e temos esse chamado estados de movimento definido. Na verdade, definido. Vamos ver, você disse que
os movimentos afirmam. Este para o inimigo. Os referidos movimentos afirmam,
e vamos escolher a
morte apenas para verificar se realmente
conseguimos. Então, indo para o imaturo
para o movimento Estados, na verdade não o
ligamos. É muito importante verificar se seu código está realmente conectado. Então, vamos copiar colar
este flip book. Vamos conectar os
sprites ao alvo. Vamos conectar essa morte aqui. E agora para a animação da morte, vamos pegar essa estrutura e vamos acertar este pino aqui
chamado animação de morte. Fizemos isso um tempo atrás
e deixamos conectá-lo. Agora, aqui embaixo, deixe-me esconder
pinos não conectados assim. Agora ele está conectado. E deixe-me verificar
aqui o porco, se definimos a animação da
morte, então temos aqui e a
animação da morte para este caracol. Vamos verificá-lo
nos padrões da classe. E nós dissemos a animação da
morte aqui. Agora vou verificar a
velocidade da animação. Então, indo para os inimigos. E este está indo para o tempo. Na verdade, vou escolher
três quadros por segundo. Então, 1 segundo, vamos reproduzir toda
essa animação. E quanto ao caracol, vamos conferir aqui. Então, oito quadros por segundo. Sim, acho que está tudo bem. Sempre podemos
mudá-lo se precisarmos. Vamos voltar para a base
íntima e ir para a
função de desembrulhar para os mortos. Então, vamos reproduzir
a animação da morte e isso é sobre isso por enquanto. Então, vamos clicar em jogar e
esperar que tudo funcione. Vou acertá-lo agora. E, na verdade, deixe-me verificar meu dano de acertos porque eu não quero
fazer isso para sempre. Então, vamos
ver onde nós fizemos isso. Nós fizemos isso em vez
de blueprints e o jogador, base de jogadores. E então vamos para
essas informações do jogador aqui. E para o dano base. Então, a saúde
do caracol é 15. Na verdade, vou colocar
dez como meu dano base. Então eu bati o caracol duas
vezes e ele morrerá. Então batendo no caracol, os outros caracóis
e todos esses. E você pode ver que está morrendo agora. Só precisamos pausar essa animação para que ela
não seja reproduzida para sempre. E você pode ver que ele
realmente aparece aqui. Ok, então eu não acho que
precisamos, tipo, não
precisamos pausar
essa animação de morte. Você pode fazer isso se quiser, assim como o que postamos com a animação de corda
para o jogador. Mas acredito que faremos uma animação desvanecida e o
desvanecimento fará com que ela desapareça. Portanto, na verdade,
não
importa se a animação dos inimigos
aqui é publicada ou não. Mas você pode ver aqui
que eles estão gerando, eu sei no chão,
então temos que consertar isso. Ou é porque o
modo de caminhada precisa ser definido. Então, vamos realmente como
agora, acho que está tudo bem. Vamos trabalhar no desvanecimento. Porque com o desvanecimento, podemos estar usando isso para definir o modo Walking
e loucas dentro
da animação da morte porque
você pode ver que está funcionando, mas é porque
você pode ver aqui, se eu voltar para a
base inimiga e dentro daqui, vamos para o Event Graph. E lembre-se que dissemos o modo de
movimentos para nenhum, e nunca
o definimos para andar novamente. Então é por isso que estão presos como se eles não estivessem realmente
presos no chão. Acredito que seja porque não gostamos que
não tenhamos dito isso para caminhar. E você pode fazer isso
agora mesmo dentro da animação
da morte ou
do evento da morte aqui. Mas acho que
faremos um efeito de desvanecimento. E com isso vamos
definir o modo Walking. Então, vamos passar
para o próximo.
90. Fade inimigo de Respawn: Tudo bem, então aqui na base, vamos agora fazer um efeito de desvanecimento
para quando o inimigo dado. Deixe-me ver se conseguimos
estruturar isso melhor. Agora temos a
animação da morte aqui, temos a animação de
resposta de spawn. Você pode apenas tentar fazer
a animação de desvanecimento aqui. Vou voltar à
minha Interface Blueprint e fazer uma nova função chamada, vamos chamá-la de ator fade. E vamos fazer um booleano
e chamá-lo de ser desvanecido. Então, só para ver se ele
deve desaparecer ou não. Vamos voltar aqui e rolar esse evento chamado atrofiado. E vamos fazer eventos de servidor. Então, eventos personalizados que passam
pelo servidor chamado atrofiado. E vamos executá-lo por meio de
um servidor confiável. E vamos executar o evento
do servidor aqui, ator desaparecer, e vamos
fazer um novo booleano. Então, todas as mesmas coisas que
temos feito até agora. Agora vamos
conectá-lo. Ok, então agora temos esse ator se desvanecendo. Vamos promover isso
para uma variável. E eu não sei se precisamos
fazer isso em uma
notificação de representante por enquanto. Deixe-nos deixar que seja
assim por enquanto. Então, o que estamos tentando
fazer é que estamos tentando alimentar o inimigo quando ele morre. Então, aqui e
a morte inimiga, na verdade, estou apenas desvanecendo
aqui antes de eu, na verdade, depois de definir isso como falso, podemos apenas alimentar o inimigo
antes do temporizador de resposta. Então deixe-me não remover, mas mova isso aqui e chame
o evento de fade do ator aqui. Então o ator se desvanece. E
vamos defini-lo como verdadeiro. Ok, então o que deve acontecer
quando o desvanecimento for verdade? O que é verdade? O que preciso fazer
é chamar uma linha GDT. Então lembre-se que fizemos
uma linha do tempo antes. Vamos fazer isso agora de novo. Então, clicando aqui, e vamos
chamar esse ator principal. E vamos reproduzi-lo
desde o início. Então, o que precisamos fazer aqui, o objetivo desta linha do tempo é desaparecer a cor do inimigo. E lembre-se de fazer
o efeito de desvanecimento, você tem que ir para esse inimigo. E, novamente, defina esse
material para um material translúcido e
sem iluminação porque
você não pode desbotar essa cor diretamente como ela
desaparece de repente. Você não pode gostar que não
haja passo intermediário. Ele só aparece e
desaparece assim. Então, temos que configurá-lo
para translúcido novamente, assim como o jogador que fizemos
com o efeito piscando. Então, vamos para a base
inimiga aqui. E, na verdade, vamos fazer
isso aqui está morto. Então, vamos fazer isso antes de desaparecer. Então, quando o jogador estiver morto, vamos lá está morto. E aqui podemos pegar esse material
brilhante e dizer Set. E vamos defini-lo para o que é
chamado de material de
sprite
translucidez , translúcido e sem iluminação. Então agora estamos
sentados e vamos defini-lo. Lembre-se de colocá-lo de volta aqui sempre que o jogador não
for mais assim. Então, para material de sprite
mascarado e mascarado. Ok, então agora dissemos
o material para isso e podemos alimentar o
jogador ou desaparecer o inimigo. Vamos até a linha
do tempo aqui. Ok, então estamos
tentando definir cores lineares. Então deixe-me fazer uma nova
variável e
chamá-la de cor de desvanecimento de ator. E vamos transformar a
nova variável aqui em uma cor linear aqui. E vamos pegá-lo e defini-lo. Então é isso que
estamos tentando definir. Estou transformando isso em um naufrágio. Notificar. Porque lembre-se que
isso é uma mudança visual. Estamos mudando o, o alfa do jogador, o que
significa que estamos tornando-o opaco. Então, ir aqui e
defini-lo para uma retina phi. E o que estamos tentando fazer
aqui na função unwrap é que estamos tentando pegar
esse sprite e dizer sets. Acredito que foi primeiro
chamado de cor Sprite. Sim, é de cor brilhante. Isso é o que estamos
tentando definir aqui. E vamos pegar esse ator de cor
falsa e conectado. Então, vamos definir a
cor e vamos
defini-la ao longo do tempo, porque
estamos
atualizando-a constantemente por meio
dessa linha do tempo. E o que estamos tentando fazer é usar uma nota de loop. Então, ele tentou usar um nó de loop. E procurando por loop, você pode encontrar este
como podemos usar este,
mas acredito que uma ideia melhor, como se você pudesse quebrar isso. Você pode ver, pegar isso
e você está certo, fazer, criar cores lineares. Dessa forma. Você pode alterar o alfa
aqui por meio de um flutuador. E, na verdade, ele pode usar apenas um nó de loop porque
isso é um float. No entanto, uma maneira melhor de fazer isso. Na verdade, existe um loop para
uma cor linear especificamente. Então, ele pode usar isso em vez disso. E você pode
percorrer cores lineares. Em vez de fazer isso
aqui, deixe-me excluir isso. E aqui para o loop você pode
simplesmente conectá-lo assim. E para a primeira cor, então começamos por
sermos apenas nós mesmos. Então, aqui 1111, todos
sendo definidos para um. Isso fará apenas os pixels como apenas temos nosso
personagem sem qualquer cor. E o segundo. Eu só queria fazer 1111 novamente, mas para o Alpha, então a opacidade
que queremos definir para 0, na verdade 0, então
vai desaparecer. Vai passar de 0 para um. Como se este fosse 0 e
depois vai para um. Então, ele vai
desaparecer de 0 para um. E queremos fazer isso sem problemas. Então, em vez de apenas
escrever um aqui, se fizermos
isso
sem qualquer outra coisa , ele vai na verdade, simplesmente desaparecer
quando começarmos o jogo. Mas queremos ir, queremos
ir de 0 para um sem problemas. E é por isso que
usamos uma linha do tempo. Então, clicando duas vezes
na linha do tempo, vou fazer uma
nova pista flutuante aqui. Vamos chamá-lo de fade alpha. Aqui, vamos clicar com o botão direito do mouse
e fazer dois. Na verdade, deixe-me fazer três
pontos aqui e você verá o porquê. Então, no momento 0, quero que o valor seja 0. Vamos realmente fazer o
comprimento deste 1 segundo. Então, na época, então
o último ponto aqui, então primeiro é 00, o último ponto no momento um, eu quero que seja um. E este
no momento de 0,75, eu quero que fique 0 ainda. Então, não quero desaparecer
o inimigo imediatamente. Quero desaparecer
cerca de 0,75 segundos. Então, ele vai reproduzir a
animação um pouco, e então ela vai
desaparecer a animação. É assim que você
pode fazer isso também. Então você não precisa fazer
isso assim, onde ele simplesmente
desaparece com o tempo. Eu só vou ser
infiel assim até que ele comece a desaparecer rapidamente aqui no
final da animação. Então, vamos aqui e vamos
conectar o alfa agora. E agora temos essa linha do tempo
suave que vai
desaparecer nossa animação. E agora o que podemos
fazer é ir até aqui para o nosso código
após a morte. Vamos, na verdade, agora, na verdade, já
fizemos isso aqui. Então o ator se desvanece,
deixe-me tentar tocá-lo e
ver o que acontece. Se eu jogar agora. E eu mato alguns inimigos. Você pode ver que eles desaparecem e
isso realmente não importa. Como se nossa animação
ainda estivesse em loop como antes, mas nós realmente não a vemos
porque estamos encaixando o inimigo. Então, se eu tentar
matar este agora, você pode ver que ele
reproduz a animação e então ela desaparece depois disso. O que é muito legal. E deixe-me, na verdade, antes de fazer qualquer outra coisa, deixe-me remover minhas
colisões aqui. Não quero mais
vê-los. Então, indo para o porco,
acredito que acabamos clicar em um desses para que a caixa de cabeça
esteja escondida no jogo. Na verdade, acredito que seja
feito através da base inimiga. Então aqui escondido no jogo. Eu só queria
acertar minhas caixas de cabeça assim e vamos vender. Então, acerte ou
esconda a
colisão de ataque de jogadores escondida no jogo. Ok, então agora temos
essa animação desvanecida, mas lembre-se que temos dois
desfavorecidos em algum momento. Eu vou desfasar imediatamente quando encontrar meu local de desova. Então, logo antes de
começarmos a lógica, vamos iniciar o processo de
desdobramento. Então o ator se desvanece, vou
chamar o mesmo evento. E em vez de ter
isso marcado como antes, agora temos isso desmarcado. E isso significa que ele
vai se desdobrar. A maneira como fazemos isso está aqui.
Qual é a linha do tempo? A linha do tempo está aqui. Em vez de jogar desde o início, vamos realmente fazer
uma filial aqui. Então, vamos pegar isso e fazer
uma ramificação e conectar. Então, se for verdade,
se estivermos desaparecendo, ele vai jogar desde o
início como fizemos antes. No entanto, se você
não estiver mais desaparecendo, então ele vai ficar falso. Na verdade, quero jogar
esse reverso do final. E vai passar
desse invisível para visível. Então, na verdade,
vai desaparecer no meu personagem. Isso é essencialmente
feito se você estiver configurando como desmarcado
e você adicioná-lo aqui, o desmarcado, que é o falso para reverter do final. Lembre-se, na verdade, eu
quero fazer isso aqui. Então, no modo de caminhada,
lembre-se de que não
definimos o modo de movimento. Então, se eu voltar aqui no, qualquer dano, definimos o modo de
movimento para nenhum. Vou copiar isso. Vou descer
aqui, colá-lo. E em vez de
defini-lo para nenhum, eu vou
colocá-lo para andar novamente. Caso contrário, vai ficar preso
e nunca, nunca se mexer. Então agora temos o modo de trabalho, então estou tentando ver
o que estamos perdendo. Então, na verdade, há
uma coisa que estamos perdendo. O que estamos
perdendo é Nunca
especificamos quando o personagem não
está mais morto. Então, aqui nós definimos que isso seja verdade. E lembre-se que temos
que defini-lo como falso porque aqui está dentro, está morto. Definimos aqui por padrão, configuramos o material de
volta para a máscara. Então, temos que fazer isso, e acho que vou fazer isso. Então, em vez de fazer isso aqui, então você não pode, você não pode simplesmente
entrar aqui e dizer isso. Porque lembre-se que você está, você está interpretando
um ator desvanece-se, que
é uma linha do tempo. E você realmente
vai definir, como se você configurasse isso aqui, a morte, você vai definir. Este material é mascarado sem iluminação, o que não dá a essa linha do tempo a chance de mudar a cor
de invisível para visível. Porque lembre-se quando você tem o material como
padrão para mascarar fendas, você não pode ter essa transição
suave com o desvanecimento do inimigo. Então, se você fizer isso aqui em cima, ele vai fazer
isso instantaneamente logo após o ator desaparecer. E vai mudar
o material para mascarar sem iluminação, que não dá a linha do tempo ao acaso tempo suficiente para fazer isso aqui para
essa transição de, de como o desvanecimento em vigor. Então, vamos realmente fazer isso
aqui na linha do tempo. Então, quando a linha do tempo
terminar em desvanecimento, podemos então definir essa
morte como falsa. E não queremos fazer
isso o tempo todo
porque lembre-se, mesmo que o campo esteja definido como verdadeiro e você está jogando aqui, ele vai jogar isso como falso porque realmente não precisamos faça isso sempre que você estiver desaparecendo, o que tem feito aqui, não
queremos
defini-lo como falso, como a morte,
porque também temos um temporizador de resposta e suas
necessidades de ir algum tempo. Vou fazer um booleano aqui. Este, novamente, o feed. E vamos fazer um booleano. Na verdade, é um tipo de feed que não
é realmente explicativo. Deixe-me mudá-lo para
depois de desaparecer. Deixe-me definir este
para replicá-lo porque lembre-se de que ele está
sendo executado no servidor, então o cliente
precisa saber sobre isso. E deixe-me desaparecer esse ator, definir um ramo e
vamos conectá-lo aqui. Então, quando o inimigo estiver desaparecendo, não
faremos nada. Mas quando o inimigo
não está mais desaparecendo, o que significa que você está aqui. Em seguida, vamos
executar esse código, executar essa linha do tempo e
a linha do tempo termina. Vamos dizer,
sim, o ator não está desaparecendo. Estava definido como falso. Então, vamos realmente
definir isso como falso também. Então agora podemos fazer isso dessa
maneira em vez de lá em cima. Tudo bem, então agora vamos
compilar e salvar, e espero que tenhamos
consertado tudo. E vamos clicar em jogar e
vamos matar alguns inimigos. Então, temos
muitos inimigos morrendo. E vamos ver se eles
respondem corretamente. Então agora este
responde a este, responda. Esses respondem. Ok, então parece que
tudo está funcionando corretamente. E se eu bater neles uma vez, eles vão e você pode ver que há realmente
um pequeno erro. Eu acredito que este não gostou que não houvesse eventos de
sobreposição gerados com este. Então, o problema aqui com
o problema sobreposto é que esqueci de configurá-los como verdadeiros. Então nós os definimos como falsos aqui, mas no final,
esqueci de defini-los como verdadeiros. Então, precisamos gerar eventos de
sobreposição. Então, vamos compilar e salvar. Vamos voltar a
jogar o jogo. E vamos tentar novamente.
Então, vamos atingi-los agora. Eles vão morrer. Obviamente, precisamos de alguns efeitos
sonoros muito em breve. E você pode ver que eles estão
respondendo corretamente.
91. Colocação de nível inimigo: Esta lição é um pouco diferente. Não temos, não
vamos codificar nada. E agora vamos colocar os inimigos ao
redor do nível. E você pode fazer isso
com o código. Assim, você pode simplesmente fazer
um evento de desova e simplesmente gerar todos os
inimigos automaticamente quando você entrou no jogo e configurá-lo
como locais aleatórios. Mas acredito que se você pode
fazer algo sem código, então sugiro que você faça isso sem código
porque lembre-se, codificação, você vai usar
alguma memória do jogo. E por que você vai
fazer isso quando você pode simplesmente vir aqui e
colocá-los de graça. Isso é muito otimizado. Você não precisa escrever código. Portanto, sempre que você puder evitar
escrever todo esse código, tente evitar loops. Tente evitar escrever esse código. Então, se pudéssemos, por exemplo, evitar escrever esse código, eu nunca o teria escrito. Mas como já gostamos, já que precisamos escrever isso, para fazê-lo funcionar,
temos que escrevê-lo. Mas para os eventos de desova, como em vez de criar um código de
desova para os inimigos, se você puder entrar aqui como se fosse adequado para o seu jogo. Claro, alguns jogos precisam de código
de geração para fazê-lo funcionar. Mas para este caso,
substituímos os inimigos. Uma vez que
colocamos os inimigos, podemos
simplesmente pegar e colocá-los
onde quisermos. E é isso. Portanto, não precisamos codificar nada aqui para
a base inimiga. Então, se eu voltar, a coisa que fizemos
com a base inimiga aqui para a resposta é que estamos basicamente apenas escondendo o inimigo e depois revelamos
ajudando o inimigo. Mais uma vez. Não estamos realmente removendo o inimigo permanentemente
do jogo. No entanto, lembre-se, no seu jogo, se você está fazendo
algo personalizado e não seguindo
esse curso completamente, se você quiser
destruir o ator, como removê-lo completamente
do nível. Porque se você apenas
alimentá-lo assim, se você desaparecer, você é louco. Como se o ator
basicamente ainda estivesse lá. Se eu for aqui para o inimigo e definir a caixa principal
para não ficar escondida no jogo. E você pode ver
como se eu jogar o jogo agora, eu acertei esse inimigo
aqui e um dado. Você pode ver que a caixa de colisão
ainda está ouvindo que o inimigo ainda
está aqui. Está apenas desbotado. Então, isso é bom para
fazer nessa situação porque temos como uma quantidade
especificada de inimigos. Por exemplo, só preciso de
quatro caracóis e meu nível. Então eu apenas desvaneci e
respondo em outro lugar. No entanto, se você
quiser destruí-lo completamente do nível
e nunca ter este ****. Porque se você tiver uma
lagoa ainda gerada, ela ainda executará
esse código de planta e não será otimizado se você continuar gerando
inimigos e nunca os removerá
do nível. Então, se você quiser
removê-lo completamente, você pode usar este
dizendo Destruir Ator. Destruir atores irá
removê-lo completamente do jogo e pode
tentar ver o que ele faz. Então, se eu matar isso aqui e ele vai
desaparecer em algum lugar, deixe-me matar um pouco mais
e matar este também. Então você pode ver agora eles estão
realmente como se estivessem
respondendo em
outro lugar e, após o código de resposta, eles estão
sendo destruídos. Então, agora eles são removidos
totalmente do jogo. Isso é otimizado porque
você não executa todo esse código para
esse inimigo no jogo. No entanto, para este jogo, eu só tenho quatro
inimigos o tempo todo. E eu apenas o desvaneci e
respondo em outro lugar. Então, estou mantendo
esses quatro inimigos. Nunca criei cinco inimigos
ou seis ou sete inimigos. Então, se você fizer isso, lembre-se de
destruir o ator. Se não, se você está
apenas fazendo isso, você pode simplesmente respondê-lo
em outro lugar e no nível. Então, agora podemos evitar
escrever código para a resposta aqui para que
possamos substituí-los. Então, o que vou começar
a fazer aqui é apenas colocar isso em um. E às vezes você vê inimigos se atravessando um pelo outro. E isso é porque eles têm, todos eles têm um no y. Então às vezes eles simplesmente
entram um no outro. Eles cortam assim. Você pode ver que há algum
recorte acontecendo. E isso ocorre porque eles
têm o mesmo valor y. Então, o que você pode
fazer aqui manualmente, levará algum tempo,
mas você pode simplesmente escrever, por exemplo, um para este ,
o segundo,
vou escrever 1.1. E para o terceiro, vou escrever 1.2. Portanto, nunca se cortarão uns
aos outros. Você pode ver agora eles estão
na frente um do outro. Eles nunca vão grampear.
E você pode fazer isso. Então segure Alt e arraste para copiar, e este é 1.3. E arraste novamente 1 para este 1,51. Então, algo assim, e você pode colocá-lo aqui, arrastá-lo novamente, 1.6. Então, vou
ter esses inimigos. E aqui para os porcos, vou adicionar
alguns porcos aqui. Então 0 e y. Para o y, eu vou
começar com um novamente porque o jogador
na verdade não é o jogador. Essas peças estão em 0, então eu não quero que elas
fiquem atrás das peças. É por isso que comecei um. E vamos arrastá-lo
novamente e dizer 1.1. E às vezes, como se
1.1 não for suficiente, você pode apenas dizer 1.1.15
ou algo assim. Então 1.2 para isso, 1,31, para este, sempre
podemos verificar
se eles estão recortando, podemos aumentar esse
tamanho entre eles. E para o jogador, o jogador está começando em dois, então o jogador está sempre
na frente dos inimigos. Vamos clicar em Play. E vamos verificar e tentar ver se
há recortes. Deixe-me realmente ir para a base
inimiga e desativar esse jogo de extremidade
escondida de colisão ou caixa de sucesso aqui. Então eu posso vê-los com mais clareza. Então agora você pode dar uma
olhada neles e ver se eles estão
recortando um dia, passar um pelo outro. E às vezes, quando eles
recortam, você pode aumentar
esses números de separação. Você pode apenas aumentar
o valor y. Acho que está
bem, com boa aparência. Novamente, você pode aumentar
a separação e o y, se quiser. Mas isso é mais, esta é uma maneira mais
otimizada de fazê-lo. Se você conseguir se safar de
algo não programando, você pode realmente fazer
isso e ele será mais otimizado. Mas às vezes você tem que
escrever código e não
pode realmente evitá-lo. Então, agora que
colocamos todos os inimigos
no nível, vamos salvar tudo e vamos para
a próxima lição.
92. Como acertar, morte e respostas SFX: Chegamos ao fim e está quase na hora do sistema de
nivelamento. E antes de fazermos isso, vamos realmente adicionar
alguns efeitos sonoros e fazer algo
interessante aqui. Acho que soa muito melhor se quando você adicionar
alguns efeitos sonoros. Vamos para o áudio. E eu incluí estes
para você dentro dos materiais
do curso
e nós os temos aqui. Só usamos o salto até agora. Então, basta selecionar todos eles
agora, exceto pelo salto. E deixe-me arrastá-los para
minha pasta de áudio aqui. E então temos todos esses. Vamos clicar em arquivo e salvar tudo. Agora, o que você pode fazer é subir esse nível com o botão direito do mouse e
criar uma bola de sinalização sonora. É um sinal de som subir de nível. E vamos
usar isso mais tarde. Você pode clicar no play para
ouvir o que parece. Apenas algumas histórias, efeitos
sonoros. E para este ataque, você pode clicar com o botão direito do mouse
e criar algum Q, chamá-lo de ataque e fazer a mesma coisa com
os acertos de ataque, chamá-lo de ataque, acertos. o botão direito do mouse para a
morte e crie uma sugestão sonora e chame
fila de som, profundidade. O salto que já fomos feitos. Então, indo e o nível sobe. Fizemos este para escolher a morte, soar sugestão, escolher a morte. E vamos fazer isso pela morte
do caracol também. Dívida de caracol. E nós temos uma resposta, este responde,
soa, responde. E vamos ver se estamos
perdendo alguma coisa. Então, temos o texto morte
agora, temos tudo agora. Então você também pode fazer
isso pela música. Temos algumas músicas
chamadas música de som,
na verdade, apenas
chamada de Tennessee, eu vou chamá-la de gênese. Esta é a música. Certo? E não vou conectá-lo agora porque
acho que vai ser irritante quando estivermos depurando o jogo e continuamos
tocando a música. Então, vou manter
este fora por enquanto. Então, o primeiro que podemos fazer é quando estamos atacando
com o jogador. Então, vamos até o jogador
e vamos para a base de jogadores. E assim, para o ataque, estamos fazendo isso aqui. Então, temos o ataque. Estamos passando pelo servidor e lembramos de efeitos sonoros. Eles têm que
passar pelo cliente. Então, se você quiser que os efeitos
sonoros sejam ouvidos apenas por
você, você quer chamar um evento personalizado e
executá-lo através do cliente. No entanto, se você quiser que o efeito
sonoro seja ouvido por todos ao seu redor,
você precisa. Na verdade, esqueci de
usar meu atalho aqui para este evento personalizado. Atalho muito rápido. Se você quiser fazer com que o efeito sonoro
seja ouvido por todos, você tem que executá-lo
através de um multicast. Multicast
se todos ouvirem, forrados, somente
se você ouvi-lo. Acho que todos os clientes
devem ouvir esses sons, então deixe-me fazer isso. Então deixe-me fazer
eventos personalizados e chamá-lo de ataque MC. E para este,
vamos dizer tocar som no local. Então, vamos
reproduzir o som no local onde o
jogador está atacando. E vou
arrastar essas variáveis nos eventos e chamá-lo de efeitos de ataque
S, pois sons, efeitos sonoros e
localização estão bem. E agora vamos jogá-lo. Lembre-se de que o multicast só pode
ser executado pelo servidor. Para o ataque, temos
dois sons diferentes. Temos 14. Aqui, vamos ver o ataque. E temos um para
o kit de ataque. Então, sempre que você acertar algo, então vamos, vamos fazer isso aqui. Então, aqui estamos verificando se
acertar qualquer inimigo. E se formos, vamos
jogar o sucesso. Então, aqui,
deixe-me chamar o ataque MC. E vamos empurrar esse código um
pouco assim, e você sempre pode
aproximá-lo mais tarde. Havia reproduzir
esses efeitos sonoros e ele vai
tocar esse efeito de sucesso. O que você pode fazer
para melhorar na verdade, manter a
consistência deste jogo, podemos ir para a estrutura e informações
do jogador e apenas
adicionar variáveis para os efeitos de ataque
e escolher o sinal de som. Para o próximo, você pode
apenas fazer um hit técnico S efeitos. Então, temos que atacar,
atacar sons. E vamos realmente fazer
aqui na base de jogadores, vez de fazê-lo separadamente
dentro de Luke e Serena, vamos realmente fazê-lo
aqui na base de jogadores porque eu só tenho um
som para todos os jogadores. Então deixe-me ir para as informações do jogador. Basta configurá-los aqui em vez
de em cada personagem. Agora eu só procuro por
um ataque técnico e de ataque. Então, todos os personagens terão o mesmo efeito sonoro. Então, vamos voltar para
a base de jogadores. E aqui, agora podemos
pegar as informações do nosso jogador. Ótimas crianças, e deixe-nos esconder pinos
não conectados e mostrar
meu ataque. Na verdade, um sucesso tecnológico para
este. E conectado aqui. Então, qual é a localização? A localização é apenas
a localização deste jogador. Então, obtemos a
localização real e conectamos. E sempre que, na verdade,
em vez de fazer isso, acredito que
vamos ter um bug porque isso está sendo executado
no servidor e o cliente nunca
poderá ouvir isso. Então, o servidor quando
eu bater em algo, vou
ouvi-lo, mas acredito que como cliente não vai
ouvir nada. Vamos tentar. Na
verdade, não está funcionando, então podemos realmente fazer isso. Mas se você quiser, você
também pode , às vezes, eu
acho que é muito mais limpo apenas
salvar isso e, na verdade, apenas
passar por aqui. Mas, na verdade, vamos
mantê-lo assim por enquanto. Vamos apenas Controlar Z. Só vou
mantê-lo assim. Deixe-me copiar cole-o aqui. Se estiver funcionando, Por que não? Vamos arrastá-lo aqui
e conectá-lo. E para este, na verdade, o que estou tentando fazer
por esse ataque? Na verdade, precisamos passar
pelo atraso aqui, assim. Ok, então aqui embaixo, vamos tocar
o efeito sonoro onde não atingimos nada. E aqui embaixo, vamos pegar
esta cópia colada aqui. E, em vez disso, podemos
mostrar os efeitos de ataque, ataques e obter a localização dos atores aqui mais
uma vez, assim. Então agora o que podemos jogar e deixe-me apenas
jogar para os clientes, só para ter certeza. Jogando conosco com os clientes.
Agora estão batendo. Você pode ver. E se eu não bater sim, isso soa bem. Certo. A próxima coisa é que queremos
o caracol e a profundidade do porco. Então, vamos até o inimigo e vamos ver
onde jogamos isso. Então, tivemos isso danificado
correndo pelo servidor. Em seguida, ele vai jogar
este evento de morte aqui, e vamos realmente
adicioná-lo a isso. Então, a morte vai passar
pelo servidor e
do servidor queremos
executar um multicast. Então deixe-me juntar esses
dois, mas isso
aqui eu vou
fazer um evento personalizado chamado MC death e
executá-lo em multicast. Aqui. Mais uma vez, toque som, localização M e apenas
chame-o de morte inimiga, ou apenas morte ou sem efeitos
imediatos.
Então, coisas assim. A localização. E agora, para este, podemos
chamar a morte multicast. E para esta morte multicast, deixe-nos agora realmente
me deixar arrastar tudo isso, sempre ter o problema
espacial aqui. Para este, para
a morte inimiga, vamos realmente fazer
a mesma coisa. Então, para a estrutura, podemos adicionar uma nova variável
chamada S Effects. E vamos
transformá-lo em um sinal sonoro. Salve aqui. E deixe-me ir, agora deixe-me ir para a base
inimiga primeiro, compilar e salvar, e depois
ir para o inimigo, para o porco. E então precisamos ir
aos padrões da classe para o preenchimento de animais
e, em seguida, você tem que selecionar o efeito sonoro surdo. Deixe-me procurar por porco
e selecionar este. Escolha isso, compile. Vamos para um caracol. E o caracol vamos
usar esse caracol, morte. Deixe-me voltar para
a base inimiga. Agora, o que podemos fazer é arrastar
essas informações de animais, quebrar Crianças, esconder pinos não conectados
e eu posso usar este, morte como efeitos conectados. E onde fica a localização? Lembre-se de que estamos
dentro de qualquer base, então podemos dizer
obter localização do ator porque está onde quer que esse inimigo esteja, assim. Ok, então vamos
salvar compostos quando clicarmos em Play e ver se
funciona. Se ele morrer. Sim, tocando o som dele. Então este estava
jogando algumas vezes. Isso é engraçado. É porque temos que
realmente fazer isso aqui como um, o inimigo está realmente
morto. Isso foi engraçado. Estava jogando várias vezes. Então podemos pegar isso
e dizer ramo. E somente quando o inimigo morre, queremos tocar o som, não quando ele responde. Então, vamos clicar em
jogar e tentar novamente, só para ter certeza de que funciona. E, na verdade, há um pequeno
bug enquanto estou testando isso. Você pode ver que realmente
funciona meu personagem aqui em cima. Precisamos consertar isso. Então deixe-me realmente tentar o som primeiro antes de
consertarmos qualquer coisa. Então deixe-me ficar aqui em cima e jogar. Eles têm um pouco mais de saúde, então eu tenho que tentar novamente.
Certo, isso também funciona. Incrível. Então o som funciona. Precisamos corrigir esse problema de
letra em um pouco. A próxima coisa que queremos fazer é reproduzir o som da morte dos jogadores. Então, indo para a
base do jogador, indo para o, qualquer dano, e quando
o jogador morrer, então aqui na morte,
quando estiver definido como verdadeiro. Então, vamos voltar à
morte aqui embaixo. Eu defini para verdade,
queremos jogar o multicast. Então, vamos fazer isso
aqui para tornar mais espaço chamar uma morte
multicast de eventos personalizados. Vamos executá-lo através
do multicast confiável e depois reproduzir
som no local. Então, estamos fazendo a mesma
coisa de novo. É bom praticar apenas
fazer isso de novo e de novo. E de repente você
verá a si mesmo e especialista nisso. Então, vamos fazer a
morte como efeitos. E para este novamente, precisamos ir para a
estrutura para o jogador em um novo som chamado efeito sonoro
da morte. Salvar. E todos os jogadores têm
os mesmos efeitos sonoros. Vou clicar nisso
e no jogador, informações do jogador. E mude isso
aqui até a morte. E este. Ok, então indo para este,
a profundidade está definida. Agora, deixe-me realmente
esconder pinos não conectados. E aqui vamos
chamá-los de morte multicast. Agora estamos chamando aqui
e colocamos esse efeito de texto. Vamos agora pegar as informações do jogador e deixe-me criar mais espaço. Aqui podemos ver o break e os pinos conectados
Haydn e
podemos usar a morte
como efeitos aqui. E este aqui, podemos
dizer obter a localização do ator. E deixe-me arrastá-lo para cima. Há mais espaço
para trabalhar. E arraste tudo isso para baixo. Assim mesmo. Então agora estamos
tocando o efeito sonoro. Deixe-me realmente morrer
e testá-lo. Então, se eu apenas encontrar
essas fotos aqui, você pode ver que você tem
esse efeito sonoro. E também agora precisamos de efeitos sonoros de
resposta. Então deixe-me ir até aqui e
dar uma olhada no código. Talvez você só precise
colocá-lo na morte falsa. Então, vamos dar
uma olhada no código. Então, quando estamos
morrendo ou não morrendo. Então, isso não é mais isso. E reproduzindo isso, e vamos ver onde realmente
definimos a morte como falsa. Não me lembro de
onde fizemos isso. Então, vamos tentar gostar do que você pode fazer
agora para encontrar algo. Este é um bom exemplo de ensino. Se eu gostar agora, não me lembre onde eu
realmente fiz o falso. Posso clicar com o botão direito e
dizer encontrar referências. E então eu posso
apenas encontrar referências
dentro desse projeto, o que eu acho que é
bom porque acho que é usado dentro daqui. Mas se você quiser,
você pode clicar nisso. Encontre em todos os projetos. Na verdade, isso vai encontrar essa função usada em
todos os seus blueprints. Então ele pode realmente fazer
isso para rastrear onde ele realmente usou
o evento da morte novamente. Então aqui eu o encontrei
no Widget Blueprint em nossa interface principal. Então, clicar duas vezes nele aqui levaria
você ao menu I. E foi aqui que
fizemos isso, onde clicamos,
Ok, e dizia que a
morte era falsa. Agora vamos fazer isso
aqui e depois na morte. Então, vamos voltar para
a base de jogadores. E quando a dívida é falsa, vamos tocar a morte
multicast onde é como se tivesse os efeitos sonoros de
resposta. Então, o que podemos fazer aqui é
apenas em vez de fazer um novo chamado
multicast responder, podemos usar essa morte. Então, vou tirar
isso um pouco. O que podemos fazer aqui em baixo é
chamado de morte multicast. E agora o que podemos fazer é
voltar às informações do jogador, criar uma nova variável chamada efeitos sonoros de
resposta. E é uma sugestão sonora
indo para a base inimiga. Agora, clicando nas informações
do jogador, definindo o efeito sonoro para
responder, compilar e salvar. Agora vamos para o,
vamos até aqui, na verdade,
pegue essas informações do jogador, quebre-o ou um pino não conectado. Então, vou usar
a resposta. E então podemos
conectá-lo aqui e obter a localização do ator novamente. E agora vamos tocar
o efeito sonoro de resposta. Então deixe-me tentar, e acredito que funcionará. Então ele joga esse Santa Fe. E se clicarmos em OK. E você pode ver que estou
tendo essa resposta e efeito. Certo, incrível. Então, trabalhar no cliente e provavelmente
funcionará
no servidor também porque isso é executado pelo servidor. Então, esses foram todos
os efeitos sonoros. Se você quiser, você também
pode ir em frente e adicionar a música aqui. Este aqui. Você pode simplesmente jogar
este e este
provavelmente vai jogar do lado do cliente. Eu não acho que você deve
jogar isso através um multicast porque
os jogadores estão naturalmente ouvindo os
sons juntos como se não
estivessem compartilhando
a mesma trilha sonora no mesmo segundo. Basta jogar isso com os
clientes e tentar praticar. Talvez apenas tente entrar
lá e fazer isso sozinho. Mas vou fazer
isso provavelmente no final
deste curso porque é um pouco chato tocar a música
o
tempo todo enquanto estou,
enquanto estou falando. Então, vamos clicar em
Arquivo e Salvar Tudo. E vamos passar
para a próxima lição.
93. Como corrigir o bug de morte da escada: Agora vamos corrigir esse bug de
escada que vimos no vídeo anterior. Então, aqui no topo. Então, quando eu for danificado aqui, vou ficar preso dentro do,
na verdade, vamos tentar novamente. Vou ficar preso aqui dentro
desta caixa de colisão. E isso ocorre porque, então deixe-me realmente
fechar este jogo e voltar para a base de
jogadores e jogadores. E a razão para isso está
aqui em nossos seres ISClient. Então, quando definimos está
subindo para falso, e é que não é verdade. Você pode ver aqui que estamos mudando o tipo de colisão para ****. E lembre-se anteriormente que fizemos
esse jogador de escalada para ignorar isso, essas caixas de colisão aqui em cima. E quando mudamos para é
como tipo de colisão para ****, então estamos realmente
ficando
presos nessas caixas de colisão. Então é isso que
estamos tentando fazer. Então, temos que fazer alguma pequena re, ou pequena reprogramação aqui. Então, clicando neste,
deixe-me esconder esse pino. Ok, então para começar com isso, vamos realmente voltar. Achei que a melhor solução
para fazer isso é ir
para os mapas de mosaico e dentro
dos mapas de mosaico aqui. Então, temos algo chamado
insight liderado nacionalmente, minimizamos isso e vamos para a
escalada e escalada. Então, no cliente que está sendo feito, fizemos algo chamado caixa de colisão
superior. E aqui nós colocamos se você
pode subir ou não. E você pode ver essa caixa aqui. Isto é, eu não sei se você pode vê-lo visualmente como se esses
são os bugs na verdade. Aquele acima da letra. Este é o que adicionamos, o que faz com que
você não possa subir. Assim, podemos abranger o botão para cima. Quando você está na
escada, se você se lembrar, você pode tentar assistir ao vídeo da letra se
não se lembrar, mas é um que adicionamos. E em vez de adicioná-lo aqui, deixe-me realmente fazer outra
coisa. Então, no mapa de mosaico
que adicionamos, então esse ator indo
para a viewport, vamos realmente fazer
uma caixa de colisão em torno dessa plataforma é que estamos definindo
essa plataforma. Para fazer isso, vamos clicar
aqui e adicionar e procurar colisão em uma colisão de caixa e vamos chamá-lo de
negar, subir. Então, estamos negando que o jogador
aperte o botão para cima, então ele spam a
escada lá em cima. E a coisa boa de
fazer isso aqui. Então, mesmo que adicionemos dez
letras ou dez cordas, isso funcionará
para todas elas porque é uma caixa cobrindo
tudo aqui. A melhor maneira de colocar isso aqui
é, na verdade, agora vamos para a perspectiva e
vamos clicar
na vista certa e depois
ir para o modo Lit aqui. E você poderá
ver isso muito melhor. E deixe-me apenas diminuir
um pouco. Ok, então esta caixa de
colisão aqui, a melhor maneira de fazer isso
é você só precisa cobrir esta plataforma para que você possa tentar ir com o
x aqui, certo? Cento, duzentos,
trezentos e oitenta. E você pode tentar
cobrir essa área. Então, talvez 375, apenas
um pouco menor, algo assim, ou 73 AT apenas para garantir
que ele realmente cobre
a área aqui também. E para a caixa de colisão
Y e Z, talvez seja 35. Acho que já está
cobrindo muito disso. E tente cobrir
logo acima da grama. Você não precisa
enlouquecer com isso. Então, vou
remover o encaixe. E assim como a
linha superior está logo acima dessas caixas
de colisão aqui na grama. Certo, então acho que isso
cobre bem. Vamos compilar e salvar, e vamos
até isso e clicar
sobre isso no componente
começar a sobreposição. Então clique aqui e diga que o
ator marcou. E, novamente, digamos
que seja o jogador. Dentro daqui. Temos que executá-lo novamente
através de uma autoridade. Portanto, o switch tem autoridade, certificando-se de que é o
servidor que o executa. Vamos fazer um ramo. Então agora estamos perguntando,
é o jogador? Se for, vamos pegar isso e
dizer que recebe referência do jogador. E só queremos
chamar isso de novo. Pode subir. Este, lembre-se de
escolher a mensagem. Pode subir, então não pode subir, mas pode subir a mensagem. E sempre que você estiver
colidindo, lembre-se, seja lá o que você colide com
esta caixa, acabamos de adicionar aqui. Você não é capaz de
pressionar o botão para cima, gosta de subir porque
então você pode gastar a corda. Então, pegá-lo e
colocá-lo em negativo. Então isso está correto. A próxima coisa é clicar aqui e clicar na sobreposição final. E vamos apenas copiar colar esse código e conectá-los aqui. Então outros atores aqui embaixo, outros atores aqui em cima também. E vamos colocá-lo em verdade. Então agora você pode subir quando não estiver dentro dessa caixa. Ok, então agora
temos o código aqui. Então, vamos para cegos sendo base. E em vez de escalar a base, vamos agora excluir o código aqui
porque não precisamos dele. Deixe-me realmente excluir esta
caixa totalmente. Remova-o. Vou dar erros e
remover tudo isso também. Então, agora movemos o
código para aqui. Isso é o que vai
defini-lo em vez disso. Então, a próxima coisa que
podemos fazer é ir, vamos para a base de jogadores e dar uma olhada no código do
cliente. Então, o cliente sendo
código estava aqui em cima. E dentro do código de
escalada
tínhamos esse chamado set. O conjunto pode subir. Este é o que
acabamos de mudar para cá. Então, o que eu quero fazer,
na verdade, deixe-me voltar. Onde está aqui? O que eu quero fazer
aqui agora é perguntar como fazer ramo aqui
e escrever um NOT booleano. Então, se você não pode se alinhar, o que significa que você está realmente colidindo com essa caixa
aqui, acabamos de adicionar. Então, se você está colidindo com ele e também perguntando
se você está subindo. Então, vamos subir. E é aqui que está escalando. E escreva um AND booleano. Deixe-me realmente
fazer isso para que eu possa explicar para você muito melhor. Então, conectando isso aqui. Então, o que eu quero fazer aqui. Então, se você não pode escalar Bob, o que significa que você está
colidindo com esta caixa aqui. Se eu apenas movê-lo para que ele possa realmente
tê-los todos juntos. Então, se você está colidindo
com esta caixa, significa que
isso é falso, como se você não pudesse subir o dinheiro, o que torna isso verdade aqui. Então, se você não pode subir
e seus seres clientes, então você ainda está na escada. Então você está sob a letra, mas também está
sobrepondo isso, o que significa que você está aqui em cima. Então queremos lembrar novamente
antes de configurá-lo aqui no isClient ser também
é aglomerar player. Isso é o que queremos. Porque quando você está
subindo e começa a sobrepor essa caixa, você deseja desativar as caixas de colisão
aqui para poder subir. Isso é o que estamos tentando fazer. Então, deixe-me voltar
ao Event Graph. Deixe-me primeiro fechar isso e para facilitar para si mesmo, vamos realmente criar
uma enumeração. Então, aqui, vamos clicar com o botão direito do mouse, vá
para a enumeração de blueprints e vamos chamá-lo
de estado de colisão. Então, para o que vou usar essa enumeração chamada Estado de
Colisão. Vou apenas fazer
uma lista de dois itens, mesma colisão
e colisão fora. Enumeração muito, muito
simples, muito simples aqui. Então, apenas para ouvir lembre-se, e a enumeração
é apenas uma lista de todos os itens que você deseja. Por isso, só queremos
a colisão ligada e desligada. Esta é apenas a lista. Vamos fechá-lo e vamos realmente voltar para
a base de jogadores aqui. Agora lembre-se, não podemos
simplesmente tomar esta cápsula. Opa, podemos simplesmente pegar
esta cápsula e dizer Definir
tipo de objeto de colisão e, em seguida, configurá-lo para
jogador de escalada, por exemplo. Não podemos fazer isso porque
lembre-se de que estamos executando isso pelo servidor para que
o cliente tenha um bug. Então, se você clicar em
Jogar agora
e tentar realmente
ver se isso funciona. Então, jogando como
cliente, eu posso subir. Você pode ver que eu posso subir aqui, mas isso vai incomodar nosso personagem. E em vez de
fazer isso dessa maneira, você precisa executá-lo
através de uma notificação de representante apenas para notificar os clientes
também sobre essas mudanças. Então vamos tomar, vamos
salvar tudo primeiro e agora podemos
usar nossa enumeração. Vamos criar uma nova variável. Vamos chamá-lo de estados de
colisão. Você também pode chamá-lo de
outra coisa, se quiser. Mas vou
chamá-lo de Estado de Colisão. E estou mudando o
tipo de variável para estado de colisão E, seja lá o que chamamos aqui
na enumeração. Então, estado de colisão E, isso é o que
chamamos aqui. Então, agora vamos salvar compostos. E vou fazer
essa replicação em
uma notificação de representante e, em seguida,
desembrulhar a função. Vou pegar esse estado de
colisão e dizer ligar a enumeração. Então, fizemos isso
algumas vezes agora. Quando a colisão estiver acontecendo, quero que você tome
minha cápsula e
defina o tipo
de objeto de colisão como lagoa porque
queremos colidir com
tudo assim. Quando minhas colisões
de eu vou copiar cole isso e configure-o
para subir sendo jogador. Então, vai colocar
a colisão da plataforma, na verdade todas as
colisões do solo. Enumeração muito simples, basta ligar e
desligar a colisão. Agora podemos usar isso muito útil. Assim, podemos pegar esse
estado de colisão e defini-lo aqui também. Então agora vamos pensar que
realmente pensei que estávamos fazendo quando não podemos subir, o que significa que estamos colidindo
com essa caixa aqui em cima. E estamos subindo. Isso significa que queremos desligar
a colisão porque estamos subindo e queremos
ignorar essa plataforma. No entanto, se não estamos batendo nessa caixa aqui ou se não
estamos subindo, então queremos ativar
a colisão porque talvez
se não estivermos escalando, mesmo
estando tocando esta caixa, se não estivermos subindo,
talvez estejamos
de pé em cima daqui e então não queremos desligar
a colisão, senão cairá
pelo chão. Então, queremos ativar
a colisão se não
estivermos escalando ou se não
estivermos tocando. Esta caixa aqui em cima, significa
que estamos aqui em baixo
e, na verdade, queremos que nosso terreno esteja ligado.
Então, isso está correto. Agora, outra coisa é, quero dizer, você pode tentar jogar
e ver o que acontece. Então, jogando aqui. Posso subir aqui. E se eu for atingido, você pode
ver que ainda estou ficando preso. E o problema está aqui na função de desdobramento
colombiano. Lembre-se que tínhamos todos esses. Na verdade, vou
excluir todos eles. E vou reconectar
os pinos como antes. Porque realmente não
precisamos mais deles. E você pode simplesmente mover
tudo isso para mais perto. Ok, então vamos compilar e salvar, e vamos tentar jogar agora. Veja se funciona. Agora posso ver, eu posso escalar e estou jogando como
cliente agora. Então eu posso fazer isso. O outro bug agora
é que não posso descer. Estou tentando
descer, mas não posso. Mas você pode ver que
a morte funcionou. Tudo está funcionando. O problema agora é
como se estivesse funcionando agora. E se eu pular no chão, posso andar de novo. Se eu pular aqui,
posso andar de novo. O problema é que não
consigo descer. Então, temos que consertar isso. Então, temos que ir para
o Event Graph. E o problema está aqui. Então, a escalada é definida para ser verdadeira quando você pode escalar e
você está tentando descer. Então é isso que, lembre-se, fizemos este cronômetro
onde verificamos se o jogador está
tentando descer. E sim, quando você desce, mas não
desligamos a colisão. Então deixe-me copiar
colar isso aqui em cima. Então aqui no temporizador. Então, quando você realmente
começa a escalar, então é fixado como verdadeiro. Quero desligar minha colisão. E aqui em cima quando cancelamos
o ser ISClient. Então, quando você
terminar de escalar, eu posso realmente definir
isso para ser ligado novamente. Então, configurá-lo aqui também. Então, agora todos os problemas devem ser corrigidos se
tivermos feito isso corretamente. Então, vamos tentar novamente. Posso escalar, posso andar, posso
descer também. Tudo está funcionando
e se eu morrer aqui, vou ser empurrado. Isso também funciona.
E se eu morrer, isso funciona também. Então eu acho que é uma maneira mais fácil lidar com a colisão e vamos tentar ser
derrubados aqui. Isso também funciona. Eu posso apertar e também
posso morrer aqui em cima. Sim, isso também funciona. Ok, então esta é uma maneira
fácil de fazer isso, apenas fazer uma enumeração
com a colisão ligada e desligada e depois
mudá-la para uma notificação de representante. E assim, na função de notificação, você está apenas colocando a
colisão ativada e desativada dependendo do que
você está configurando aqui. E lembre-se das variáveis
de notificação on ou rep. Você só pode definir notificações
por meio de um servidor. Os eventos podem afirmar que isso é suficiente. Porque lembre-se, você não pode simplesmente entrar aqui e
passar por este. Você precisa estar no servidor antes de poder definir funções
não lidas. Muito, muito importante e isso é o que estamos
fazendo para sempre verificar se é o servidor
pelo qual
você está executando e se
é, está correto. Sim. Foi isso para isso fixo. E vamos passar
para o próximo.
94. Como adicionar experiência a estruturas: Vamos agora criar
nosso sistema de nivelamento. Então, primeiro, o que precisamos para
o nivelamento está aqui
na estrutura e nas informações do
inimigo ou informações sobre animais, temos que dar
experiência aos inimigos , porque
obviamente
todos, todos os inimigos vão dar alguns tipo de experiência e haverá diferentes uns
dos outros. Então, escrever experiência aqui
na estrutura e
mudá-la para um número inteiro. Como você pode, você pode
colocá-lo em um flutuador. Mas a experiência, eu quero, você não tem uma vírgula, então você não tem
casas decimais. E, portanto, não
precisamos de um flutuador. Então, esses são números inteiros. E eu gostaria que você
tivesse um jogo com algo
dando, por exemplo, 20,5 experiente do que você teria que configurá-lo para um flutuador. Caso contrário, vou apenas
com um número inteiro porque esses são apenas
números inteiros que estou fazendo. E para a experiência, vou
colocá-lo logo abaixo do dano. Então, este especificará quanta experiência
cada animal vai dar. Então, vamos agora para o inimigo
aqui e depois nos baseamos. Vamos lembrar de compilar
e salvar como antes. E vamos ao porco e abra o editor de
blueprint completo. E dentro daqui para a
experiência para o porco, vamos, por exemplo, obter, digamos 20 experiência
toda vez que matamos um porco. Para o caracol, toda
vez que matamos um caracol, vamos pegar, por exemplo,
dez compostos de experiência. Salvar. Opa. Ok, então isso é
feito para o animal, a estrutura para os animais. Agora vamos entrar no jogador. O jogador
precisará de duas variáveis. Então, primeiro precisamos de um nível. Então, qual é o seu nível atualmente? E vamos colocar isso
em um número inteiro. São números inteiros. E vamos também fazer experiência. Então, quanta experiência
você tem agora? E isso também é um número inteiro. Vamos colocar esses. Vou colocá-los logo abaixo
do dano base aqui em cima. Ok, então vamos salvar isso. E a última coisa. Então, agora, deixe-me
ir primeiro para a
base de jogadores e jogadores e Compilar e Salvar. E aqui nas propriedades e
na estrutura de informações do jogador, o nível como padrão, você começará com um. Então lembre-se, você não está
começando com o nível 0, você está começando com o nível um. Então lembre-se de escrever isso
aqui como experiência estrangeira. Vamos atualizar isso mais tarde, então não se preocupe com isso. Vamos fechá-lo. Então, a última coisa que
você precisa definir quanta experiência
você precisa por nível. Então você meio que tem
como se precisasse de uma lista de qual experiência é
necessária para qual nível. Então, precisamos disso para realmente
criar uma nova estrutura. Vamos clicar com o botão direito do mouse e vamos para blueprints e
criar uma nova estrutura. E este, vou
chamá-lo de informações de nível. Por isso, ele contém informações sobre a experiência que
precisamos para todos os níveis. Então, ele precisa de apenas duas variáveis. Precisamos do nível. E isso vai
ser um número inteiro. E este é
chamado de experiência. Então, quanta
experiência é necessária? E isso também
será um número inteiro. Então, para duas
coisas muito básicas, qual é o nível? E em vez de experiência, podemos simplesmente chamá-lo de
experiência necessária. Portanto, é mais nível explicativo e experiência
necessários para subir de nível. Vamos fechá-lo. para trabalhar com
essa estrutura, nós realmente temos que
trabalhar com tabelas de dados. Tabelas. Vamos trabalhar com eles na próxima lição. Então, vamos seguir em frente.
95. Introdução a tabelas de dados: Agora que temos essa estrutura de informações de
nível, vamos começar a trabalhar com tabelas de
dados e
elas são tão úteis, você verá que elas são boas de
usar e também são muito fáceis, não, não realmente
complexas conceito. Vamos para a pasta,
criar uma nova pasta, chamá-la de tabelas de dados e ter todas as nossas tabelas de
dados aqui. Neste momento,
vamos ter um, mas eu gostava de ser estruturado. E agora você pode clicar com o botão direito
aqui e diversos. E aqui você pode selecionar Tabela de
dados, esta. Agora ele pergunta
qual estrutura
devo criar uma tabela de dados? E então você precisa
especificar a estrutura. E a única é essa informação de nível
que fizemos clicando. Certo, e vamos chamá-lo de
d t para tabelas de dados. E vou
chamá-lo de informações de nível também. E clique duas vezes nele. E aqui estamos dentro
de um DataTable. Agora você precisa de um novo valor, então você precisa
clicar em Adicionar aqui. Agora, para adicionar algum valor. Esse valor fornece uma linha
e, em seguida, você pode ver
as variáveis que você criou dentro da estrutura de
informações de nível. Portanto, toda vez que você adicionar uma nova
variável em sua estrutura, ela estará aqui
nesta tabela de dados. Então, o que é essa tabela de dados, você pode simplesmente imaginá-la como um documento Excel Excel,
onde você tem, por exemplo, o nível
e a experiência necessários. E então você só faz mais
linhas e as define. Para a primeira,
em vez de nova linha, vou
renomeá-la para uma. Então, clicando em F2 para renomear
e clicar em um, também
podemos clicar com o botão direito do
mouse e
clicar em Renomear. Isso depende de você. Então, aqui começamos no nível
um, obviamente não 0. Então aqui você tem que escrever quanta experiência é
necessária para nível até dois. Então 50 experiência para
nível até dois. E então deixe-me adicionar um novo valor e que a linha que
vou chamar dois. E isso é muito importante. Na verdade,
vamos usá-los, então não se esqueça de
chamá-los 1234 e assim por diante. Então, para este, no nível dois, você precisa de 75 experimentados
no Love Lab. E este eu
vou chamar três. No nível três, você
precisa de 100 para subir de nível, e vamos fazer cinco. Então, às quatro, você precisa 125 e isso é adequado
para você precisar de
cento, cento e vinte e cinco. E no nível cinco
e no nível cinco, você precisa de 150 para subir de nível. Assim, podemos definir quanta experiência
você precisa para subir de nível. E, obviamente, é
aqui que entra o design do jogo. Você tem que equilibrar
todos esses números. Então, agora vamos fechá-lo e foi
isso para tabelas de dados. Então você pode ir em frente
e salvar tudo. E vamos passar
para a próxima lição.
96. Tabelas de dados por meio do Google Sheets: Então, a coisa legal
sobre tabelas de dados, você realmente não precisa fazer
isso manualmente o tempo todo, como criar todas essas linhas. Às vezes você tem,
por exemplo, se, digamos que você tenha
itens apenas em um conto divertido, o jogo que eu lancei no Steam. Então, na cauda da fazenda, eu tenho como todos os itens
que você pode comprar na loja, eu realmente os tenho
dentro de uma tabela de dados. E isso levará muito
tempo para fazer porque se você tiver dez ou 20 variáveis
para cada item, isso levará uma eternidade. E é por isso que usar o Planilhas
Google é realmente muito mais rápido e
eu recomendaria isso. Então aqui no Google, como se você
fizesse
uma conta e entrasse aqui e vá para a unidade. Então, aqui no seco, você pode clicar com o botão direito do mouse e
criar um novo Planilhas Google. E dentro desta planilha
do Google agora, posso dar uma
olhada na minha tabela de dados. Então, se você simplesmente minimizar, se você não se lembra
da estrutura, basta voltar
para a estrutura, dar uma olhada nela, e então você tem que
escrever os nomes aqui. Então, por exemplo, se eu
voltar à minha planilha do Google, você terá que escrever
o nome exato herói, também com as letras maiúsculas. Por exemplo,
posso dizer, vamos, geralmente começo com o número da
linha e, na verdade bem aqui.
Vamos apenas tentar isso. Então esse número aqui, e eu realmente vou
mudar de estilo aqui só para
fazer com que pareça muito melhor, apenas para o meu próprio bem. E aqui em cima vai ser ousado. Certo? Então, aqui em cima, temos a primeira variável
variável dizendo nível. E o próximo é dizer que a
experiência é necessária. Vou tornar isso maior. Então, algo assim. Esta pode ser minha,
minha planilha do Google. Agora, esta é minha tabela de dados. Então, na linha, no número um. Então, temos o nível um e
isso realmente não importa. Eu só os faço como números de linha. Então, no nível 23, e você pode ver que é muito mais rápido porque
eu posso arrastar assim. Então, agora ele recebe tudo isso. E se você é novo
no Planilhas Google, poderá assistir a um
tutorial no YouTube. Levará dois minutos. Então, selecionando esses
números, por exemplo, posso arrastar para baixo e
tê-los listados automaticamente. E a experiência
necessária, posso dizer, por
exemplo, começamos com
50 e depois posso dizer 75. E acredito que ele pode
fazer isso automaticamente. Deixe-me tentar. Ele também pode fazer isso
automaticamente. Vê que você está adicionando 25 sobre ele e ele apenas
faz isso automaticamente. Você pode ver que isso
é muito mais rápido do que entrar e inserir
cada número aqui embaixo. Isso faz isso
automaticamente para mim. E você pode até fazer
fórmulas no Excel para
equilibrar seu jogo
para que você não
precise inserir todos os
números manualmente. Mas, obviamente, temos que testar o jogo para garantir que ele funcione. Agora, digamos que esta
planilha do Google estava boa e boa. E agora o que vou
fazer é clicar em Arquivo, ir para o download e
fazer o download como CSV, CSV muito importante. Mas agora ele vai baixar. Este é o meu arquivo baixado, então agora posso renomeá-lo. E o que você precisa
renomeá-lo é esse mesmo nome
que as tabelas de dados. Então, se eu for aqui, é chamado de informações de nível DT. Portanto, certifique-se de
ter exatamente o mesmo nome, informações de nível
DT com
letras maiúsculas. Vou arrastá-lo e soltá-lo aqui nesta tabela de dados. E, na verdade, acho que preciso,
na verdade, não preciso, mas se você não tiver, então você pode ver se você
clica duas vezes nele, você pode ver que você obtém
todas essas entradas. Muito, muito bom. Ele fez isso
automaticamente e agora
pode usar
essas informações. E posso ver que é
muito mais rápido de fazer. Agora, o que eu disse antes, nós também podemos excluí-lo. Então, se você não tem nada, se você ainda não conseguiu
e tiver a estrutura, deixe-me salvar tudo primeiro. Então, indo para essas tabelas de dados, você pode simplesmente
arrastá-lo para aqui. Em seguida, ele perguntará,
você está importando
essa tabela de dados, tipo de linha de tabela de
dados. Então você tem que selecionar as informações de
nível aqui, a única. E vou
dizer que ignore campos extras. Às vezes eu tenho
campos extras para calcular minha fórmula. Portanto, ele deve
ignorar campos extras. E campos extras são como
se apenas olhasse para suas variáveis aqui
em cima. Se você tiver algo, como se você tiver outra
variável que realmente não existe em sua estrutura, isso será ignorado. Então, isso é o que significa. E ignore os campos ausentes. Na verdade, eu não quero, porque e se estivermos
perdendo alguma coisa? E o campo Importar chave
é apenas nossos números aqui. Então deixe-me tentar fazer isso. Então nosso número aqui
é minha chave de entrada, e você verá para que essa
chave é usada mais tarde. Então, fazendo isso, e
vamos tentar fazer isso. Talvez não possa, talvez às vezes
possa nos erros. Então, vamos aplicar e clicar duas vezes. Agora podemos ver que isso funciona. Então, agora você pode ver
todas essas entradas. E parece incrível. Então, agora vamos salvar tudo. E eu recomendaria
usar o Planilhas Google toda vez que você fizer um jogo
e fizer um projeto, é muito mais rápido de usar. Você provavelmente pode
otimizar esses números. Talvez você realmente não precise
desse nome de linha e você possa gostar do campo da chave de entrada. Você pode simplesmente escrever
esse nível aqui. E você pode fazer isso apenas para minimizar todas essas linhas aqui. Mas agora isso está funcionando. Vamos passar para o próximo.
97. Como criar uma biblioteca de funções: Tudo bem, então a próxima
coisa que precisamos fazer
para usar essa
tabela de dados em nosso código, precisamos
passar por uma biblioteca. E isso é algo que
não aprendemos antes, mas é muito fácil. Não se preocupe. Vamos clicar com o botão direito agora. E vamos criar uma nova
pasta e vou chamá-la de bibliotecas. Esta é a última
coisa nova que aprenderemos aqui. Então, vamos entrar
aqui e clicar com o botão direito do mouse. E aqui na guia blueprints, você tem algo chamado biblioteca
de funções. Então, até agora aprendemos
sobre as aulas de blueprint. Aprendemos sobre
as estruturas, aprendemos
sobre enumerações. Aprendemos sobre Interfaces de
Blueprint, e agora vamos criar uma biblioteca de funções de
blueprint. Então você pode ver que
passamos por tudo isso. E esta também é uma
biblioteca de macro de biblioteca. Muito semelhante. Mas vamos nos preocupar com
a biblioteca de funções por enquanto. Então, vamos clicar nele. E vou chamá-lo biblioteca de
funções,
assim mesmo. Deixe-me entrar aqui e dizer agora que a função que queremos fazer é chamada
obtém informações de nível. Então, estamos tentando obter essas informações
de nível
dessa tabela de dados aqui que
estamos tentando extrair. Então é isso que estamos fazendo
na biblioteca de funções. Estamos tentando extrair
informações
dessa tabela de dados e
podemos usá-las em nosso código. Então, aqui, obtenha informações de nível. Vou torná-lo puro. E lembre-se quando
fazemos algo puro, é como
transformá-los nessa função verde. Então, se eu for para a base de jogadores só para que você
possa ver um exemplo, e se eu olhar ao redor, por exemplo, isso obtém controle. A rotação é uma
função pura e esta, a azul, é uma função
insegura. Então, a função pura,
você não tem esses pinos de execução porque você realmente não precisa deles aqui. Lembre-se, sempre que você só
precisa obter informações, você realmente não
precisa de canetas de execução. Os pinos de execução são apenas
para definir informações. Então, por exemplo, você está
definindo a entrada de movimento, você está definindo
o x é o valor z neste caso. Mas aqui você está apenas recebendo,
obtenha rotação de controle. Obter um vetor está apenas
recebendo informações. Você realmente não
precisa definir novas informações. Aqui,
informações de nível de gate-eu estou recebendo. Vou defini-lo como puro. E a entrada
será extraída de qualquer
entrada de chave que você colocar aqui. Portanto, a entrada da chave
é apenas um número. Então, vou fazer novas entradas e será um número inteiro. E vou chamá-lo de nível. Então, está tentando ver. O que vou fazer
aqui é na base de jogadores, vai dar uma
olhada nas informações do jogador, dar uma olhada em que
nível você está. E a partir desse nível, como se pudesse ver o número um. A partir desse nível, ele lhe
dirá qual experiência é necessária
para o nível até dois. Então é isso que
estamos tentando fazer. Então, o que esse nível
e a coisa que precisamos usar é chamado Obter tabela de dados. Obter linha da tabela de dados. Estamos tentando tirar uma
linha específica desse nível. Então, se formos nível quatro, ele vai para quatro. E então ele vai
conseguir uma linha de tabela e usar essas informações 125
na experiência necessária. Então, vamos tentar fazer isso. Não podemos simplesmente
conectá-lo assim, mas podemos dizer duas cordas. Então, estamos
convertendo-o em uma string primeiro, e então ele pode fazê-lo. Então, primeiro convertendo-o uma string e depois
convertendo-o em um nome. E então entrando
daqui, vamos conectá-lo. E a tabela de dados
que queremos extrair, só
temos uma. Então, selecionando-o aqui. E então vamos dirigir
daqui e dizer retorno. E adicionamos um nó de retorno. E esta é a informação
agora esta é a tabela. Agora sabe como se
estivéssemos no nível quatro, nariz aqui fora na informação de
que estamos no nível quatro. E precisamos dessa
experiência para subir de nível. Aqui. Vamos chamá-lo de
conjunto de informações de nível de informações de nível de superação. Certo? E a coisa legal sobre
bibliotecas que você pode realmente, essas são funções globais. Você pode chamá-los em qualquer lugar. Se eu simplesmente entrar na minha base de
jogadores agora e apenas disser ainda informações de nível,
você pode vê-lo. Está aqui da biblioteca de
funções, por isso é uma função global
que você pode usar em qualquer lugar. E você pode, você pode perguntar, por que não codificamos tudo ou muitas
coisas dentro daqui? Na verdade, é
caro fazer isso. Eu li muito sobre isso. E algumas pessoas realmente
atrasam seus jogos. Se você tiver essa
biblioteca de funções é muito pesada. jogo deles está atrasado. Então parece que isso é muito, muito pesado de usar se
você tiver muito, mas em casos como este, em
que realmente precisamos usá-lo. E às vezes como o que você precisa usar isso
é você só precisa pensar, existe uma função
que eu tenho que usar em 50 blueprints estão em cinco
plantas o tempo todo, então você provavelmente deve ir e faça isso
aqui, por exemplo,
obtendo as informações de nível,
podemos usá-lo em obtendo as informações de nível, nosso
controlador de jogador, em nossa interface do usuário, em nosso controlador de jogador
ou não como controlar a base do jogador e a base
inimiga e assim ligado. Assim, podemos usá-lo em muitos, muitos lugares e provavelmente é uma boa ideia fazer isso aqui em vez de um projeto específico. Ok, então você pode ver aqui, eu
posso apenas dizer informações
no nível do gate-level, e agora temos que conectar algo aqui
para e agora temos que conectar algo aqui
para que possamos conectar
essas informações do jogador, por exemplo, eu posso
mostrar muito rapidamente. Por exemplo, podemos pegar o nível atual dos jogadores
e podemos conectá-lo aqui. E agora, por exemplo, se
o jogador estiver no nível três, ele extrairá
essa linha número três e sabe que você precisa. Agora você pode
pegá-lo daqui e separá-lo e ele
conhece seu nível três. E você precisa aqui, você precisa de 100 experientes
para subir de nível. Método muito, muito legal para fazê-lo. Então nós temos, se eu apenas
explicar isso muito rapidamente. Então você criou uma
estrutura aqui chamada info de
nível e
fez essas variáveis. E depois disso,
acabamos de entrar no Google Sheets e
fizemos isso aqui. Agora você pode arrastar essas informações e soltá-las nessa tabela de dados. Vou aqui no Navegador
de conteúdo. E então você precisa selecionar para qual estrutura essas tabelas de
dados. E fizemos isso. Então, ele só cria isso para nós. Então você vai em frente e vá para a biblioteca de funções
e cria esta, obtenha a linha da tabela de dados. Em seguida, você seleciona qual tabela de dados e qual é o nome da linha? próprio nome deles são
apenas números aqui. se você editar o
nome da linha para hello, por exemplo, ele não saberá como
se você é um Nível um, ele não saberá o que
é isso porque o nome da sua
linha é olá. Não é um número, mas
nós o temos como números. E saberá
que, por exemplo, se o seu nível três, ele vai divulgar essas informações
e essas informações, podemos chamá-las
aqui e usá-las em qualquer lugar. Então, vamos salvar tudo e vamos passar
para o próximo.
98. Como adicionar experiência na morte Enemy: Olá e bem-vindo de volta. Então agora vamos
adicionar experiência quando
o animal morrer. E aqui estou
na base de jogadores. E primeiro temos que
criar um evento chamado experiência de
anúncio porque
queremos adicionar experiência
ao jogador. Então, queremos
limpar isso um pouco mais tarde, mas vamos adicioná-lo
aqui onde há espaço. Vamos prosseguir e
fazer um evento personalizado. E vamos fazer isso através
da função Blueprint
Interface. Então, vamos para as interfaces, para a base de jogadores, e vamos criar uma nova função
chamada add experience. E aqui a entrada é apenas, apenas o inteiro porque
é apenas a experiência. E vamos chamá-lo de
experiente para adicionar. Vamos compilar e salvar, e vamos voltar
para a base de jogadores e salvar tudo aqui. Agora vamos clicar com o botão direito do mouse
e chamar a experiência de anúncio E este, novamente, vamos fazer com que um seja executado
pelo servidor chamado experiência de anúncio para garantir que o cliente não
esteja trapaceando. Vamos executá-lo pelo
servidor sendo confiável. E vamos chamá-lo aqui, experiência
do Server AD. Agora, novamente, precisamos de um número inteiro
chamado experiência para adicionar. E vamos conectá-los aqui em cima. Ok, então temos esse
evento aqui e não temos nada a
ver com isso agora. Mas o problema é que quando
você mata um inimigo, você tem que conectar
quanta experiência você tem que adicionar
para os inimigos habilidosos
ou mortos. Então, vamos
até o inimigo agora. Então, dentro da base
inimiga e inimiga, dentro daqui, vamos descobrir
onde matamos o inimigo. Então, matamos o inimigo. Este é o dano. E então aqui estamos verificando
se a saúde é 0. E se for, vamos seguir frente e matá-lo para a morte. Então, antes de fazermos isso, então aqui é onde
matamos o inimigo. Temos certeza que o nome está morto. Então aqui vou chamar meu anúncio para
experimentar o evento aqui
e para a base de jogadores. Então, para pegar o jogador, já
temos um controlador
de jogador. Podemos dizer que é controlado peão. E então podemos dizer Obter referência de
camada porque estamos tentando fazer referência
à base de jogadores. E vamos conectá-lo. Whoops, vamos conectá-lo. Assim mesmo. Pode, na verdade apenas puxá-lo aqui em vez disso. Ok, então temos isso agora
e agora podemos arrastar disso e dizer adicionar experiência. E é uma mensagem porque é de uma função Blueprint
Interface. E quanta experiência você
quer adicionar? Lembre-se, fizemos
na estrutura animal, já
fizemos isso, para que possamos quebrá-lo aqui. Vamos esconder tudo por enquanto, e vamos clicar e
clicar nessa experiência porque já definimos quanta experiência
todos os presentes de animais. Então agora só queremos
dar essa experiência que o inimigo dará em um dado. Então, apenas movendo-o aqui. E então vamos
continuar com nosso código. Vou movê-lo um
pouco para cima, assim. Ok, então agora estamos adicionando
experiência quando o inimigo é morto e a
experiência vai passar
para a base de
jogadores aqui. E isso vai
passar por aqui. Então, agora que
criamos isso, estamos prontos para atualizar a
experiência para o jogador.
99. Como atualizar a experiência: Ok, então vamos agora avançar e atualizar a experiência
para o jogador. Então agora temos a experiência, quanto o inimigo dá, e ela passará por
esses eventos de experiência publicitária. Agora, aqui no servidor, agora
estamos prontos para
atualizar essas informações do jogador. Então, vamos pegar essas
informações do jogador e vamos dividi-las. Agora, vamos esconder
tudo e aproveitar essa
experiência que fizemos. Então, essa é a experiência que
o jogador tem agora. E obviamente você começa com 0. Então, vamos pegar essa experiência
que você ganhou e dizer mais e adicioná-la com a experiência atual
que você tem. Então, se você tiver 0 e
o porco lhe der 20, agora
você terá 20
porque você
os adicionou e esse
é o novo valor. Então, vamos defini-lo aqui para o
novo valor para que ele seja atualizado. Então, vamos pegar essas informações. Digamos que defina membros e vamos conectá-lo aqui. Agora, o que podemos fazer com
isso é
arrastá-lo para baixo assim
e levá-lo para cima. E agora, o que, o que você
quer definir? Queremos definir a experiência, e essa é a experiência para a qual
queremos configurá-la. Este é o número atualizado. E então lembre-se de pegar essas informações do jogador
e configurá-las aqui. Então, agora você atualizou quanta experiência seu jogador tem através da estrutura. Então, isso é
tão simples quanto isso. Agora você tem a experiência
atualizada, como quanta
experiência você tem. E, obviamente, não
será atualizado na interface
do usuário porque ainda não
criamos uma interface do usuário. Mas você pode imprimir uma string
novamente e ver se isso está correto. Assim, você pode separar isso
novamente e ocultar tudo, aproveitar a experiência e sempre
pode imprimi-la na tela para ver o novo valor para que você
possa clicar em jogar. E aqui eu posso acertar inimigos. O servidor vai
dizer dez agora. E se eu matar o segundo, vai dizer 20 porque cada caracol dá
dez experiências. Se 3040 porque
acabou de matar também. Então você pode ver que isso está
funcionando perfeitamente agora. Então, agora que as experiências
do incorretamente, veremos como podemos
atualizar o nível também.
100. Como atualizar o nível: Agora estamos prontos para atualizar
o nível para o jogador. Então, espero que você esteja totalmente
acordado para esta lição. Há alguma matemática
que temos que fazer, não muito complexas, mas só temos que estar totalmente acordados e
saber o que estamos fazendo. Então, agora que
atualizamos a quantidade de
experiência que o jogador tem, agora
estamos prontos para verificar se o jogador
excedeu experiência
necessária para subir de nível. Então lembre-se que fizemos
este chamado obter informações de nível anteriormente. E a partir disso, podemos separar
isso e podemos tentar ver se o jogador tem essa experiência
necessária. E temos que especificar qual nível é o
jogador atualmente. E podemos fazer isso
clicando aqui, e vamos fazer esse nível aqui. Então, começamos pelo nível um
como padrão e
deixe-me arrastá-lo aqui
e fazer isso aqui. Então, tentando ver como aqui nós, estamos escrevendo um porque o jogador é o nível
um e ele vai
passar por essa tabela de
dados e
sabe que precisamos de
50 experiência. Então, isso vai dizer 50 aqui na experiência necessária. Então, o que vamos fazer é
pegar isso
e, na verdade, vamos levar
essa experiência primeiro. Vamos pegar isso aqui e dizer, é maior ou igual? É maior ou igual que
a experiência necessária? E vamos fazer uma filial aqui em cima. E vamos
conectá-lo. Então, por exemplo, eu mato alguém e
digamos que eu tenha 200 de experiência e eles são
necessários talvez seja apenas 150. Então eu só estou perguntando, é 200 maior ou igual do que
o necessário com isso, que é duzentos e
cento e cinquenta. Ou seja, temos que subir
de nível o jogador. Se não for isso, não
fazemos nada. Então, talvez apenas atualizemos a interface do usuário ou o que
estamos tentando fazer. Vou esconder isso aqui. Então essa é a coisa que
vamos fazer. Então, se for verdade,
vamos nivelar o jogador. É falso. Não estamos fazendo nada exceto por talvez
atualizar a interface do usuário, que faremos mais tarde. Ok, então, para
nivelar o jogador, digamos que seja verdade. Você tem mais experiência do que
a experiência necessária. Então você tem que, vamos pegar essas informações do jogador. E vamos primeiro aproveitar
essa experiência. Então, digamos que temos 200. Vamos subtrair isso. Subtraa-o da
experiência necessária. Então, digamos que você tenha
200 subtraídos por 150, o que talvez seja necessário. Então isso lhe dá 50
experientes à esquerda. Então, primeiro temos que subtrair essa experiência e depois
amar, amar o jogador. Então, vamos tentar fazer algumas anotações de redirecionamento para fazer com
que pareça um pouco melhor. E, na verdade, em vez de
fazer isso daqui, só para torná-lo mais limpo, eu não gosto da aparência disso. Podemos apenas empurrar esse
pouco mais longe e separar isso e
dizer a experiência, porque agora ela está atualizada. Então, pegue a
experiência daqui. E agora podemos dizer
isso aqui. Essa experiência foi subtraída
da experiência necessária. E podemos levá-lo aqui e
colocá-lo como aqui. E em vez desse
nível daqui, podemos esconder isso novamente, apenas para fazer com que pareça melhor. Na verdade, podemos apenas
tirá-lo daqui só para que eles não estejam muito
longe um do outro. E deixe-me apenas conectá-lo. Ok, então algo assim, vou arrastar isso cima só para que pareça
um pouco melhor. Arraste isso pode ser para baixo para que eles não colidam um
com o outro. Ok, algo assim aqui. Então, estamos perguntando, é essa experiência que
temos agora, é maior ou igual do que
a experiência necessária? Se isso for verdade, estamos aproveitando a experiência e estamos subtraindo-a da experiência
necessária. Então talvez 200 menos 1 quinto. Temos 50 experientes
à esquerda, por exemplo. E agora precisamos definir
a nova experiência. Então, vamos pegar
as informações do divisor novamente e dizer os membros do conjunto
e queremos definir a
experiência para esse número 50, talvez seja
o número. E então temos que
subir de nível o jogador porque o jogador excedeu
o valor necessário. Então, vamos realmente
clicar duas vezes aqui e fazer uma anotação de redirecionamento para
que isso pareça ainda melhor. Algo assim.
Certo, e aqui nós atualizamos
a nova experiência e vamos definir a
estrutura primeiro. Agora que
definimos a estrutura, podemos dividi-la aqui
e podemos esconder tudo. E poderíamos tomar o
nível e dizer mais, mais, mais, mais meios. Você pode vê-lo. Adicione um
ao valor especificado e, em seguida, defina-o assim. Isso significa que isso é a
mesma coisa que fazer isso. Então, levá-lo aqui e
dizer mais e escrever um, e depois pegar isso e definir esse valor
assim. Isso é a mesma coisa. Então, basta dizer
plus-plus para editá-lo e defini-lo. E então, obviamente, temos que atualizar nossa estrutura
com esse número. Agora temos um novo nível. Então, novamente, você pode
arrastar para fora disso aqui e dizer set member. E agora queremos definir o nível dois e o novo número
aqui, assim. Certo, e lembre-se novamente de definir essa estrutura assim. Então, agora atualizamos
a experiência, você atualizou o nível. E o que eu quero fazer agora, lembre-se como se você pudesse matar muitos inimigos
e talvez você tenha excedido a experiência
necessária tanto
para o nível dois
quanto para o nível três. Então, digamos que você matou
um inimigo que lhe deu tanta experiência que você nível dois nível sub
em vez de um. Então, temos que verificar
novamente como se está tudo bem, como se você
subtraísse essa experiência, mas você tem que verificar novamente, é essa nova experiência que
você tem no bolso, Novamente, maior do que o
necessário para o próximo nível. Porque talvez precisemos adicionar
dois níveis ao mesmo tempo em vez de um se você tiver
atendido a esse requisito. Então, vamos
arrastar disso
e, na verdade, vou
arrastar para essa ramificação novamente e clicar duas vezes para fazer anotações de
redirecionamento apenas para que seja. Olhando melhor aqui. Algo assim. Vou arrastar
tudo assim. Ok, então o que estamos fazendo
aqui é que estamos verificando novamente, é a
experiência que você tem agora com essa experiência
atualizada. Como mesmo que isso seja retirado
disso e experiência, lembre-se de que
atualizamos nossa experiência. Então, essa experiência agora
teremos a atualizada. Isso é maior do que o necessário novamente
para o próximo nível? Portanto, ele continua verificando
se é necessário, como se tivéssemos experiência
mais alta do que a experiência de
quarto necessária, se não, ele vai
para falso e não fará nada. Portanto, não adicionará
nada ao nosso nível. Então, é basicamente isso. Este é o código. Então, temos como se
estivéssemos, estamos adicionando a experiência
quando matamos um inimigo. Em seguida, estamos verificando se estamos
na experiência necessária para
que esse nível suba de nível. E ele vai
tirar essas informações da tabela de dados por causa dessa função
de informações de nível que fizemos, Biblioteca de Funções. E então ele
atualizará nossa nova
experiência porque estamos subtraindo essa
experiência do necessário porque
estamos subindo de nível. Portanto, não precisamos de
toda essa experiência. E com essa nova experiência, estamos novamente, atendendo à experiência necessária
para o próximo nível? Se não, talvez
atualizaremos a interface
do usuário ou onde quer que
façamos aqui. Então, agora que
terminamos com esse código, vamos realmente ir em frente e criar o nivelamento
ou o nível da interface do usuário.
101. Como criar a interface de usuário de nível: Para criar o URL adorável, vamos voltar à nossa pasta de
interface do usuário dentro do widget Blueprint
principal que foi criado. E vamos apenas adicionar
o nível aqui agora. Cabe a você onde você o adiciona. E este é apenas um
curso como você pode fazer o design que você quer. Mas aqui vamos, na verdade,
apenas adicionar um nível exibido. Então, vamos pegar, eu quero
adicioná-lo ao lado desta interface do usuário. Então eu realmente tenho que
adicionar uma caixa horizontal horizontal para que elas
estejam alinhadas horizontalmente. Então, vou para uma caixa
horizontal. E então eu vou colocar essa sobreposição na caixa
horizontal. E vou colocar outra
sobreposição na caixa horizontal. É aqui que eu quero
projetar meu nível EY, apenas arrastando esta caixa
horizontal do jeito e está assim
porque não está preenchendo. Então, vou
clicar nessa sobreposição e clicar em preencher aqui, então ela preenche a coisa toda. E com este, esta é a exibição de nivelamento e nivelamento. E aqui eu quero uma imagem como plano de fundo,
assim como esta. Vou com o mesmo design. Tendo esta imagem
definida como preto quadrado plano e preenchendo todo
esse espaço, vou colocar um espaço entre essas duas sobreposições. Apenas certifique-se de
que, ao minimizá-los, o espaçador está fora
das sobreposições. Então aqui no meio. E isso é espaçamento
na direção x, então talvez algo como dez. Certo? E aqui, deixe-me
duplicar esta imagem e deixe-me selecionar a
azul agora azul plana. E, novamente, basta clicar neste alinhamento na parte superior
e fazer o tamanho para cinco. Duplique isso, faça o
alinhamento para baixo. Então, temos esse mesmo
design de antes. E agora eu quero adicionar algum texto. E o texto que eu quero primeiro adicionar uma caixa vertical porque
quero textos. E o primeiro
vai dizer nível. Então, aqui vai dizer nível. E o segundo
na minha caixa vertical, ele só terá
esse nível exibido. Então, o nível um é o começo. E eu quero colocar isso
no meio e colocar este no
meio também. E toda a caixa vertical que
eu quero colocar
no meio também. Agora você pode selecionar os dois textos para
que possamos adicioná-los juntos. E para a família da fonte, vou selecionar Bold. Para o tamanho. Só vou deixar que seja 24. E este para a sombra, vou definir
o deslocamento de sombra 22 e mudar o alfa para 0,35. Temos algum tipo
de exibição básica, e você pode ver que isso é
muito pequeno e estreito. Está sendo
afastado disso. Assim, você pode clicar
nesta segunda sobreposição, clicar em preencher para preenchê-la. E se você não quiser
preenchê-lo tão parecido com o
mesmo tamanho que este aqui. Você pode simplesmente alterar esse
número de preenchimento agora é 1. Você pode escrever 0,5 e
ele pode torná-lo menor. Acho que vou com
0.4 e vou fazer minha caixa horizontal um pouco maior porque acho que
isso é muito pequeno. Algo, algo assim. E o que podemos fazer agora, apenas certifique-se de que o ponto de
ancoragem esteja correto. Então, clicando na âncora, colocando-a aqui em baixo. E, em seguida, escrever zeros 0 e
a posição que você pode vê-lo se alinha abaixo da nossa janela.
E não queremos isso. Então, novamente, brinque com os alinhamentos e este é
o motivo pelo qual o alinhamento aqui. E isso é apenas definido para um,
e ele estará aqui em cima. Agora, para a posição, vou
colocá-lo em talvez 30
no x e menos 30 em y. Menos 30 está indo para cima. Agora temos nossa exibição de
nivelamento. Agora, só para facilitar
para nós nas variáveis, vou
clicar nesse número e
chamá-lo para o próximo nível. E para este, realmente não
precisamos
transformá-lo em uma variável porque não
precisamos disso. Apenas certificando-se de que estou clicando neste texto aqui porque
precisamos modificá-lo, certifique-se de que ele está definido como
variável. Mas este para esse
nível também
garante que ele esteja definido como variável. E esse é chamado de
experiência de textos. Nível de textos. Essa barra de progresso é
chamada de experiência prog. E sim, isso é tudo sobre isso. Como se tivéssemos tudo precisamos e vamos salvar tudo. E no próximo, vamos adicionar funcionalidade
a essa interface do usuário.
102. Funcionalidade de UI de nível: Então, aqui estou de volta à minha interface do usuário
principal e agora vamos adicionar funcionalidade a esse sistema de nivelamento de
experiência. Então, o que
precisamos fazer é ir até o gráfico
e codificar algo. Então aqui eu quero
clicar com o botão direito do mouse e vamos criar novos eventos personalizados e vamos
chamá-lo de experiência de atualizações. E este atualizará
a experiência e o nível. Então, vai ter
essa experiência. E se tivermos a experiência
necessária, vamos atualizar
o nível também. Então agora eu não sei o que
precisamos colocar aqui nas entradas, como se precisássemos descobrir
isso por enquanto, vamos deixar que seja assim. E a primeira coisa que
precisamos fazer é aproveitar essa experiência de
barra de progresso. E assim como antes,
com a Health Bar, digamos definir por cento. E isso definirá
a porcentagem dessa barra de
progresso aqui. Então, ele vai preencher. E geralmente, como aqui, ele
começa como 0 por padrão. Então, vamos definir a
porcentagem por alguma coisa. E depois disso
temos essa experiência. E vamos definir esse texto também no topo
dessa barra de progresso. Então este é esse texto na parte superior. E lembre-se quando
temos textos dinâmicos, exatamente o que eu ensinei antes, precisamos usar texto de formato. Então, novamente, o mesmo método, remova, salve o texto de formato. E precisamos de duas variáveis. Precisamos de quanta
experiência você tem e quanta experiência
é necessária para subir de nível. Então, vamos fazer duas
variáveis aqui. Vamos fazer um colchetes encaracolados e escrever experiência,
experiência. Portanto, essa é a experiência
atual. E então, como fora
dos colchetes encaracolados, estou escrevendo uma barra. E então criamos
novos suportes encaracolados e chamamos de experiência necessária. E faça como terminar
com suportes encaracolados. Então, temos dois suportes encaracolados. Temos este aqui, temos uma barra e
esta segunda. Então agora temos duas variáveis que
podemos definir como variáveis dinâmicas. Vejo que precisamos, como nas informações do jogador, talvez precisemos apenas de uma
informação do jogador aqui porque, em vez de conectar todas essas
variáveis aqui, nós realmente exatamente
como podemos usar, como nós pode atualizar todas essas informações usando
as informações do jogador. Então, na verdade, vou
criar isso como uma entrada e escrever informações da camada,
assim. E vamos chamá-lo de informações do jogador. Na verdade, vamos fazer isso daqui. Então, com o que temos
até agora, vamos experimentar. Vamos pegar as
informações divididas e separá-las. E agora podemos usar
essa porcentagem aqui. Lembre-se que esta é a experiência. Então, quanta experiência você
tem agora dividida pela experiência
necessária que você precisa. Então, vamos ocultar todos
os pinos não conectados para que precisemos da experiência
necessária. Lembre-se, a função que fizemos
na biblioteca é global. Então, podemos apenas dizer para obter as informações do nível e você
pode acessá-las aqui. Você precisa especificar
o nível de um jogador. Temos isso aqui em nossa
estrutura assim. E agora você pode acabar com isso. Agora você tem a experiência
necessária. A experiência
que você dividiu
pela experiência necessária
lhe dará a porcentagem. E, na verdade, há
um pequeno erro aqui. Como quando você faz isso assim, ele realmente vai mostrar
0 porque lembre-se que este é um número inteiro e este é um
número inteiro e isso é um flutuador. Como se fosse processar
esses dados corretamente, mas o número será exibido de forma errada,
porque lembre-se, quando você dividir números inteiros, ele
lhe dará um número inteiro. Não lhe dará
uma porcentagem, como se você não tivesse casas
decimais ou números inteiros. Então, se você disser, por exemplo, a experiência que você tem
é dez dividida por 50. E esse número que você recebe é
um número de casa decimal. Isso não mostrará que
esse número será igual a 0 porque os números inteiros não podem
ter casas decimais. Então, a maneira correta de fazer isso é primeiro converter isso em um flutuador. Então diga dois carros alegóricos. E faça a mesma coisa
para este flutuar. E vamos excluir isso. E agora vamos dizer que
essa experiência dividida. E agora estamos operando
com um flutuador. Portanto, certifique-se de
transformá-lo em um flutuador primeiro você não receberá
essas casas
decimais, mas você só
terá números inteiros. Então agora temos as
casas decimais. Vamos clicar duas vezes e
fazer um nó ferroviário aqui. E agora esse número
que temos agora, podemos usá-lo na porcentagem. Atualizaremos a barra de
progresso corretamente. Ok, então isso está acabado agora. E a próxima coisa, vamos primeiro
clicar neste e esconder o pino apenas para
que ele pareça um pouco melhor. Então, a próxima coisa é que
precisamos atualizar
a experiência que você tem
e eles experimentaram necessários. Isso é muito fácil porque
a experiência
que temos é apenas essa experiência. Deixe-me clicar duas vezes e
fazer um nó de redirecionamento aqui. E a experiência necessária
é apenas esta necessária. Então eu posso clicar duas vezes
e colocá-lo aqui. E deixe-me realmente
arrastar isso para baixo para que ele não transborde a
coisa toda com as linhas aqui. Algo assim. Isso parece um pouco mais
limpo, melhor trabalhar. Ok, então agora temos
essas informações definidas. O que precisamos fazer em seguida é atualizar a exibição do nível
para os jogadores. Então, tomando esse nível de texto, então agora queremos
atualizar esse nível aqui. Então, tomando esse nível
e diga texto definido. E agora isso também é
muito fácil porque
já temos o
nível para o jogador. Podemos apenas pegar
este ou você pode pegar este que depende de você
e conectá-lo aqui. E, novamente, faça um nó de redirecionamento para que ele pareça muito melhor. Algo assim. Agora, na verdade, temos
todas as informações que estamos atualizando, a porcentagem, estamos atualizando o
texto dinâmico nesta barra de progresso. E também estamos atualizando
o texto de nivelamento aqui. Então, agora podemos compilar e salvar, e agora podemos usar essa experiência de
atualização em nosso controlador de jogadores para atualizar a
experiência e o nível do jogador.
103. Como finalizar o sistema de nivelamento: Olá e bem-vindo de volta. Vamos agora finalizar
o sistema de nivelamento. Vamos para o controlador do
jogador. Lembre-se de que fazemos as atualizações da interface do usuário
no controlador do player. Então, indo para o
controlador do jogador aqui, e agora vamos
fazer isso aqui. Temos a barra de
integridade de atualização aqui. Vamos fazer um novo. Para este, vou
chamá-lo de experiência de atualização. Então, na verdade, vamos voltar
às interfaces primeiro no controlador do player
Blueprint Interface. E vamos fazer isso aqui
chamado de experiência de atualização. Vai lembrar de tomar as informações do jogador da estrutura como a variável, porque
essa é a que fizemos. E vamos chamá-lo de informações do jogador. Compile e salve.
Vamos voltar e chamá-lo aqui, atualizar a experiência. E agora, novamente, execute-o
através dos clientes. Lembre-se de que não é o
servidor agora, é o cliente porque estamos lidando com a interface do usuário e a
interface do usuário passa pelo cliente. Então, eventos personalizados
e passando
pelo cliente, dizendo experiência de
atualização. E vamos fazê-lo funcionar para clientes
proprietários e confiável. E vamos adicionar a variável de
informações do jogador aqui. Então, procurando informações do jogador. Agora podemos escrevê-lo aqui, atualização
Cl, experiência. Então, agora ele vai
executá-lo por aqui, executá-lo através do cliente, e o cliente
executará a função de blueprints de
widget que fizemos aqui no WB main, aqui chamada experiência de atualização. Isso é o que
vamos fazer agora. Agora você pode arrastar daqui. E, na verdade, precisamos acessar
o Widget Blueprint principal. E já nos lembramos de ter isso como uma variável em
nosso controlador de jogador. Então, vamos começar daqui
e dizer Atualizar experiência, e você a verá aqui. Então chame aqui, conecte-os
e, em seguida, conecte-os aqui. Então, agora ele vai
alimentar essas informações aqui e atualizar
tudo para nós. Agora não especificamos
onde vamos adicionar isso. Então atualize a experiência,
vamos realmente voltar, vamos salvar tudo e
vamos voltar para o jogador, baixista, base de jogadores. E lembre-se, fizemos esses eventos de experiência
publicitária aqui. E isso é o que
queremos adicionar aqui porque se você subiu de nível
, estamos atualizando
a nova experiência. Estamos atualizando o novo nível. E então ele vai
verificar novamente. Você precisa subir de nível novamente? Se sim, ele
atualizará novamente a experiência,
atualize o nível. Depois disso, ele
vai dizer não, você não precisa mais subir de
nível. Você não está atendendo experiência necessária
para esse nível em que você está. Então, vá em frente e
atualize a interface do usuário aqui. A interface do usuário novamente,
agora é a função que precisamos ou o evento que precisamos para acessar isso dentro
do controlador do player. Agora podemos dizer Get Controller. Estamos dentro
da base de jogadores. E aqui digamos que o controlador do jogador REF
que fizemos muito antes. Vamos conectá-lo aqui. Agora, vamos arrastar disso
e dizer Atualizar experiência. Isso é o que chamamos
de função de interface. E é uma mensagem porque é uma função Blueprint
Interface. Agora ele precisa das informações. Então, vou arrastar
daqui
para baixo e arrastar essas informações
do jogador para ele. E agora ele
atualizará a experiência. Então, vamos compilar
e salvar o elemento ,
na verdade, basta dar muito mais ajuda ao
jogador. Só não quero
morrer o tempo todo. Então, definir as
colinas máximas para talvez 500 e a corrente
ajuda a 500. E vamos jogar agora. Ok, então agora sou o
jogador, estou acertando isso. Agora podemos ver atualizações. Mas inicialmente você pode dizer
que diz 0 de 100. Isso não está correto. Então, precisamos fazer
uma atualização inicial. Lembre-se de que sua interface do usuário só está sendo atualizada sempre que
você ganha experiência. Então, quando você está gerando, você não está atualizando sua interface do usuário. Você só está atualizando
sempre que mata algo. Então, vamos realmente fazer
isso aqui no, deixe-me copiar colar
este código e deixe-me ir até aqui e fazê-lo
no lugar inicial. Então, sempre que
começo a jogar o jogo respondendo o jogador
respondendo à câmera, estamos configurando a visualização da câmera. Eu vou fazer
isso aqui, na verdade. Então, logo após você
definir a visualização da câmera, vou adicionar isso. E vou atualizar minha
interface do usuário como uma atualização inicial. Então, aqui,
algo assim. Certo, e agora vamos
compilar e salvar. Agora vamos clicar em jogar. E você pode ver isso na atualização
inicial e você tem
essas informações corretas agora. Agora pode matar alguma coisa. Isso lhe dá dez experiências. A barra também está sendo atualizada. Incrível, e vamos
ver se subimos de nível. Então, vou matar mais
alguns. Agora parece um jogo. Quando todos os
elementos se juntam. Agora podemos ver que vou me certificar de
que o nivelamento até o nível dois e minha
experiência amassada agora é 75. E se eu continuar matando, agora
vai aumentá-lo. Então, agora ele está atualizando
corretamente, na verdade. E se eu for aqui e
preencher alguns desses aqui, ok, então agora posso ver que
tenho 70 de 75. Então, vamos ver se ele
calcula corretamente. Então, se eu acho que cada foto
dá como 20 experiências, então se eu matar uma, ela deve dizer 15 agora. Então deixe-me matar um. Eu não caio. Ele diz 15, então está realmente calculando corretamente
e me nivelou. Então isso é bom e tudo
está atualizando corretamente. Então, a última coisa que
precisamos fazer é apenas adicionar um efeito sonoro e um
efeito visual para quando subimos de nível. Então, vamos torná-lo um
pouco mais interessante.
104. Nível acima SFX e VFX: Mas a última coisa aqui
no sistema de nivelamento, vamos em frente e
adicionar algum efeito sonoro e visual para subir de nível. Vamos voltar para
a base de jogadores. E dentro daqui, vamos até a
nossa experiência de anúncio, e agora vamos adicionar um multicast. Então, vamos clicar com o botão direito. Faça um evento personalizado. E vamos fazer multicast. E vou
chamá-lo da mesma forma. Você pode chamá-lo de nível ou
vou chamá-lo experiência porque estou
incluindo-a lá em cima. E vou mudá-lo
para um multicast confiável. Vou tocar a
localização sonora como antes. E adicionando essas variáveis em. Vou chamá-lo de efeito sonoro para subir de
nível. Certo? E também queremos jogar como um efeito visual
para quando você subir de nível, mas o efeito visual
é um flip book. Então, nos materiais do curso que
incluí para você, esse nível de textura
que você precisa adicionar. Então, aqui no nível do
personagem, vamos aqui para nossos personagens de
ativos. E vamos arrastar esse
nível de textura. Novamente, clique com o botão direito do mouse e
aplique papel às configurações, e agora extraia esses sprites. E a grade para isso é
que acredito que foi 180 por 180. E agora clique em extrair. E agora vou
renomear todos esses. Então, agora que você os tem
na sua frente, agora vou clicar em todos eles, clicar em todos eles,
clicar com o
botão direito do mouse e
criar um flip book. E vou
chamá-lo de um nível B. Ok, agora vou
clicar duas vezes neste flip book e definir os quadros por
segundo para oito. E você pode ver que está
parecendo um estranho. E isso é, lembre-se, talvez
você possa descobrir, mas provavelmente é porque
isso tem esse material. Então, vamos mudar o
material da máscara para o translúcido. Então, procurando por translúcido. Então, estamos usando isso
algumas vezes agora. Material de
sprite translúcido e sem iluminação, você pode ver que parece
muito melhor agora. Então, vamos fechar esse efeito. E, novamente, se você não
vir esses materiais, lembre-se de acessar
as configurações e habilitar o do
mecanismo de conteúdo dos desenvolvedores e o conteúdo do
plug-in. Se você terminar
com eles, você
sempre pode longe deles assim. Então você não vê todas
essas pastas extras. Às vezes, é irritante
ver todas essas pastas. Então eu só clique fora e
tenho isso mais limpo assim. Então eu só mostro a eles
sempre que preciso deles. Então, vamos voltar
para a base de jogadores e agora precisamos jogar
esse efeito de subir de nível. Mas este é um flip book e não
podemos realmente mudar os
personagens flip books. Então, temos que mudar. Você não pode alterar o flip book
dos personagens. Então, temos que adicionar
outro componente aqui. Então, vamos adicionar um novo componente. E vamos chamá-lo ou apenas
procurar flip book. Então, papel flip book. Vou chamar isso,
talvez você suba o
nível de efeitos V. Você vai simplesmente
chamá-lo de algo assim. Vou anexá-lo
ao meu sprite por enquanto. Para este flip book,
vamos mudá-lo para, Vamos encontrar nosso nível aqui. Este é o efeito amor, amor, então nós o temos aqui. E no início, não
queremos mostrar isso o tempo todo. Então, vou realmente
descer e invisível. Vou remover
este visível aqui, então ele não está visível
no jogo para começar. Então, o que eu quero fazer quando eu subir de
nível é que eu queria pegar isso e definir
a visibilidade para ser visível. Vou conectar isso aqui. Depois que ele estiver visível. Em seguida, vou atrasá-lo por algum tempo e depois
configurá-lo para invisível novamente. Vou atrasá-lo no
momento deste flip books. Vou pegar isso
e dizer flip book,
e podemos escolher este, e podemos escolher este, virar o comprimento do livro e o atraso. E depois de atrasarmos, por mais tempo que este
flip book esteja sendo reproduzido, vamos defini-lo
como invisível novamente. Então pegue essa visibilidade aqui e
conecte-a com esta. Clique duas vezes para fazer um redirecionamento. Agora só para fazer com que pareça melhor, então você pode definir a
visibilidade falsa aqui. Estamos escondendo de novo, seja lá o que for. Terminamos um loop
deste flip book. E eu não tenho certeza se isso realmente
vai ser
jogado desde o início, então estamos configurando isso como visível. Mas e se o que é esse flip books realmente jogando no meio quando o
definimos como visível? Então, na verdade, vou
remover isso daqui. E, na verdade, vamos
defini-lo através do código aqui. Então, estamos configurando isso como visível. E então vamos pegar este flip
book e dizer Set flip book. Porque só queremos
mostrá-lo desde o início sempre que
quisermos mostrá-lo. E então temos que
escolher qual flip book. Não vamos fazer isso aqui.
Vamos arrastá-lo para este evento. E em vez de chamar
novo flip book, podemos chamá-lo de
aumentar o nível dos efeitos. E deixe-me arrastar isso para cima
apenas para torná-lo mais limpo, abrindo-o aqui em vez disso, temos o VFX como
efeitos e a localização. E fazendo um
nó de redirecionamento, na verdade, você pode fazer uma
anotação de redirecionamento a partir deste para
torná-lo melhor, assim. E sim, isso parece bom agora. Portanto, temos essa experiência de anúncio com efeitos e
temos que adicioná-lo em algum lugar e temos que adicioná-lo sempre que o jogador subir de nível. Então, subindo aqui para
a experiência do anúncio, temos que descobrir onde
o jogador sobe de nível. E novamente, se você se
lembrar do código, o jogador sobe de nível. Aqui, podemos simplesmente alterá-lo
aqui no final deste código. Este é o nivelamento do efeito. E vamos pegar isso,
na verdade, levar isso
aqui e dizer
MC, experiência de anúncio MC como esta. E você pode pegar isso aqui e
fazer outro nó de redirecionamento. Ou você, na verdade, vou
colocá-lo aqui em cima. Não há espaço aqui embaixo. Assim mesmo. Ok, então algo
assim aqui. E agora temos essa
experiência publicitária e temos que
escolher o efeito visual
e o efeito visual. Você pode simplesmente adicioná-lo à
estrutura, se quiser. Então, vamos voltar
para a estrutura. Informações do jogador para ir adicionadas aqui. Chame-o para subir de nível como efeitos. E no nível dos efeitos, dos efeitos ou dos efeitos V, vou
colocá-lo aqui em cima. E isso é só porque
eu quero que os efeitos
sonoros fiquem juntos e os efeitos
visuais se você tiver mais para ficar juntos.
Vamos mudá-lo. Este V afeta um flip
book, flip book em papel. E o efeito sonoro
é um sinal sonoro. E lembre-se que já adicionamos
um nível de efeito sonoro. Então compile e salve tudo. E vamos ao jogador aqui. Informações do jogador, e vamos definir o efeito sonoro de nível para ser o mesmo para todos os
jogadores, porque realmente
não temos mais de um. Então, aqui. E o nível de efeitos V, podemos clicar aqui
e dizer subir de nível. E podemos escolher o
que acabamos de fazer. E agora vamos compilar e salvar. E vamos e,
na verdade, escolhê-lo aqui. Então, vamos pegar, podemos realmente quebrá-lo aqui a partir
desta informação do jogador. Já o temos aqui. Então, vamos quebrá-lo. E vamos esconder tudo
e apenas escolher o nível de seus efeitos e o
nível dos efeitos. Conecte-os aqui. E então temos a localização, que é a localização do jogador. Então pegue aqui e diga que recebe localização do
ator. Assim mesmo. E não acredito que
estamos perdendo alguma coisa. Então, vou ocultar esses pinos não conectados
e compilar e salvar. Ok, então agora temos esse efeito sonoro de
nivelamento e
podemos tentar clicar em Play
e ver o que acontece. Então, clicando no
botão de reprodução, jogando conosco aqui. Então agora tentando subir de nível para ver se isso está realmente funcionando. E estou tentando subir
aqui para subir de nível mais rápido. Portanto, existem alguns bugs
com essas animações. Mais tarde, vamos
corrigir na verdade
na próxima lição, eu encontrei. Vejo que, na verdade, subi de nível. E houve algum efeito de jogo. Então, vamos tentar novamente. Bom. Então você pode
ver que o efeito está sendo reproduzido e o
efeito sonoro também está sendo reproduzido. Você pode ver que esse
é o bug que eu realmente quero corrigir
na próxima lição. E agora está parecendo,
na verdade, bonito. E se você quiser que o efeito
jogue em cima da cabeça, lembre-se, você pode
voltar para o jogador. E como você acabou de
adicioná-lo como um efeito, você pode simplesmente ir em frente e clicar nesse nível,
nível de VFX. E lembre-se que este é
apenas um flip book, você o adiciona para que você possa arrastá-lo aqui acima da sua cabeça, anunciado que vai
jogar acima da sua cabeça. E sempre que você subir
de nível vai jogar aqui. Então, salve tudo. Foi isso por enquanto. Agora vamos realmente
ir em frente e corrigir os erros finais que encontrei
enquanto estava jogando o jogo. Eu estava jogando por
cerca de meia hora e estava tentando encontrar bugs. E encontrei dois deles. Então, vamos em frente e corrigi-los. E acabamos, quase
terminando com este jogo.
105. Como corrigir os bugs finais: Ok, então vamos agora consertar os dois livros que
temos atualmente. Então, a primeira é que, se você estiver na carta, você é capaz de atacar e não
queremos fazer isso. Então, vamos para o jogador
a e base de jogadores. E o que eu editei
dentro daqui. Então, na sua lógica de ataque, você só precisa
adicionar este booleano. Então agora temos, é que se você
já está atacando, não
queremos atacar. Se você já está morto, não quer atacar. Aquele que você precisa adicionar. Clique neste plus
aqui e adicione isso. Então, se você já está
escalado , você também não
quer atacar. Então, uma solução muito fácil, só
temos que verificar isso. A segunda coisa às vezes é que os inimigos se ligam
na animação da morte. E isso ocorre porque
esquecemos de adicionar o modo de caminhada. E vamos voltar
para a base inimiga. Então eu estava gastando muito tempo tentando
reestruturar esse código. Então, ele pode tentar ver
aqui e copiar isso. Então, em danos no DNA, temos o controlador de exibição
e eu movi esse cálculo de saúde
primeiro antes de qualquer outra coisa. Então tente disco e
acredito que estes foram primeiro como na frente
deste mais saudável. Mas acho que estruturalmente só
faz mais sentido
calcular a saúde primeiro. E depois de
calcular o ****, você pode definir o modo de
movimentos como nenhum. Acredito que estes
eram o oposto. Então isso estava aqui
e isso estava aqui. Mas acho que parecerá um pouco melhor defini-los no modo de trabalho antes de definir
o estado oculto. A outra coisa é,
se pela lógica, eu descobri que é melhor
usar esse controlador de IA
em vez de, em vez de obter controlador. E obtendo o controlador de IA, descobri que é melhor
usar esse controlador de IA, que também usamos aqui, e a mudança para o
local ou ator. Então, usar esse
controlador de IA e pegar o componente cerebral disso
e, em seguida, interromper a lógica. Certo, então temos isso aqui. E então vou para
o atraso. Acredito que tivemos uma
parada imediatamente. Parar imediatamente a função aqui. Você pode excluir isso e na verdade, vamos
adicionar isso mais tarde. Então é assim que
parece agora, muito simples. E agora estamos atrasando,
assim como antes. Estamos perguntando se o
inimigo está morto ou não. Se o inimigo não estiver morto, ele vai arrumar
essa caminhada e correr, certo? Acredito
que fizemos isso antes também. O movimento ai é o mesmo, tudo é o mesmo. E depois adicionei
algo novo aqui. Então, se o inimigo está morto, somos como em vez
de reiniciar a lógica. Então tente excluir isso
se você tiver isso agora. Portanto, se você tiver o controlador
Get e iniciar a lógica
ou reiniciar a lógica, poderá removê-lo. E, em vez disso, fiz
um novo evento aqui, fiz um chamado reiniciar a árvore de comportamento. Acho que isso é muito melhor
do que reiniciar a lógica. Porque às vezes, quando
você reinicia a lógica, você está realmente
reiniciando essa lógica e não a árvore de comportamento. E é por isso que estou, vou
reiniciar especificamente a árvore de comportamento. Achei que essa
caixa um pouco. E a coisa
assim funcionará perfeitamente se
realmente formos aqui. E lembre-se que eu falei antes, você poderia destruir o que
remove esse ator completamente. E se fizéssemos isso,
não teríamos esse problema. Portanto, este é apenas esse
projeto específico. Então, apenas para este
projeto que estou fazendo, isso será um problema. Mas se você realmente
destruir o ator, isso não será um problema. Mas este dia eu movimento dois ainda
serão executados de alguma forma porque eles param a
lógica e iniciam a lógica apenas inicia essa lógica
em vez da árvore de comportamento. Então eu fiz essa chamada árvore de comportamento de
reinicialização. E é apenas uma
função ou eventos que realmente fizeram dentro
da função de interface base inimiga. Então, se você for para a
interface e a base inimiga, eu fiz essa chamada árvore de comportamento de
reinicialização. E eu chamei aqui
na base inimiga. E então eu fiz eventos de
linha. Então, executar em possuir cliente e confiável e, em seguida,
chamá-lo aqui, é
claro, o cliente. Então ele corre
aqui e para baixo aqui. Estou parando o
movimento imediatamente. E então eu estou parando
a lógica só para ter certeza de que a
lógica foi interrompida. E então eu estou pegando meu controlador de IA e vou
obter uma referência
ao meu controlador de IA. Na verdade, feito aqui. Nós fizemos na interface
ai controller, fizemos isso chamado
Good AI controller ref. Estou recebendo isso para que eu
possa obter uma referência ao meu controlador de IA. E dentro daqui, em vez
do meu controlador de IA, deixe-me voltar agora para o controlador de ar
inimigo. Eu fiz este. Então, antes de termos essa árvore de
comportamento de corrida aqui em cima. E em vez de fazer isso, estou fazendo meu
evento personalizado chamado run AI tree. E quando eu começo a jogar, estou
apenas executando este evento aqui. E a razão pela qual eu
fiz esse evento é porque eu realmente
quero executá-lo também em alguns outros pontos. Então, não só no jogo inicial, mas também quero
executá-lo aqui. Na minha base inimiga
sempre que começo. Reiniciou a árvore de comportamento deles. Então, estou executando essa árvore de IA executada. Acabamos de executar essa
árvore de comportamento como antes. Então é isso que, o que está
essencialmente acontecendo sempre que estamos
reiniciando a árvore de comportamento. Então eu editei aqui, estou executando esta árvore de comportamento de
reinicialização sempre que o jogador está morto. Então, se o inimigo estiver
nos perseguindo e o jogador morrer, ele reiniciará
a árvore de comportamento. Ok, então se o inimigo dado, estamos adicionando a experiência
como antes. Estamos configurando a mesa para ser verdadeira. E aqui, como Pouco antes de
respondermos ou qualquer coisa, estamos removendo os eventos de sobreposição
gerar. Então estamos desvanecendo o personagem. Depois disso, temos
o temporizador de atraso. Estamos deitado algum tempo. Estamos colocando a saúde de
volta ao inimigo. Em seguida, estamos habilitando a
geração de eventos de sobreposição. Então eu adicionei este, o movimento definido para andar
e escrever antes. É por isso que o inimigo estava surgindo na animação da morte. Porque lembre-se
aqui no início, definimos esse modo de movimento nenhum e o
estado do movimento a ser atingido. Quando o inimigo dado. Nunca dissemos isso de volta. Então, quando os dados e a
resposta do inimigo o colocam de volta para andar e correr bem aqui. A resposta do inimigo. Lembre-se de gostar,
eu também mudei isso. Movi a
resposta depois disso porque quero ter certeza de que meus eventos de sobreposição de geração estejam definidos como verdadeiros
antes de eu responder. Então eu respondo, e então
pedi o destino dela definido como falso. E então eu adicionei essa chamada árvore de comportamento de reinicialização. Eu acredito que a
função de morte também estava aqui, então eu a excluí. E o motivo é que
as funções de morte já são executadas aqui. Então lembre-se que tivemos
esse ator desaparecer. E quando o ator se
desvanece, e quando estiver definido
como falso significado aqui, quando estiver definido como falso, e quando o ator se
desvanece, ele vai correr esta morte. Portanto, não faz sentido
ter essa morte aqui em cima. Então, excluindo isso daqui, e acabei de adicionar esse comportamento de
reinicialização para ler apenas para ter certeza de
que está funcionando. E aqui embaixo,
também acredito que tínhamos os direitos de corrida são modo de
caminhada na verdade
a carga de trabalho. Você pode excluir isso
daqui porque agora já
estamos tendo isso aqui em cima. Então, nós realmente não precisamos
tê-lo aqui em baixo. E isso é o que parece e
quando está terminado. Então, quando a morte é definida como falsa, eu também estou executando reiniciando
a árvore de comportamento apenas para ter certeza de que
ela não está incomodando. Além disso, tente deixá-lo
de fora do código e
veja se ele funciona. Se porcas, para reconectá-lo novamente. É assim que
parece agora. E se jogarmos o jogo,
e vamos experimentá-lo. Então, está parecendo muito
melhor agora com o código, como se nada estivesse incomodando. Tentei jogar
por 15 minutos. Então acabei de mudar
a saúde
do inimigo para poder
matá-los um pouco mais rápido. Mas parece que
tudo está funcionando agora. Eles não estão desova
e estocando. Eles não estão surgindo com
sua animação de morte. E podemos pensar em
jogar o jogo assim. Tudo está funcionando
corretamente, como você pode ver. Tão incrível. E esses foram os
bugs para isso. E se os inimigos novamente, nosso recorte um pelo outro, você pode aumentar essa separação entre eles, como eu
disse antes, eu fiz isso aqui também
porque havia recorte. Então eu cliquei no
primeiro, disse o E21, cliquei no segundo
para 1,2, depois o terceiro,
então 14 e cliquei no
quarto, responda a 1.6. Então eu posso aumentá-lo ainda mais. Como se você os vê recortando, você sempre pode aumentá-los. Mas sim, agora tudo está
fixo e espero que vamos realmente testar a escada pouco antes de terminarmos isso. Eu
não fiz isso. Então atacar a carta também não
é impossível, apenas se eu cair da escada. Então você só pode ver quando
eu sou derrubado da carta, eu sou capaz de atacar. Então, de pé na própria
carta, não
sou capaz de atacar, mas se eles me derrubarem
e eu marcar, posso atacá-los. Tudo bem, então foi isso para esta lição e vamos
salvar tudo. E vamos seguir em frente.
106. Como criar a interface de texto flutuante: Olá a todos e
bem-vindos a esta seção. Nesta seção, eu estava
pensando em criar placas de identificação,
mas, em vez disso, vamos realmente criar textos de combate flutuantes. Acho que é mais interessante
neste momento criar isso. E incluirei as placas de identificação nos meus futuros vídeos extras. Para o texto de combate flutuante. São apenas alguns textos. Quando você acertar o inimigo, esse texto aparecerá
e
mostrará quanto dano você
causou ao inimigo, porque agora o jogador não
tem chance de vê-lo. Então ele vai voar para cima e dizer
quanto dano você causou. E se o inimigo bater em você, o inimigo mostrará quanto dano causou
a você como jogador. Então, vamos começar a fazer isso. Vamos começar a trabalhar com a interface do usuário. Então, vá para a pasta da interface do usuário, e aqui podemos clicar com o botão direito do mouse e criar um novo Blueprint de
Widget do usuário. Vamos criar isso aqui. E vamos chamá-lo de w
b e texto flutuante. Então este é o menu
que vou usar. Aqui. Essa interface do usuário será muito simples. Vamos começar novamente com
o painel de tela. Comece sempre com um painel de tela quando você estiver criando a interface do usuário. E dentro daqui, vamos procurar por uma sobreposição na verdade calcula a caixa quantil média. E vou te mostrar
o que estou fazendo aqui. Então, caixa horizontal e a única coisa que
precisamos é de uma imagem
na caixa horizontal e um texto dentro da caixa
horizontal. Então, será apenas alguma imagem
e isso será um ícone, obviamente esta imagem aqui. E então alguns textos
que mostram quanto dano
você causou todo o
inimigo causou a você. Para interface do usuário que você não
precisa de toda a tela. Por exemplo, só precisamos de
algum texto flutuante aqui. Em vez de ir com a tela
, você precisa
alterá-la para o desejado. Desejado é apenas ser
essa parte aqui para que você possa ver a
tela desaparecer
ou, na verdade, ela não desapareceu . Ainda está aqui, mas apenas se redimensionou para
esse conteúdo aqui. Então, com a imagem,
vamos clicar
na imagem e vamos
realmente importar isso. Então, novamente, no
material do curso que incluí para você na interface do usuário e nas imagens, esse tipo e esse ícone de sangue. Então, vamos pegar esses,
vamos para as imagens da interface do usuário. E dentro daqui, vamos importar esses dois. Isso não é escolher slots,
portanto, não precisamos clicar com
o botão direito do mouse e aplicar configurações de vapor 2D. Então, agora vamos voltar aqui e
clicar nesta imagem aqui. Procure sangue, por exemplo. Assim. E agora posso ver que
não está no tamanho correto. Então, clicando nesta
caixa horizontal para que eu possa redimensionar coisas assim para que ela seja
exibida mais corretamente. E clicando
neste em vez de preencher horizontal
e verticalmente, vamos fazer no meio. E para o tamanho, estou apenas fazendo um 44
em torno de 44 pixels. Então, muito menor do que antes. E para o texto, vamos
clicar nele e vamos montar, por
exemplo, algum dano. Por exemplo, fiz
dois 135 de dano. Isso será novamente alterado dinamicamente
dependendo do seu dano. Vamos mudar a fonte para preto. E eu gosto de usar
essas fontes muito pesadas porque quando você está
na área de jogo, quero que o texto
fique muito visível. Então, escolhendo isso e
alinhando-o ao meio. E também aqui embaixo para
a justificativa, também alinhando,
alinhando-a ao meio. Na verdade, vamos
alinhá-lo à esquerda porque ele deve estar na parte
esquerda dessa imagem. Então, quanto mais tempo esse texto
for, será assim. Então, isso é realmente correto.
Vamos, vamos mantê-lo aqui à esquerda para
a justificativa. E aqui para esse tamanho, vamos tentar algo como 30. Então, um pouco maior. E vamos, na verdade,
antes de fazermos qualquer coisa, vamos adicionar um espaçador
entre esses dois. Então, vamos procurar um espaçador entre
a
imagem e o texto. E vamos definir o espaçador para algo como dez,
algo assim. E para este,
vamos adicionar um esboço. Então, no tamanho do contorno, vou colocar um. Então, temos um pequeno esboço. Você pode ver aqui
essa cor preta. Em vez de ser totalmente preto,
vamos, na verdade,
deixá-lo um pouco mais cinza. Então, apenas um leve efeito. Você pode ver a diferença. Este é o antigo,
este é o novo. Então, uma diferença muito, muito
leve, não algo muito pesado. Para a sombra. Na verdade, vou
aplicar sombras. Bem, vamos aplicar 0,5 talvez. E se isso for demais, sempre
podemos reduzi-lo. Então 0,5 e
aplicará sombras para que possamos realmente vê-lo com mais
clareza no ambiente. E quanto à cor,
podemos
mudá-la dinamicamente para
que não
precisemos mudar
a cor aqui. E agora temos que alinhar
o ponto de pivô corretamente. Então, em vez de estarmos alinhados aqui para a caixa horizontal, vamos subir até o topo e
ancorá-lo no meio. E vamos fazer o
alinhamento 0,5 a 0,5 e fazer a posição
0 é 0. Assim mesmo. Agora está alinhado
totalmente no meio. E talvez se você
não
entendesse o que era esse alinhamento, como, se você, se você o tiver de volta para 0, você pode ver sempre linhas
para este canto superior esquerdo. Então 0,5, podemos ver que ele se alinha
no meio ao x. E aqui ele se alinha
no meio ao y. Assim, você pode vê-lo
se alinha ao meio. Se você escrever 0,5 a 0,5, se você escrever um, poderá
vê-lo se alinha dessa maneira, 0 ou linhas desta forma. Então 0,5 está no meio. E você pode ver que ainda
temos algum espaço aleatório aqui. E isso ocorre porque se você
clicar na caixa horizontal, você pode ver que o tamanho
não é como o texto aqui. Assim, você pode clicar
nesse tamanho para o conteúdo, e ele será
dimensionado automaticamente para o que
você tiver aqui. Portanto, se você tiver seu
dano muito maior, você pode ver que a
caixa horizontal será
dimensionada automaticamente
para esse número. Então esse é um
truque muito legal para o tamanho do conteúdo. Então agora temos esses textos de
combate e ele está pronto clicando
na caixa horizontal, você pode ver que está alinhado
no meio e parece
totalmente correto agora.
107. Como adicionar animação de UI: Agora vamos adicionar alguma animação da interface para torná-la um pouco
mais interessante. Então, não trabalhamos
com animação antes. E se você não tiver esse aplicativo, às vezes ele está se escondendo
assim aqui. Então você tem uma guia de animação ou podemos encontrá-la
aqui na janela. Animações. Você
também pode encontrá-lo aqui se estiver fechado. Mas aqui embaixo, você pode
simplesmente clicar e arrastar e você pode ver essa guia de
animação aparecer. Então, queremos criar uma
animação para este ano, e eu quero mover
a coisa toda, tanto o ícone quanto o texto. Então, vou clicar
nesta caixa horizontal e vamos realmente mudar
o nome dela por enquanto. Vamos chamá-lo de HB
para caixa horizontal. E vamos mudá-lo para
texto flutuante para que eles sejam. Então agora temos isso. Então, aqui em
baixo, na animação, você pode clicar neste
botão para adicionar uma animação. E vamos chamá-lo de
carregamento de animação de texto. Agora, você pode clicar nesta animação e clicar em Adicionar faixa. E então você
precisa selecionar ao que deseja adicionar animação? E eu quero gostar que
você tenha que selecionar
a coisa que você precisa
adicionar a animação. Por exemplo, seleciono essa caixa horizontal
e clico aqui. E agora posso clicar nesta caixa horizontal para
fazer uma animação para ela. A coisa é que queremos fazer é primeiro só queremos movê-lo. Então, vai como
quando eu acertar um inimigo, ele vai sair daqui. Então aqui ao longo do tempo, por exemplo, mais de 1 segundo, então o
texto vai voar para cima. Então, essa é a principal coisa que
queremos fazer agora. Aqui na caixa horizontal, posso clicar neste arrasto Adicionar. E eu quero mudar
a transformação. Transforme. Você pode alterar a tradução, que significa o que
quisermos fazer agora. Então, alterando a posição
do texto, isso é tradução. E você pode alterar a rotação, a escala e este ano. Então, vamos começar com
a tradução. Vamos clicar aqui. Então, para a tradução, quero ir de 0. E, na verdade, é
do contrário. É para cima, é assim. Está no menos. Eu quero ir de 0 agora. Acho que depois de 1,5 segundos. Então eu quero fazer minha
animação inteira 1,5 segundos. Então, depois de 1,5 segundos, vou menos 150 no y. Então você pode ver seus pontos
criados. Então você está indo
daqui para aqui, você pode ver como
é fácil fazer animações de interface do usuário. Fizemos como se você estivesse se
preparando fazendo isso, você pode fazê-lo em 15 segundos. Muito fácil, indo
de 0 a menos 150. Ok, então isso parece interessante, mas eu realmente
queria fazer um pouco mais
pela rotação
agora. Está tudo bem. Começa com 0,
mas depois de um 2.5º, então 0,5, quero fazer
cinco na rotação. E depois de 1 segundo, quero ir para 0, novamente. Clicando em 0 aqui, você pode ver que ele adiciona um novo ponto. E se você precisar
mover esses pontos, você sempre pode clicar
no ponto e
arrastá-lo para outro lugar. Se você quiser que seja
mais longo ou menor, você sempre pode fazer isso. Então, assim, você pode ver se eu
apenas removo isso, se eu clicar em
outro lugar também. Agora você pode ver que ele voa para cima, ele gira cinco graus desta forma e depois volta. Se você quiser que ele gire mais, você sempre pode escrever
dez se quiser. Você pode ver agora que
acontece muito mais. Mas eu só queria mantê-lo
em arquivo por enquanto e
sempre podemos alterá-lo se for uma mudança
muito pequena. Então também acho que
será mais interessante, como se o texto entrar em
nossa fase um, ele aparece. Então, depois de 0,3 segundos
clicando na balança, quero fazer dela um tamanho. Então, ele começa com um aqui, e então
parece tamanho de dois. E depois de 0,6, eu realmente quero que ele
volte para um aqui. Então, quando é gerado, ele faz. Isso vem na nossa cara, volta novamente e sobe. Ok, então isso está
parecendo interessante. Mas, como último efeito, acho que também
será mais interessante se ele
desaparecer com o tempo. Aqui em 1 segundo, vou agora na verdade,
é outra
transformação porque ela realmente
não tem uma função de
visibilidade aqui. Então, clicando na
faixa aqui. E enquanto eu o tenho
aqui em 1 segundo, não
é realmente importante. Você sempre pode
alterá-lo se você não tiver feito isso e precisar
alterá-lo para 1 segundo. Novamente, você pode simplesmente clicar
e arrastar esses pontos. Então, tendo uma lágrima em 1 segundo, vou clicar na pista. E então o
chamado opacidade de renderização. Para este,
vou começar com um. Então isso está correto. Depois, indo para 1.5, vou escrever 0, então ele vai desaparecer. Agora podemos ver a animação. Estamos indo disso. E então ele vai subir, e então vai
desaparecer lentamente, assim. Animação tão suave. E você sempre pode clicar aqui
para reproduzi-lo. É assim que parecerá. Animação tão interessante que você pode fazer. E você pode fazer
o que quiser. Você pode clicar nesta
faixa e você pode realmente ver o que pode fazer
também para essa transformação, você também tem uma animação de cisalhamento e tenta pensar qualquer animação que
você está tentando fazer. E acho que esta é uma animação
simples e legal com a
qual estaremos trabalhando. Então foi isso para
essa animação e podemos compilar e
salvar, salvar tudo. E vamos passar
para o próximo.
108. Funcionalidade de UI de texto flutuante: Agora que terminamos com
a interface do usuário e a animação, vamos começar a usar
a funcionalidade dentro daqui e
o Blueprint do Widget. Vamos agora para o gráfico e vamos excluir
esses eventos padrão. Agora, em vez de
aqui, vou
clicar com o botão direito do mouse e criar
um novo evento personalizado. Vamos chamá-lo de atualização. Carregando texto. Texto flutuante atualizado. Muito, muito simples. Ele atualizará nosso texto. Então, clicando neste texto, vamos realmente mudar
o nome primeiro. Vamos alterá-lo para o texto de carregamento do
TXT. E vamos clicar
aqui é variável, senão ela não
aparecerá aqui. E vamos pegar esse
texto agora e dizer esse texto assim. E agora podemos pegar esse texto aqui e arrastá-lo para
essa função ou eventos, porque esse evento
chamaremos para outro lugar
para atualizar o texto. Então, em vez de aqui,
vou
chamá-lo de texto flutuante. Também podemos alterar a
cor do texto. Então, quando o inimigo nos atinge, podemos ter uma cor vermelha. Quando atingimos o inimigo, podemos ter uma cor azul. Assim, também podemos fazer
a variável de cor. Então, tomando novamente este texto, podemos, se você quiser, como se você não
soubesse como a função é chamada e você
sabe o que quer fazer. Você quer mudar a cor apenas para adicionar cor e
ver o que acontece? E é assim que você
acha da melhor maneira. Então você pode ver aqui que
temos algo chamado SetColor e opacidade. Então, escolhendo isso aqui. E agora na
cor e opacidade, você pode arrastar disso
e criar cor de ardósia. E agora você pode ver que você pode
alterar a cor do texto e você também pode alterá-lo se ajusta a uma cor
especificada em primeiro plano. Esse é o padrão. Você não precisa tocar nisso. Você pode realmente
mudar a cor aqui. Então, com isso, podemos realmente pegar a cor
especificada novamente, conectá-la ao nosso evento. Vamos
mudá-lo em outro lugar. E vamos chamá-lo de cor de texto
flutuante. E a última coisa que queremos fazer é mudar
esse ícone também. Então é sangue quando
estamos sendo atingidos e é esse ícone de tipo quando
estamos atingindo o inimigo. Também queremos mudar
isso dinamicamente. Então, vamos primeiro mudar novamente o nome dele e
chamá-lo de imagem, carregando texto e talvez
ícone de ícone de texto flutuante. Vamos compilar e salvar, e vamos para o gráfico. E em vez de aqui,
vamos agora arrastá-lo e dizer que este é
chamado Set brush. Se você apenas procurar
o pincel a partir da textura, e isso é uma
textura e é
por isso que dizemos Definir
pincel da textura. Então, vamos conectá-lo
e você pode ver que você pode encontrar todas as
suas texturas aqui. Mas queremos
mudar dinamicamente. Então, vamos arrastar essa
textura e fazê-lo aqui. E vamos chamá-lo de ícone de texto
flutuante. E deixe-me organizar
as coisas um
pouco melhor aqui para que
você possa clicar duas vezes. Na verdade, você
também pode simplesmente arrastar
este aqui para cima.
Acho que é melhor. E arraste-o aqui. Pressione a sugestão para
alinhar tudo. E eu acho que isso
está parecendo bom. Então isso é o que temos até agora. Essa é a funcionalidade. E lembre-se, queremos
reproduzir nossa animação. Então, aqui em cima, no
Event Construct, você pode escrever a
construção de eventos e isso
provavelmente começará a jogar. Lembre-se de que usamos o
Begin Play e nossos outros projetos. No entanto, ele é chamado Event Construct quando você
está lidando com UI, isso é a mesma coisa. Isso é exatamente como sempre que você joga o jogo e
constrói a interface do usuário. Então, aqui, o que queremos
fazer é ver nossa animação, animação de
textos flutuantes. Isso é o que criamos. Obtenha essa variável aqui. E a coisa mais simples que podemos arrastar
isso e
dizer Play Animation. Agora vamos
reproduzir a animação. Nós realmente não precisamos fazer mais. Então, foi isso. Vamos tentar isso um
pouco para baixo. Então, agora temos a
funcionalidade dessa interface do usuário aqui. Agora, com essa funcionalidade, podemos chamar isso em
outro lugar e atualizar a interface do usuário.
109. Como criar o ator de texto flutuante: Ok, então temos que criar
um ator de texto flutuante agora. Então, quando você danifica e
inimigo ou o inimigo o danifica e
você quer
gerar essa interface aqui. Se você quiser
gerá-lo para o mundo, lembre-se de que precisa de
algo para gerá-lo. Você não pode simplesmente gerar algum texto
aqui sem nada. Então, na verdade, precisamos de um
ator e precisamos gerar esse ator sempre que
o inimigo for atingido. E depois removemos esse ator sempre que
o texto terminar. Então, indo para os blueprints
e dentro daqui podemos clicar com o botão direito do mouse e podemos
clicar na classe Blueprint. E então podemos simplesmente criar um ato simples ou não um papel. Na verdade, queremos
criar um normal aqui. Eu tentei com o papel
e na verdade não funcionou. Então, temos que usar um normal. E fazendo isso, vamos
chamá-lo de texto flutuante PP. E vamos clicar nele aqui. E o que queremos fazer aqui, não
queremos adicionar
nada à janela de exibição, mas aqui nos componentes, vamos clicar aqui e
vamos procurar widgets. E você pode ver que você tem
algo chamado widget aqui. E este é um widget 3D. Portanto, não é como a interface do usuário
aqui que fizemos. Quando você adiciona um componente
aqui, você pode
vê-lo , na verdade, também ativo
para a janela de exibição. É um Widget 3D
e é assim que você faz coisas como mostrar
eu no mundo. Então eu falei sobre a
placa de identificação mais cedo. Vamos fazer isso
nas lições extras, mas fazendo as placas de nome, isso será a mesma coisa. Fazendo esses widgets 3D
porque queremos
exibi-los no mundo e talvez eles devessem
seguir o personagem. Então, aqui criamos um widget. E você pode ver à
direita no widget, no painel Detalhes, você pode alterar algumas configurações. Então, em primeiro lugar, você precisa
escolher a classe do widget. Olhando aqui, você tem que
selecionar o que acabou de fazer. Então, o texto
flutuante do blueprint do widget. E posso ver que ele aparece
aqui, a janela de exibição. Então, vamos compilar e salvar. E em vez de fazer o mundo, então, se você escolher o mundo espacial, ele aparecerá
assim no mundo. Como um personagem
pode girar em torno desse texto
e vê-lo em 3D. No entanto, eu só quero
que ele seja exibido. E o que a tela significa é justo, ela sempre estará voltada para
nós na tela. Não quero que se
pareça com texto 3D. A tela será a correta. E vou dizer
desenhe o tamanho desejado. Então, no entanto, fizemos isso
em nosso Widget Blueprint, e foi isso para este. Então, este foi realmente
fácil. Então, vamos ao Event Graph e adicionar a funcionalidade dele. Então, vamos excluir
esses padrões. E para este, vou clicar com o mouse e fazer
seu evento personalizado. Eu não quero fazer uma função Blueprint Interface apenas para
esses textos flutuantes
porque eu não acho que preciso de mais coisas aqui. Então, vamos fazer deste
um evento personalizado aqui, e vamos chamá-lo de
exibição de texto flutuante. E para este, vou pegar este widget. Vamos, na verdade, renomeá-lo. Vamos renomeá-lo para widgets de texto
flutuantes. Então, vou levá-lo aqui. E então temos que dizer
Get User, objeto widget. E agora temos que lançá-lo para o
passado para o que você é que
você escolheu aqui. Então, o texto flutuante WB, um custo para o WB carregando texto
e, em seguida, conecte-o aqui. E agora temos acesso a
esse Widget Blueprint, para que você possa chamar
qualquer coisa daqui. E lembre-se da
coisa que queremos chamar deste Widget Blueprint, deixe-me realmente
torná-lo maior aqui. O que queremos
chamar dele é esse texto flutuante de atualização. Então aqui podemos procurar atualizações carregando textos e você pode chamar essa
função a partir dela. E apenas certifique-se de que o destino
seja esse texto flutuante do WP. E isso é tudo o
que você precisa atualizar. E agora
vou arrastá-lo aqui novamente para este evento
porque vamos
chamá-lo em outro lugar. Assim mesmo. E este, na verdade, vou
executá-lo como um multicast. Então, isto é, lembre-se do
que eu disse antes. Um multicast só pode ser executado
por meio de um evento de servidor. Então você pode imaginar que
terá um evento de servidor em algum lugar. Então, criaremos
um evento de servidor mais tarde. Então, isso está sendo executado agora através do multicast e
exibirá essas informações
para todos os jogadores. E a razão pela qual
estou chamando isso
no multicast e
não em uma notificação de representante. Novamente, esse texto de combate
aparecerá e desaparecerá. E para jogadores que
ainda não se
conectaram ou estão longe, essa informação
será irrelevante
porque desaparecerá
após 1,5 segundos. Portanto, não faz sentido para um representante notificar porque lembre-se, Eric notify é algo
que notifica todos
os clientes também quando eles
se conectam dez minutos depois. Então, se você fizer isso em uma
notificação de representante dez minutos depois,
quando eles se
conectarem , eles verão todo
esse texto de combate de spam que aparecerá e desaparecerá
após 1,5 segundos, mesmo que dez minutos. Então, não
queremos isso. Vimos que um multicast
só o mostrará aqui e agora se apaixonou pelos outros jogadores
conectados que estão perto de você. Então, reproduzindo esse multicast, ele exibirá esses textos
flutuantes. E lembre-se, este é um ator. Um ator quando você o cria para
o mundo, você tem que removê-lo em
algum momento porque
mesmo que você esteja reproduzindo este texto aqui e essa
animação desaparece assim. Lembre-se de que você gerou
um ator e
esse ato, esse ator
não desaparecerá sozinho. Então, temos que destruir
esse ator em algum momento. Então, na verdade, vou
levar isso aqui e levar minha animação flutuante. Então, vou chamar isso aqui. Você tem algo chamado
get and time porque eu quero excluir esse ator depois que essa animação
for reproduzida. Então eu posso conseguir desta vez. Então, 1,5 segundo. Eu posso realmente obtê-lo assim, pegando a animação, obtendo a enzima que é de 1,5 segundos. E agora posso colocar um atraso
e conectado aqui. Agora, com isso, posso
destruir o ator. O que isso está fazendo é atualizar meu texto e estou dizendo a ele para esperar por quanto
tempo essa animação for. Então, se em algum
momento você quiser mudar essa animação para cinco segundos, isso é muito legal porque agora ela muda automaticamente para cinco segundos porque está apenas recebendo o horário de término
de sua animação. E estamos atrasando isso. E então estamos destruindo esse ator aqui porque não
precisamos mais dele. Então foi isso para esse ator de texto
flutuante. E agora vamos
realmente seguir em frente e fazer a lógica de textos
flutuantes maiores.
110. Lógica de texto flutuante: Agora vamos trabalhar na lógica de texto
de upload maior. Então, o que queremos fazer é exibir um texto flutuante novamente
quando o inimigo,
o inimigo atinge você e
quando você atinge o inimigo. Então, dependendo de quem
está batendo, quem, por
exemplo, se
você acertar o inimigo, quero que o texto
fique acima do inimigo. No entanto, se o inimigo bater em você, quero que o texto esteja acima de você. Então, precisamos fazer isso
tanto para a base de jogadores aqui. E também precisamos fazer
isso para a base inimiga. E lembre-se, nós fizemos um
pai para ambos. Então lembre-se aqui, a base de
personagens é aparente tanto para a
base do jogador quanto para a base inimiga. Então fizemos isso no
início deste curso. Então, vamos realmente codificar isso dentro da base do
personagem
, porque então podemos usá-lo
tanto na base inimiga
quanto na base do jogador. E agora você pode ver como é
útil criar um pai para todos esses itens. Então, em um ponto posterior, se você quiser fazer com que os
inimigos soltem itens, e eu também acho
que
faremos isso nas lições extras. Basta dar uma olhada no meu curso. Talvez eu já tenha
feito muitas lições
extras no momento em
que você está assistindo a este curso. Mas para os itens, novamente,
queremos criar, clicar com o botão direito do mouse
e criar um ator. E então queremos
criar uma base de itens. E a partir do item, queremos criar, por
exemplo, a base de itens da missão. E a partir do item Quest, quero criar itens de missão. Então, muito, muito boa
prática para criar um blueprints base,
porque depois você pode usá-los
a seu favor. Então, vamos para o
caractere baseado e faça o texto flutuante. Então, vamos abrir o editor de
blueprint completo. Vou excluir todos
esses eventos padrão. E aqui Vamos começar a criar nosso evento personalizado de
texto de fonte de exibição. Então, chamá-lo exibe texto
flutuante. E podemos criá-lo em uma função
Blueprint Interface. Mas agora, na verdade, não sei quais variáveis precisamos. Então, vamos começar a
fazer um cliente. Você sempre pode trocá-lo. E vamos até aqui, fazer novos eventos personalizados e
executá-los pelo servidor. Porque lembre-se no texto
flutuante aqui, você fez um multicast. Então, temos que executá-lo através do servidor e
temos que fazê-lo aqui. Então, executá-lo
no servidor aqui. E deixe-me realmente
dar um nome a ele. Portanto, o servidor exibe o texto carregando. Para este, vamos
chamá-lo aqui novamente. Então estamos acostumados a isso agora e eu não chamei
isso de algo corretamente. Então, exiba, e vamos tentar novamente, servidor exibe texto flutuante. Ok, então aqui o que
eu quero fazer como uma variável realmente
quer os atores. Então, se é o inimigo
ou é o jogador, porque lembre-se que esta
é uma base de personagens. Então, na verdade,
não faço ideia agora se é o jogador ou o
inimigo sendo danificado. Então deixe-me procurar por ator
na variável aqui. Escolha este ator. E vamos mudar o
nome para ator danificado. Então, precisamos saber
quem está danificado, é o jogador ou
é o inimigo? Agora podemos clicar com o botão direito do mouse sobre esse dano e
promovê-lo para uma variável. E vamos
chamá-lo de ator danificado. Agora podemos definir a
replicação para replicá-la. Portanto, o cliente
também pode ver esse valor. E obviamente temos que arrastar isso para este evento também, porque este estará ligando para
outro lugar em algum momento. Então agora temos este
e quero gerar meu ator de textos flutuantes no local onde o
ator foi danificado. Então, vamos levar esse
dano ao ator. E, na
verdade, o que queremos fazer, vamos realmente
criá-lo para que você possa vê-lo. Acho que será
confuso se eu começar por aqui. Então o que queremos
fazer é gerou esse ator,
então gerou o
texto flutuante da BP. Textos flutuantes. Então, estamos tentando gerar
esse texto flutuante. E aqui você
tem que selecionar, tentar ajustar a localização, mas sempre aparecer apenas para garantir que ela esteja
sempre desova. E para essa transformação de desova, temos que dirigir daqui
e dizer fazer transformação. Agora estamos quebrando para ver a localização
e a
rotação e a escala. E isso é o que
você está tentando fazer. Estamos tentando agora gerar esse texto flutuante acima
do ator danificado. Então, estamos tentando pegar esse ator danificado e
dizer obter localização dos atores. Porque lembre-se que
este é um ator. Então, conseguindo a localização dos atores, podemos simplesmente
conectá-lo assim. No entanto, quero gerá-lo um
pouco acima do ator. Não quero gerá-lo no meio
do ator. Então, na verdade, vou dizer
quebra e quebrar esse vetor. Então eu posso ver o X, Y e Z. Na verdade,
estou fazendo
o mesmo aqui. Estou pegando isso e
dizendo make vector. E agora o x é o mesmo, o y é o mesmo.
É apenas o z. Então, aqui em cima, se você
quiser que o texto fique um pouco para cima,
é o eixo z. Então eu estou pegando esse
eixo z e estou dizendo mais talvez 30 ou
algo assim. Você tem que testar isso e , em seguida, você estará
conectando-o assim. Então o x é o mesmo,
o y é o mesmo. E estou apenas ajustando
o valor z para estar um pouco acima do ator. Vamos arrastar isso para cima e organizar
isso um pouco melhor. Então, agora respondendo esse
texto flutuante neste local, então a rotação é a mesma, então zeros é 0 e
a escala é a mesma aqui, não
precisamos tocar nisso. Agora, aqui podemos promover isso para uma variável e podemos
chamá-lo de texto flutuante. Então agora este é o ator que geramos sempre que
atingimos o inimigo. Ok, então desse ator, lembre-se que você fez
esse multicast e agora você realmente tem uma
referência a esse ator. Você pode arrastar daqui e dizer exibir texto flutuante,
exibir o texto de carregamento. E não é
da base de caracteres, é chamado de
função aqui. E certifique-se de que o alvo seja textos
flutuantes da BP para
garantir que ele venha daqui. Agora você pode realmente
atualizar esse texto. Muito legal. Você pode chamar esse evento, ele passa por aqui
e, em seguida, você pode realmente
atualizar esses textos flutuantes. No entanto, lembre-se, eu disse antes que estaremos
mudando as cores. Por exemplo, se
o jogador
nos acertar ou se o jogador acertar o inimigo, o inimigo, ou ele
exibirá uma cor azul aqui. No entanto, se o inimigo nos atingir, ele exibirá uma cor vermelha. Portanto, não podemos fazer
isso assim porque na verdade não sabemos se esse
ator danificado é um jogador ou não. Então, o que você pode fazer, você pode pegar esse ator
danificado e dizer que o ator marcou Jogador ou
ator marcou inimigo. Porque todos nós, já
sabemos o que o ator tem tag. Nós o usamos antes. No entanto, acho que mais tarde, se fosse um jogo como um verdadeiro, outro curso talvez
você tenha toneladas de mapas, toneladas de personagens de dano, e você realmente
precisa de
mais variáveis do que apenas jogador e inimigo. Você pode realmente
criar uma enumeração aqui que
será muito melhor,
muito mais dinâmica
e, em seguida, muito mais fácil para você. Então, vamos realmente fazer
isso na próxima lição.
111. Enumeração de texto flutuante: Portanto, para essa enumeração, vamos clicar com o botão direito do mouse e vamos criar uma enumeração de blueprint. Vamos chamá-lo de um tipo de texto
flutuante. Dentro dessa enumeração de tipo de
texto flutuante, vamos adicionar duas coisas. Vamos adicionar aqui,
chamá-lo de dano da camada. E vamos chamá-lo
aqui, dano inimigo. Portanto, pode ser dano de camada
ou pode ser dano inimigo. Agora podemos pegar essa
enumeração e voltar para a base de jogadores ou com base
em personagens aqui. E agora deixe-me excluir esses textos
flutuantes por enquanto. Então, antes de chamar isso agora vamos realmente
adicioná-lo a este evento. Vamos adicionar essa enumeração. E foi chamado de tipo de
texto flutuante E selecionado aqui. E, novamente, chame-o de tipo de texto
flutuante. Para esta enumeração,
vamos arrastar e dizer alternar. Lembre-se que já usamos
isso algumas vezes. Agora, ative a enumeração
para que possamos verificar se
é dano inimigo ou
dano do jogador que foi aplicado. Então, se for
dano do jogador, lembre-se, ele será gerado acima do inimigo porque
o jogador danificou o inimigo. O dano surgirá
acima do inimigo. Então eu vou pegar esse ator
danificado e podemos dizer obter referência inimiga porque queremos pegar esse ator agora. Queremos gerá-lo
acima do inimigo. Agora. Você pode fazer isso assim. E para o, para
o dano inimigo, você pode tentar pensar o que podemos fazer e talvez você já tenha
adivinhado. Vamos pegar esse ator danificado. E agora digamos
Obter Referência do Jogador porque queremos
gerá-lo onde o jogador está. Então, se o inimigo
danificar o jogador, queremos gerar o
dano acima do jogador. A referência dos jogadores. E a partir daqui, agora podemos pegar esse texto flutuante e
podemos arrastar e dizer novamente, exibir o texto de carregamento e
podemos chamar essa função. Agora podemos adicioná-lo aqui. Vamos copiar colá-lo aqui em baixo. E você pode arrastá-lo
novamente para os alvos. E vamos arrastá-lo um pouco para baixo para que tenhamos mais espaço para
trabalhar . Assim mesmo. E se você quiser, você pode
clicar duas vezes para fazer, redirecionar o nó e fazer com
que pareça um
pouco mais enxuta. Algo assim. Ok, então agora podemos
atualizar esse texto dependendo se
for um jogador ou não. E deixe-me arrastar isso para que eu possa realmente ver
o que está acontecendo. E agora podemos arrastar
isso e toda a lógica que
atualizará esses dois
estará entre aqui. Então, primeiro, para
o texto flutuante, será a quantidade de dano. Portanto, esse é o dano do jogador. Precisamos mostrar quanto
dano o jogador causou. Então agora no inimigo, lembre-se que já temos
isso, qualquer evento de dano. Então, vamos para o
inimigo, base inimiga. E dentro da base inimiga
já
temos esse evento de dano. Então, a partir deste evento de dano, já
sabemos quanto
dano o jogador causou. Então, vamos clicar com o
botão direito do mouse sobre este e promovido a uma variável para que
possamos usá-la. E vamos chamá-lo de valores de dano
do jogador. Vamos nos conectar e
lembre-se de replicá-lo. Portanto, o cliente
também pode ver esse valor. Temos que fazer a
mesma coisa mais tarde. Então, vamos fazer a mesma
coisa para o jogador aqui. Então, para o jogador, quando o
inimigo danifica o jogador, também
precisamos fazer aqui botão direito do mouse promovido
a uma variável, e vamos chamá-lo de quantidades de dano
inimigo. Ok, então estamos promovendo aqueles que são
variáveis porque
realmente queremos usá-los. Então, replique este também. Lembre-se de fazer isso. Agora, vamos voltar
para a base de jogadores. Então, quanto o jogador
danificou esse inimigo? Então podemos tirar
isso do inimigo
e dizer que os valores de dano do jogador. E agora podemos
conectá-lo aqui e ele vai
converter seu flutuador em um texto. Podemos fazer a mesma
coisa aqui em baixo. Podemos dizer que o inimigo os
danifica. E podemos conectá-lo novamente. E agora exibirá quanto dano o inimigo
causou ao jogador. Agora, quanto à cor dos textos
flutuantes, você pode clicar aqui. Então, vou torná-lo
azul para quando o jogador acertar o inimigo. Portanto, este é o dano de Blair e ele será
exibido como azul. Então, deslizando isso
lá em cima e apenas escolhendo
algo aleatório. E para a saturação, na verdade
vou escrever 0,5. Não quero que seja muito
azul. Então, clique em OK. E para este, você pode tentar fazer o mesmo. Então, apenas para escolher uma cor vermelha, talvez mais rosada assim. E, em seguida, definindo
a saturação como
0,5 assim e clicando em OK. Então Agora, para o ícone flutuante, então quando o jogador
danificar o inimigo, quero mostrar a espada aqui. Então, procurando por dor, você pode escolher isso,
no entanto, para os inimigos. Então, quando o inimigo
danificar o jogador, quero
procurar esse ícone de lote. Então agora temos, está
sendo dinâmico aqui. Tudo bem, então agora
terminamos com essa lógica aqui. Este foi o mais difícil
na verdade. Então agora temos essa lógica completa. Então, temos que chamar
esse evento em algum lugar. E, na verdade, estaremos fazendo uma função de
biblioteca de textos flutuantes porque isso
será mais fácil de chamar. Lembre-se que já fizemos
algo dentro
dessa biblioteca e temos que
chamar esse evento. E ele vai
passar pelo servidor. Vai levar
esse ator danificado. Então, desta vez, é ator que
estaremos conectando mais tarde. E ele levará esse
ator, tomará a localização, gerará o ator de
texto flutuante acima do inimigo ou do jogador,
dependendo de quem foi danificado. E então, se for imagem borrada, então temos que definir isso
também mais tarde. Se for dano do jogador, ele vai pegar
o inimigo e mostrar a quantidade de dano
do jogador. E também exiba esse texto flutuante
através do multicast. E se o dano
for dano inimigo, ele vai pegar a camada TSP porque este
é o ator danificado, são os inimigos
que
danificam o jogador. E ele vai levar
esse valor de dano inimigo e ele vai
jogá-lo neste multicast. O Multicast será executado aqui. Ele vai usar esse Widget Blueprint e
ele será atualizado. Então, vamos voltar aos
nossos projetos de widgets. Ele vai para
este evento aqui, atualizará o
texto, a cor dele e também o ícone do texto. E depois de atualizar essas coisas, ele vai esperar até que
essa animação tenha terminado. E então ele vai
destruir esse ator porque não queremos
continuar gerando l. Então o jogo vai em
algum momento um atraso porque você não
remove seus atores. Então agora tudo isso terminou. Vamos realmente seguir em frente e vamos continuar e realmente terminá-lo. Então, aqui está o evento que
queremos chamá-lo.
112. Função de biblioteca de texto flutuante: Tudo bem, então estamos quase terminando com os textos
flutuantes. Então, agora vamos
para as bibliotecas. Já fizemos um e vamos
para a biblioteca de funções. E dentro daqui, vamos
adicionar uma nova função, e agora vamos chamá-la de
exibição de texto flutuante. E a razão pela qual eu
estou criando isso dentro
daqui é porque
esse texto flutuante, talvez precisemos dele em
muitos, muitos atores e eu não quero fazer isso em
todos os atores. Então, novamente, uma coisa boa para usar uma biblioteca
é quando você quer
chamar uma função em muitos
atores, atores de blueprint. Então, exiba textos flutuantes. Posso imaginar, mesmo
não tendo criado meu remunerado, posso imaginar que vou
usar isso em muitos atores e é por isso que estou
lendo aqui dentro. O texto flutuante,
novamente, precisa da entrada de um ator porque precisamos do
ator danificado que criamos antes. E precisamos do tipo de texto
flutuante. E esta é a enumeração. Então, vamos primeiro selecionar
a variável ator. E então vamos selecionar
os textos flutuantes. Este é o tipo de texto
flutuante de enumeração. Agora, a partir desse ator danificado, temos que chamar o evento do jogador ou do
personagem, base de personagens. Temos que chamar isso. Deixe-me realmente transformá-lo em uma função Blueprint Interface. Então, vamos para as interfaces e não temos uma agora. Então, vamos clicar com o botão direito e Interface de
Blueprint. Agora vamos chamá-lo de base de
caracteres. E dentro daqui, digamos que precisamos ter esse chamado recebe referência de
caracteres. E este terá uma saída de base de caracteres selecionada aqui. E vamos chamá-lo de personagem,
Compilar e Salvar. E agora vamos voltar
para a base de caracteres, ir para as Configurações de Classe e Adicionar sua Interface de Blueprint
dentro daqui, base de caracteres,
Compilar e Salvar. Lembre-se de
compilar aqui também, então isso
não aparecerá para você. Então, clicando nele aqui. E para este, vamos
apenas dizer a si mesmo. Então, fizemos isso
algumas vezes agora. Então, com isso, agora
podemos obter uma referência. Então, na biblioteca,
podemos arrastar isso e, em seguida, nos referir
em vez de lançar, agora
podemos dizer que obtém referência de
caracteres. E a partir daqui podemos
chamar esse evento chamado. Vamos voltar aqui,
exibir texto flutuante. Agora, na verdade, também precisamos
deste dentro dele, e eu vou excluir isso. Na verdade, podemos fazê-lo agora dentro desta Interface de
Blueprint, vou excluí-lo e
chamá-lo de texto de carregamento de exibição. Então os compostos salvem
aqui e aqui podemos procurar busca. Podemos criar um novo chamado
Display, texto flutuante. E, na verdade, antes de eu terminá-lo, às vezes ele sai. Então, deixe-me primeiro criar
minhas entradas aqui. Ator ou ator danificado, em vez de ator tão danificado. E o segundo era o tipo de texto
flutuante. E vamos encontrar a enumeração. E então encontre o ator danificado, que é apenas um ator. Assim mesmo lá em cima. Basta reproduzir texto flutuante, assim como este,
Compilar e Salvar. Agora, com base em caracteres,
você pode clicar com o botão direito do mouse e dizer exibir texto flutuante, e você pode selecioná-lo aqui. E agora é uma função Blueprint
Interface. Você pode conectá-los. Isso agora na biblioteca, agora
você pode chamar essa
exibição de textos flutuantes. Certo? Tudo bem, Bom daqui e
digamos exibir texto flutuante. E é uma mensagem porque é um
evento de interface de blueprint aqui. Ator tão danificado,
é só este. Então, vou clicar aqui
e fazer um nó de redirecionamento. Na verdade, não faça um redirecionamento. Observe que parece um pouco estranho. Então, apenas fazendo isso. E para o texto flutuante, vou fazer isso. Isso é simplesmente o que
ele vai fazer. Agora, a última coisa,
agora podemos usar essa função, na verdade
estamos terminados. Podemos usar essa
função de biblioteca para chamá-la em outro lugar. Então agora vamos para o inimigo. O inimigo. Aqui. Quando o inimigo for danificado, queremos gerar o
ator acima dos inimigos. Então aqui, sempre que os
inimigos forem danificados, agora
você pode dizer, você pode clicar com o botão direito do mouse e dizer que você chamou
dentro da biblioteca. Então, indo para a biblioteca e você chamou de exibir texto flutuante. Então você pode clicar com o botão direito do mouse
aqui e dizer exibir texto flutuante. E você pode ver que está aqui
na biblioteca de funções que
exibe texto flutuante. Agora, você precisa
conectá-lo aqui e você
precisa especificar o que é
o ator danificado. É eu mesmo, é o inimigo. E qual é o texto flutuante? É, na verdade, é dano ao
jogador. Então isso está correto,
na verdade,
agora . Vamos copiar isso aqui. Vamos voltar para a base
de jogadores agora. E para o jogador, se
o jogador estiver sendo danificado aqui, vamos colá-lo. E quem é o ator danificado? É o próprio jogador. Qual é o tipo de Dano, é dano NME. Então agora ele vai realmente tocá-lo e eu
vou mostrar para você. Então, vamos clicar em Jogar por
enquanto e ver o que acontece. Então, na verdade, vou
jogar como servidor aqui, como um servidor de escuta.
Como o servidor. Agora, você pode ver
quando eu fico danificado está realmente sendo exibido
quando eu atingi o inimigo. Vai mostrar
esse dano aqui. Muito legal. No entanto, se eu jogar como
cliente e eu for atingido aqui, você pode ver que nada está
sendo exibido e isso foi o que estaremos
falando na próxima lição. Então, para esse cliente, eu não vou me
preocupar com isso por enquanto. Mas para este jogador aqui, você pode ver os danos do cliente
exibidos no servidor. Mas se você for ao cliente, ele não está mostrando
nada no servidor. Você pode ver que agora ele está
sendo exibido corretamente. E deixe-me mostrar
o que está acontecendo agora. Então Wendy, agora estamos
dentro dos jogadores. Então, quando o jogador fica danificado, estamos chamando essa função
aqui da biblioteca. Então, estamos especificando quem
é o ator danificado,
é o próprio jogador. E isso é dano inimigo
que está acontecendo. Agora ele vai para
a biblioteca de funções, e ele vai
passar e chamar essa exibição de textos fluindo
da base de caracteres. Base de caracteres. Agora
chamando esse evento aqui, passando pelo servidor, o servidor vai
definir essa variável e estamos tentando encontrar essa localização de atores
danificados, respondendo esse texto no local
da atriz. E quando respondemos
ao texto, verificamos, é dano claro ou
é dano inimigo? Se for um dano de prazer? Vamos fazer isso aqui. Chame esse multicast a partir
do texto flutuante BP. E estamos definindo
isso dependendo se for dano inimigo
ou dano do jogador, das cores e dos ícones. Portanto, esse evento é
do texto flutuante da BP, que está aqui. Agora ele continuará
com esse multicast. Passá-lo a todos os jogadores está tomando este plano de widget. E então ele vai
passar e atualizar o
texto flutuante nesse widget, que está aqui. E agora exibindo esse widget, Ele será definido
para este evento aqui. Ele vai definir o texto e cor
do texto
e definir o pincel. E depois disso, ele vai esperar até isso,
essa animação
aqui que fizemos. Então, ele vai esperar até que
essa animação tenha
terminado antes de
destruir o ator. Porque se você fizer isso antes, ele nunca mostrará os textos porque ele irá
destruí-lo rapidamente. Então, isso é o que está acontecendo. Você pode ver que são muitos passos, mas uma vez que você fica
muito bom nisso, isso é realmente
muito fácil de fazer. Então, passando pela biblioteca de
funções, passando pelo
caractere baseado, passando pelo servidor, executando o multicast aqui. E depois do multicast, você está realmente atualizando
esse texto aqui. Ok, então terminamos
com o texto de combate. E a razão pela qual o cliente não
está recebendo tudo isso é muito fácil e provavelmente
levará um
minuto para explicar. Então, vamos realmente fazer
isso na próxima lição.
113. Replicação de actor: Certo, então por que isso? O cliente não consegue
ver esse dano aqui. Então, quando fico danificado, posso vê-lo como o servidor
e dano o inimigo. Eu também posso vê-lo, no entanto, se eu sou o cliente, então se eu realmente
abrir o cliente aqui,
então, como o cliente, eu
realmente não consigo ver
esse dano aqui. Por que isso? E isso é por causa
da replicação de atores. Então, até agora
replicamos essas variáveis e
replicamos eventos, mas não replicamos atores de
blueprint. Então, vamos para o
texto flutuante aqui, texto flutuante Vp. Deixe-me clicar nos padrões
da classe para
este ator de textos flutuantes. E você pode
clicar neste chamado replicates. Isso é o que você está perdendo. Então, clicando aqui e indo para
os textos flutuantes também, o widget Durante
até a parte inferior. E você precisa clicar nessa chamada replicações de
componentes. Lembre-se de que estamos no multijogador. Então clique em Jogar. Agora, ao
clicar em jogar como cliente, agora
você pode ver que o cliente também
pode vê-lo. E essa foi a única
mudança que estava errada. Então, apenas essas duas marcas de seleção. E talvez
agora você esteja perguntando, por que não fizemos
isso antes? Por quê? Por que temos que fazer isso agora? Como por que tudo isso funcionou? Sem nós clicar aqui? E isso ocorre porque o personagem com o qual
estamos trabalhando é replicado por padrão
no Unreal Engine cinco. Então, clicando neste jogador, você pode ver que são realmente
baseados em personagens. Então, clicando na base de
caracteres, você pode ver aqui
na classe padrão para a base de caracteres, essa replicação
já está marcada para você. Portanto, os caracteres dentro do Unreal Engine são
replicados por padrão. E é por isso que
você não precisava fazer isso. Se você removê-lo, você
verá muitos bugs em seu jogo. Mas isso vem
verificado por padrão. E os atores não são
replicados por padrão. Então, se você criar
um aplicativo depois disso, todos devem ver que você realmente precisa se lembrar de replicar. Por exemplo, se você estiver
criando armas. Por exemplo, em um jogo 3D
ou em um jogo 2D, se você,
se seus inimigos
soltando armas ou o jogador estiver envolvendo
armas para o outro jogador, esse ator de arma tem que ser replicado senão o cliente não consigo ver essa arma derrubada. Então, após a replicação,
assim como quando a replicamos, todas essas variáveis
que fizemos nos outros blueprints, lembre-se de replicar
o ator também. Se você precisar de um todo,
os jogadores para vê-lo.
114. Como limpar o projeto: Agora que terminamos
o jogo, vamos realmente ir em frente
e limpar o projeto. Portanto, lembre-se de conferir minha seção de aulas
extras. Ainda continuarei
atualizando este curso. Por exemplo,
adicionarei placa de identificação para
soltar os itens que você
pode perder esses itens, por
exemplo, poções de saúde, barras de
saúde acima desses inimigos. Também adicionaremos estatísticas para que
possamos obter mais força ou mais saúde e atualizações e talvez buscar o sistema
solicitante. Então, muito mais coisas, talvez até mais de 200
vídeos
que podemos fazer se
não começarmos daqui. Mas isso deve
lhe dar uma boa base de como criar um jogo de plataforma
2D multijogador. Então, aprendemos a
criar tudo isso, como importar os ativos e aplicar papel a essas
configurações a eles. Criando flip
books em papel, sprites, atores e importando-os para o nível de
criação de mapas de mosaico. E incluímos
um sistema de cartas e um sistema de
ataque e muitas coisas que pudemos
ler neste curso. E na sessão de
aulas extras, vou adicionar mais coisas. Mais uma vez, como as barras de saúde, o sistema de estatísticas de RPG, talvez um sistema de missões. Então, muitas coisas
ainda podemos adicionar a este projeto. Mas agora antes de terminarmos, deixe-me ir em frente
e limpar o projeto porque eu não gosto de deixá-lo assim. Então, vamos para a base de jogadores, por exemplo, podemos começar com a
base de jogadores são, na verdade, vamos começar daqui. Então, para os ativos, não
precisamos limpar tudo. Tudo já está
limpo. E vamos para o áudio
que é bom também. Vamos para blueprints agora,
é aqui que a limpeza
é principalmente anúncios. Então, vamos começar com
esta câmera BP. E para este,
realmente não temos nada. Então, vamos fechá-lo. E a base de personagens, também não
temos muito aqui. Basta verificar aqui. Se, se tudo estiver
resolvido e você gostar de como fez as coisas ou
precisar adicionar, reescreva nós. Então, por exemplo, eu só
gosto de ser estruturas. Às vezes, estou apenas pegando esses nós de redirecionamento
e movendo-os. Lembre-se também de selecionar tudo e clicar
em C para adicionar comentários. E você pode chamar
isso de textos flutuantes, por exemplo, apenas, você pode fazer
isso muito melhor do que eu. Só estou fazendo isso
rapidamente para este curso, então não demora para sempre. Mas tente escrever um texto longo aqui
explicando o que você fez. Porque se você estiver
voltando para este projeto
seis meses depois, não será capaz de
lembrar o que é isso. Então, tentando escrever, talvez textos flutuantes para o ator danificado e blá, blá,
blá, seja o que for. Você pode ver, você
tem muito espaço aqui. Se você quiser, você pode alterar
novamente a cor dos comentários. Você pode alterar o
tamanho desse texto para torná-lo
maior se quiser compilar e salvar. E agora você pode ir para
o texto flutuante. Aqui. Acho que tudo
está bem. E vou deixar que
seja como este ano. Eles vão fazer a
região cortada realmente fazer muito aqui. E no controlador do jogador você pode realmente limpar
isso um
pouco porque não
tínhamos ou não comentamos nada. Então aqui, por exemplo,
podemos selecionar isso e dizer inicializando widgets. Eu geralmente também faço
aqui e digo começar a jogar porque então eu sei
onde está minha jogada inicial. Se eu tiver muito código, Xia Lai, inicializando widgets. Ok, então agora temos isso para baixo. Agora. Vamos pegar isso. Agora estamos selecionando
o personagem aqui, e eles estão juntos. Então, vamos pegar tudo
isso e
vou chamar uma seleção e desova do personagem em camadas. Assim mesmo. E
podemos ir até aqui, isso está atualizando a Barra de
Saúde e a experiência. E deixe-me selecionar
isso e dizer atualizando as barras de saúde e experientes. Se você quiser, na verdade, isso está parecendo bom,
mas se você quiser, então às vezes você
sempre pode arrastar isso e colocá-lo aqui ao lado. Então, temos isso mais
compacto juntos, mas acho que
isso não se encaixa. Selecionando uma desova,
eu só gostaria de
colocar coisas que se
encaixam aqui nas laterais. Então, vou
arrastá-lo aqui novamente. Agora, se você quiser novamente, você pode clicar nas
variáveis e dar a elas uma categoria se eu
puder encontrá-la aqui. Então este você pode chamar widget, por
exemplo, Widget, Blueprint
ou algo parecido. Então, apenas uma categoria e
fazendo a mesma coisa aqui, Widget Blueprint e
eles
estarão por conta própria aqui. Então tente fazer isso com
todos os seus projetos. Por exemplo, o maior
é provavelmente a base de jogadores. Vou limpar
isso sozinho. Então, eu realmente não
vou adicionar nada. Só vou arrastar as coisas. Por exemplo, clicando aqui,
clicando em Ocultar pinos não conectados
e, em seguida, dar uma olhada aqui e talvez eu esteja insatisfeito com isso, arrastarei isso para baixo. Então tente limpar seu
projeto da melhor forma possível. Tente comentar tudo e juntá-los
onde eles se encaixam. Porque agora você pode
ver que está um pouco bagunçada. Então você tem que
comentar tudo. E na próxima lição, vou
mostrar recursos
muito úteis que estou usando para meu próprio projeto
pessoal.
115. Recursos úteis: Nesta lição, vou mostrar alguns
dos recursos úteis que estou usando
para meus projetos pessoais. Acabei de criar isso por diversão. Criei este projeto aqui. Ou você pode saquear itens e ter um sistema de inventário. Então, muitas coisas
que você pode fazer, você tem um
sistema de nivelamento como nós fizemos. E você tem moedas e você
pode ir até a loja aqui. E dentro do afiado,
você pode realmente comprar coisas. Então, para este projeto, você pode ver esse código, novamente, estou usando
os mesmos métodos. Então, indo para o jogador, a base de jogadores, eu
realmente vou mostrar minha base de jogadores. Então esta é a base de jogadores
até agora para este jogo. E vou mostrar recursos que realmente
ajudarão você enquanto você estiver codificando. Então podemos ver que as
linhas são assim. Na verdade, gostei muito mais dessas
linhas do
que aqui em nosso projeto, onde
temos essas linhas curvilíneas. Na verdade, gosto de usar esse
plug-in onde as linhas se tornam robóticas ou onde quer que
seja chamado, assim. Você pode encontrá-lo
no mercado. Então, indo para o mercado
e dentro daqui, você pode procurar notas
eletrônicas. Acredito que se chama
notas eletrônicas. E vamos ver se
podemos encontrá-lo aqui. Talvez eu tenha procurado
por anotações eletrônicas. E este é, na verdade, o único. Então, clicando nessas notas
eletrônicas, esta é realmente a
que estou usando e você pode ver muitos alunos
usando um dois. Este é o único e você
pode ver que você pode escolher estilos
diferentes para
seus projetos. Então você tem estilos diferentes. Você pode realmente ter
notas mais escuras, se quiser. Mas este é o
que estou usando e
faz minhas linhas aqui eletrônicas. E acho que isso é
muito mais fácil de classificar. Então eu acho que isso
fará com que tudo pareça um
pouco melhor de se olhar, é mais fácil de olhar na verdade. E você pode ver aqui
que nem preciso criar nós de redirecionamento. Isso fará isso automaticamente
para mim em nosso projeto, mas as linhas curvas normais, terei que criar notas de
redirecionamento para isso. Mas eu realmente não
preciso criar notas de
redirecionamento para isso porque
você pode ver quando eu arrasto, ele
faz isso automaticamente para mim. Ativos muito legais que você
pode usar no mercado. Coisas muito legais
que eles têm feito. Então, estou usando isso. A segunda coisa é a
que estou usando é essa chamada, vamos ver, ou são comentários de tamanho
automático. Portanto, esses comentários
de tamanho automático também são muito legais de usar. Ele dimensiona automaticamente os comentários
para as notas que você tem. Então você pode ver aqui, eu
tenho esses nós aqui, e se eu arrastar algo, você pode ver todos os tamanhos. Meu comentário dependendo de
onde estou arrastando isso. E se eu fizer alguma coisa, por exemplo, posso
imprimir uma string aqui. Você pode ver que ele o
inclui automaticamente dentro
do comentário. Tão coisas muito legais. E isso também é como se você
pudesse personalizar os comentários. Então, se eu escrever algo aqui, vamos escrever algumas cadeias de impressões dentro
deste projeto. E quando clico em ver, agora eu o personalizei. Então, quando clico e
vejo, você pode ver que ele tem muito mais espaço na parte superior
e inferior e nas laterais. Na verdade, fiz isso manualmente. E o comentário está
escrito no meio. E também personalizo o tamanho automaticamente para 28, assim. Então você pode ver muito legal. E também para a cor comum, você pode
escolher automaticamente quais cores. Então, por exemplo, para
este projeto, estou usando azul se for do
lado do cliente, estou usando vermelho se ele estiver
sendo executado pelo servidor e pagando se estiver executando o servidor e
os clientes, para exemplo, um multicast. Assim, você pode ver
aqui, por exemplo, uma execução
pelo cliente também, sendo executada pelo servidor. Será vermelho e jogando
o cliente
novamente, estará aqui
através do azul. Então, todos os comentários dos lados, muito legais de usar para
o seu projeto também, apenas para torná-lo mais organizado. E sim, eu
realmente não uso muito mais. Eu costumo usar esses dois. Você também pode usar o
chamado arranjador de notas automáticas. Acho que foi um pouco
como se eu não tivesse gostado,
então, na verdade, não estou usando. Mas muitas pessoas eu acho que
estão usando isso também, na verdade não muito,
na verdade, algumas delas. Mas acho que foi organizado minhas anotações e nozes
como eu queria, na verdade não estou usando isso. E a última coisa, mesmo que este seja um curso 2D, a última coisa
que quero mostrar
aqui , céu ultra dinâmico. Então, se você está planejando
criar um jogo 3D, este é um salva-vidas e você pode ver que muitas
pessoas estão realmente usando ele e isso criará caras
dinâmicos
para o seu projeto. Novamente, você pode verificar
minha página, meus cursos, estou fazendo projetos 3D também, cursos
3D e os planos que
você tem usado aqui em 2D. Então, o bom de criar jogos
2D no Unreal
Engine é que agora você é muito melhor em
usar blueprints do que antes. Então agora, esses métodos que você tem aprendido
aqui em um jogo 2D, você pode realmente usá-los dentro de um jogo 3D também. Então, mesmo que todos esses projetos sejam feitos
agora dentro de um jogo 2D, não
é muito
diferente em um jogo 3D. Então, agora que você teve sua
prática neste curso 2D, você pode realmente usar
o que aprendeu
também em nossos cursos 3D. Então, essa é a coisa boa sobre o uso do Unreal Engine
e os blueprints. Todo o código
naturalmente será desperdiçado se você, de repente, quiser mudar
para jogos 3D, porque uma linha do tempo é uma linha do tempo e é usada para
a mesma coisa em 3D, bem
como eventos personalizados e obter a localização da
atriz. Temos que fazer isso
em 3D também. Então, tudo isso é realmente
o mesmo em um jogo 3D.
116. Atualizações de cursos futuros: Agora terminamos
com o curso. Espero que você tenha se divertido muito. Eu me diverti muito
criando este. Novamente, se você quiser estender
este curso você mesmo, se quiser adicionar mais inimigos, você pode acessar este site. Foi de onde eu o tirei. Maple ficou em casa e você pode simplesmente criar mais monstros aqui. Você pode criar mobs,
criar caminhos,
personagens e, na verdade, pode criar mais monstros. Então você pode ver
que adicionamos esses animais e
agora fizemos isso de forma tão dinâmica que você
pode realmente ir até o inimigo e clicar com o botão direito do mouse
e criar um novo inimigo. E ele será adicionado
automaticamente. Basta lembrar de clicar
no inimigo e também no intervalo animal aqui, todas as animações, a saúde e o nome e a
experiência e assim por diante. E também lembre-se, é claro, adicionar um arrasto e adicionar o
inimigo a esse nível. Então, mesmo que tenhamos
terminado este curso, farei
atualizações futuras para este curso. Vou adicionar
muito mais coisas,
muitas coisas de RPGs. Por exemplo, vamos adicionar
Health Bar diz que o sistema, talvez um sistema de habilidades também. Vamos adicionar um sistema de missões. Então, muitos outros sistemas que ainda podemos
adicionar a este jogo. Então, continuarei
atualizando este curso. E se você quiser lembrar, você pode ir à minha página aqui e dar uma olhada nos
meus outros cursos. Estou tentando liberar um todos os meses ou a cada um
mês e meio. Dê uma olhada nos meus outros cursos. E lembre-se, você
sempre pode ir ao meu Discord e escrever para mim se
você quiser
um curso que você quer ver, ou se precisar de ajuda com este curso ou qualquer
outro curso, você pode ir para o meu
discurso e podemos conversar ou você pode escrever com todas as outras pessoas que estão realmente
fazendo este curso. Você pode escrever com eles
nos servidores Discord. Então, uma comunidade muito boa que
temos lá dentro. Lembre-se também de que eu
tenho um canal do YouTube, então você também pode ir ao meu canal
do YouTube se quiser
assistir a três vídeos
sobre esse assunto. Então, também sou muito ativo. Eles estão adicionando
vídeos com frequência, então vá ao meu YouTube
também e veja se há algo que
atrairá seus interesses. Então, com isso dito,
obrigado por tudo. Obrigado por
me apoiar e espero que você
tenha se divertido muito e eu te
vejo no próximo curso.