Transcrições
1. Introdução aos sistemas de portas e portais interativos: Bem-vindo aos sistemas de portas
e portais interativos Unreal Engine Five Blueprint Mastery ,
o único
workshop abrangente dedicado inteiramente
à criação de mecânica avançada de
portas e portais o único
workshop abrangente dedicado inteiramente
à criação de mecânica avançada de
portas interativos. Realmente não há
nada parecido com isso lá fora. Um workshop completo em uma porta onde você aprende
a projetar, construir e animar uma ampla variedade de sistemas de portas em um local
estruturado e conveniente Muitas vezes, os desenvolvedores
de jogos se deparam com uma barreira ao tentar criar sistemas interativos
que vão além do básico. Sincronizar animações
para bonecos duplos, criar quebra-cabeças complexos ou implementar mecânicas de
teletransporte criar quebra-cabeças complexos ou
implementar mecânicas de
teletransporte pode parecer opressor. Este workshop resolve tudo isso
combinando tudo o que você precisa em um único curso Imagine aprender passo a
passo com todas as ferramentas, recursos e orientações de
que você precisará para ter sucesso. De gatilhos baseados em colisão a sistemas de
teletransporte de
vários níveis,
você desbloqueará todo o potencial
da programação de cinco loops
do Unreal sistemas de
teletransporte de
vários níveis,
você desbloqueará todo o potencial
da programação de cinco loops
do Unreal Engine. Neste workshop, você terá
acesso a 41 aulas e mais de 8 horas de conteúdo
exclusivo que você
não encontrará em nenhum outro lugar. Você começará com o essencial como interfaces de loop e configuração do modo de
jogo,
antes de avançar para técnicas avançadas, incluindo animação
sincronizada, mecânica de
bloqueio Começaremos com
o essencial como interfaces de projeto e configuração do Gamo, antes de avançar
para técnicas avançadas,
incluindo
animações sincronizadas, mecânica de bloqueio e sistemas complexos de quebra-cabeças ,
como interfaces de projeto
e configuração do Gamo, antes de avançar
para técnicas avançadas,
incluindo
animações sincronizadas, mecânica de bloqueio e sistemas complexos de quebra-cabeças. No final, você até domina a mecânica de
teletransporte e efeitos visuais
dinâmicos, garantindo que
seus sistemas
de portas Mas o que faz com que este
workshop realmente se destaque é a chave de nível
modular Sci Fi exclusiva para criar projetos de
qualidade profissional Ao final deste workshop,
você
dominará a comunicação de você
dominará a comunicação para interatividade avançada,
criará sistemas de
portas imersivos, de animações
simples a transições complexas de vários níveis,
implementará estados seguros para
garantir que sua mecânica
persista em todos os níveis
e adicionará toques
finais de
nível implementará estados seguros profissional, como efeitos sonoros e modelos
para interatividade avançada,
criará sistemas de
portas imersivos, de animações
simples a transições complexas de
vários níveis,
implementará estados seguros para
garantir que sua mecânica
persista em todos os níveis
e adicionará toques
finais de
nível profissional, como efeitos sonoros e sistemas dinâmicos de partículas. Se você cria
seu primeiro projeto ou expande seu portfólio, esta é sua chance de
adquirir habilidades que você não encontrará em nenhum
outro curso. Participe do único workshop completo de
sistemas de portas disponível e vamos dar
vida às suas ideias com o Real Engine Five, sistemas de portas
Blueprint Mastery e o curso de portal interativo
2. Introdução ao Unreal Editor e adição do modelo de terceira pessoa: Olá, bem-vindo aos verdadeiros portais
Engine five Blueprint Mastery, Door Systems e
Interactive Vamos começar extraindo nosso Doors
Resource Pack baixado Vou clicar com o
botão direito do mouse e vou usar o WinRAR e extrair o pacote de recursos de
duas portas Agora, se você tem o WinZip, o processo é mais ou menos o mesmo Você escolhe um destino
e ele o extrai. Agora, para mim, ele o
extraiu aqui para a área de trabalho em que eu
baixei o arquivo E antes de continuarmos,
vamos verificar na Unreal Engine
Library na guia Unreal Engine que temos 5.4 0.4, que é a versão do projeto Se você estiver na
versão acima, são cinco. Agora, vamos ao nosso projeto. Vou clicar duas vezes
e abrir o projeto. Isso pode demorar um pouco,
dependendo da velocidade do seu computador, mas incluímos o cache de dados derivado e
a pasta intermediária, que hospedam arquivos que
facilitam esse processo. Arquivos como shaders que
foram carregados antes quando
estávamos criando o projeto Agora, para aqueles que são novos, vamos explicar o que
estamos vendo aqui. Em primeiro lugar, essa
imagem é nossa janela de visualização. Podemos nos mover usando o botão esquerdo do mouse e
movendo o mouse para cima, para baixo, para a esquerda direita e usando o WSAD para nos movermos no espaço mundial
como um videogame Q e E também elevam
e deselevam. Não tenho certeza de que palavra é
essa, mas de qualquer forma, nosso personagem, nosso não
personagem, nossa câmera. Agora, isso, como você pode ver,
é um pouco lento. Então, se eu usar a roda do mouse
enquanto pressiono o botão direito do mouse, posso ir mais rápido com a roda do mouse para cima e posso ir mais devagar
com a roda do mouse para baixo Isso pode ser indicado
aqui pela velocidade da câmera. Também posso alterá-lo
alterando o valor aqui, mas a roda do mouse parece
ser um pouco mais fácil. Agora. Não entraremos em mais
detalhes sobre muitos botões. Vou explicar algumas, mas vou explicar quando
abrirmos nosso mapa. Então, para fazer isso,
vamos até aqui, que é o navegador de conteúdo. E aqui podemos ver nossos
ativos, mapas e sons. Eles estão incluídos em
nosso pacote de recursos Doors. Agora, para ativos,
podemos ver alguns ativos, mas os demonstraremos
posteriormente no mapa correto. Em sons, podemos ver alguns sons que precisamos
usar neste tutorial. E nos mapas da pasta, podemos ver os mapas pré-fabricados. Se os abordarmos rapidamente
, vamos abrir o mapa do Tutorial 2. É uma pequena sala que
usaremos mais tarde como sala de transferência e iremos para o mapa do
tutorial sem número. E aqui podemos
ver nossos ativos e nosso nível que
usaremos para construir nossas portas. Agora, em primeiro lugar, vamos começar continuando a explicação do que
estamos vendo nessa tela. Como podemos ver, é muita informação, mas
não se assuste. São coisas muito simples. Aqui, temos o esboço,
que, como você pode ver, é praticamente
feito no nível um, no nível dois, no
nível três
e em alguns itens extras Essas são as pastas que
categorizamos os itens que estamos incluindo
neste pacote de recursos e,
nas próximas pastas, estamos categorizando-as com
base nos níveis em que
criaremos as portas Você também pode ver uma pasta de
iluminação, que tem os adereços de iluminação, e podemos ver algumas pastas novas
aqui que, na verdade não
têm nada e o playground de
pastas que foi deixado para trás Então, vamos começar
explicando essas pastas vazias. Agora, quando eu tenho uma pasta que tem alguma coisa, em
primeiro lugar, ela tem uma seta e podemos
ver dentro de seu conteúdo, onde essas pastas não
têm nada. Essas pastas também têm um olho próximo a elas,
que está fechado. Se eu tentar clicar
neles, nada acontece. Então, essas pastas
estão meio vazias. Podemos excluí-los, não
precisamos deles. Então, a próxima coisa que precisamos fazer é
ver nossa pasta de itens extras. Vou clicar nele
e vou
clicar no olho. Agora, você pode ver os itens
desaparecerem da nossa vista. Isso não significa que eles
não estejam carregados no jogo. Se eu pressionar play, poderemos ver
claramente os itens. Eu pressiono play, e isso
é em tempo de execução, o jogo e os itens estão lá. Então, fechar os olhos aqui não significa que os estamos
perdendo no jogo. Significa apenas que podemos
trabalhar sem olhar para eles. No momento, fecharemos
os olhos
de todos os níveis, exceto do nível um, porque vamos
usá-los à medida que progredimos editoriais. Agora, para os itens extras, vamos abrir o olho e
ver o que temos aqui. A velocidade é um pouco alta. Ok. Corrija-o com a
roda do mouse e podemos ver agora. Temos uma porta dupla e, em diferentes medidas
que podemos usar, desfazer as alterações Temos uma moldura, a
mesma coisa para a porta. Acho que essa é a porta
que se move dessa maneira, e temos uma luz acima dela, alguns triângulos que
vamos usar para itens, uma porta de salão que vamos usar para
nossa loja de física, um interruptor que
vamos animar Um botão que
vamos animar, um botão de gatilho, que também é
feito de duas malhas, assim como o botão, um
portal, algumas caixas
e alguns outros tipos de portas,
um copo, isso é uma Agora, é uma escada.
Acho que é uma escada, algumas paredes, alguns andares, e esta é uma pequena
demonstração de todos os ativos Sim, são peças separadas. Mas, novamente, temos
isso em nosso nível. Agora, para continuar explicando o que vemos
aqui, como vimos, o botão play é
usado para jogar o jogo, para iniciar o que
criamos, e o escape é usado para parar. Agora, a próxima coisa que eu quero falar
que vamos
usar é que quando eu seleciono
qualquer coisa aqui, temos um esboço detalhado Então, quando eu trago algo para o mundo e quero
ver seus próprios detalhes, por exemplo, porque eu
posso ter dois andares. Se eu vou usar Alt e vou
arrastar esse R até aqui. Então, isso duplica o chão. Se eu usar esse piso
e esse andar, são a mesma malha, mas são exemplos. Eles têm detalhes diferentes. Por exemplo, a localização
desses dois blocos muda. Isso é Y 600 e esse é Y 980. E se eu mudar isso, escala, ela muda para
essa única instância. Então, esses são os detalhes
da instância que estou selecionando. Existem vários detalhes com
base no que selecionamos. Então, tudo para obter detalhes
da instância selecionada
está aqui. Agora, outra coisa
que acontece no outliner é que, quando estou
escolhendo algo aqui, ele realmente
seleciona E se estiver longe
ou se eu não souber realmente onde está o
que selecionei aqui, posso pressionar F. E ele
ampliará o máximo
possível em nossa malha agora, porque eu
selecionei essa malha Se eu selecionar outro ator, ele ampliará esse ator. Agora, tenha cuidado porque se
eu selecionar a esfera do céu, por exemplo, e pressionar F, ela me levará para fora
da esfera do céu
para senti-la, para ter tudo na tela. Agora, vamos voltar para algum item. Vamos entrar no passado. E acho que explicamos algumas coisas sobre
o que estamos vendo. Somos mais versáteis no uso
do irreal. E antes de deixarmos mais
uma coisa, vou até o
Content Browser e
vou até o botão
at aqui. Porque eu quero adicionar um
recurso ou pacote de conteúdo. Essa é uma forma de adicionar os
recursos e pacotes de conteúdo que Area oferece gratuitamente quando
estamos criando um projeto E o conteúdo,
o recurso que eu
quero adicionar agora é o modelo de
terceira pessoa. Portanto, temos um personagem
que podemos mover e algumas outras coisas que
explicaremos na próxima lição. Então, por enquanto, vou
pressionar Adicionar projeto. Isso pode demorar um pouco. Quando estiver pronto, ele
abrirá uma janela. Aqui está, abra uma janela do navegador de conteúdo
que não precisamos, podemos fechar e fechar
isso e agora podemos ver novas pastas aqui, a pasta de personagens, a prototipagem de níveis e a pasta de terceira pessoa Mas vamos explorar
isso na próxima vez. Adeus por enquanto. Te vejo então.
3. Noções básicas de interface do Blueprint Modo de jogo, spawning de personagens e configuração de blueprint de nível: Bem-vindo de volta ao
Unreal Engine five, Blueprint Mastery, Door Systems
e portais interativos Então, da última vez, paramos de baixar nosso personagem
em terceira
pessoa adicionando ao nosso projeto, o modelo em terceira pessoa. Agora, vamos explorar o que
temos no modelo de terceira
pessoa. Temos uma pasta de plantas. Temos uma pasta de entrada
e uma pasta de mapas. Os mapas têm o mapa modelo de terceira
pessoa, que se eu o abrir
e pressionar play, posso ver o personagem em terceira
pessoa. Eu posso mover algumas caixas. Eu posso pular e é mais
ou menos isso. Agora, quando vamos ao nosso
mapa e pressionamos Play, não
há nada disso. Não podemos ver nenhum personagem
pulando por aí. Temos apenas uma câmera em movimento. Bem, por que isso? O motivo é dentro do suporte de terceira pessoa, podemos ver as plantas
dobradas, que têm o personagem em terceira
pessoa que estávamos usando
e controlando,
e tem o modo de jogo em terceira
pessoa BP O que é um modo de jogo? Um
modo de jogo é um plano especial que tem regras
especificadas por nível exemplo, neste nível, teremos um modo de jogo. No modelo de
mapa em terceira pessoa, temos outro modo de jogo. Bem, teremos o
mesmo, mas, no momento, não
temos nenhum modo de jogo aqui, então é um modo de jogo padrão. Não é um modo de jogo
modelo em terceira pessoa. Então, como mudamos o modo de
jogo em nosso mapa? Ao lado dos detalhes aqui, podemos ver as configurações do mundo. Agora, se você não consegue
ver as configurações mundiais, podemos ir para a Janela e habilitá-la aqui, configurações
mundiais, e ela aparecerá
assim em algum lugar do layout, ou aparecerá
encaixada aqui, o
que, como você pode ver, você pode
encaixá-la em qualquer lugar que quiser Você pode até mesmo encaixá-lo aqui. Mas esse é o lugar
mais útil. De qualquer forma, como
mudamos as
configurações do mundo, o modo de jogo? Como podemos
substituí-lo? Bem, há essa opção de modo de jogo
aqui em que
podemos definir, substituir o modo de jogo e selecionar nosso modo de jogo em terceira
pessoa BP, e pronto,
basicamente Se eu pressionar play agora, o
personagem aparecerá. Eu aparecerei
caindo e morrendo. Agora, por que não
apareceu onde eu quisesse? Bem, eu posso controlar isso
antes de tudo, com minha câmera. Eu posso apertar play aqui, e
o personagem aparece aqui. Mas por que no outro mapa estava aparecendo sempre em
um determinado lugar, mesmo que não tivéssemos
a câmera lá? Bem, o motivo é porque modo de
jogo tem
algumas funcionalidades
extras, algumas funcionalidades
que vamos
substituir posteriormente no tutorial Mas essa funcionalidade
consiste em gerar o personagem. E qual personagem, isso
depende de outra funcionalidade
chamada classe de peão padrão E aqui podemos ver que
a classe de peão padrão é o personagem de terceira
pessoa do BP Se eu não dissesse isso para ninguém, aperte play, quase nada.
Eu nem consigo me mover. Vou mudar isso de volta
para personagem em terceira pessoa, e precisamos fazer com que o
jogador comece. Como fazemos isso? Um novo
botão aqui aparece. Bem, não parece, mas vamos
explicar isso agora. Então, vou clicar nele, e esse é o
botão para
adicionar rapidamente algo ao seu nível,
algo à janela de
visualização, basicamente,
porque mais tarde, a
janela de visualização atinge vários níveis Como você pode ver no meu Unreal, há uma guia de nível aqui
, chamada de subníveis, mas não vamos entrar nela Agora, vamos aqui e
vamos adicionar uma partida de jogador. Este é o nosso começo de jogo.
É assim que parece. Tem um controlador e uma
bandeira e essa forma de cápsula, que é uma colisão, na verdade, uma colisão de forma de captura Vou fazer com que esse
par comece em algum lugar aqui. Eu vou apertar a ponta, então ela vai para o chão. E eu vou apertar play. Agora, veja, temos
nosso personagem aqui, e nossa câmera não
importa onde esteja. Pode ser como aqui, pressionando play, o
personagem está aqui. Agora, veremos como isso é controlado mais tarde nos
próximos tutoriais, veremos como isso é controlado mais tarde nos porque
substituiremos sua própria funcionalidade
na funcionalidade de como o modo de jogo
escolhe o início
de Agora, criamos
um início de jogador. Adicionamos nosso modo de jogo
e o personagem patrocinador que jogaremos
e testaremos nosso código Mas antes de
mergulharmos na primeira porta, vamos fechar novamente
todos os níveis. Parece que não salva. Essa parece ser uma configuração
temporária. Há outras maneiras de ocultar a visibilidade por meio de
código e ativos, mas não faremos isso agora. Então, antes de mergulharmos nos
projetos e começarmos a codificar, vamos explicar um
pouco o que são Bem, blueprints é o verdadeiro sistema de
script visual do motor E o que é um sistema de script,
um sistema de script visual Considere ter
blocos de código com comportamento
pronto e apenas conectar essa
lógica na ordem você deseja usar. O código
foi reescrito tantas vezes e nem sempre é eficiente reinventar
a roda, reescrever o código que
foi escrito O URL oferece um sistema de diagrama, que consiste em blocos de código prontos em uma representação visual
que fazem certas coisas, e os organizamos em uma ordem
especial para que faça sentido que a máquina
saiba o que pedimos que ela faça Dizer isso significa que também temos muitos
tipos diferentes de plantas Por exemplo, há um plano de
nível que
usaremos para controlar nossa primeira porta Mas, além disso, existem widgets
que controlam a interface do usuário Existem projetos de atores que fazem
coisas específicas em nosso jogo Por exemplo, nosso switch
será um ator. Existem
projetos de personagens que são nosso personagem que estamos
usando e controlando Existem
esquemas de animação que
controlam a animação do
personagem Existe o
modo de jogo Blueprint, que é o
plano especial sobre o nível Por exemplo, quais são
as regras do nível? Ele pode hospedar alguma lógica
multijogador. Tem uma pergunta específica. É por isso que é o
modo de jogo Blueprint, o projeto do controlador do jogador Sei que isso pode parecer
assustador para alguém novo, mas é apenas um sistema para
categorizar a funcionalidade. Temos o sistema
para os widgets, temos o sistema
para os personagens Temos o sistema
para as animações, sistema para
o
multiplayer e a jogabilidade Tudo é categorizado
em sistemas específicos, um
sistema muito bem otimizado que o real oferece Agora, vamos começar abrindo
nosso primeiro blueprint, que seria o blueprint de
nível,
um blueprint dedicado Vou até esse
botão, um novo botão. Mas quando eu pressiono, podemos
ver algumas opções para criar uma nova classe Blueprint para
converter seleções
em classe blueprint Mas o que queremos é
abrir um plano de nível. Essa não é uma imagem típica
que vemos em uma planta, layout
típico, mas é
o suficiente para explicar algumas coisas Aqui, temos
o gráfico de eventos, que hospeda a funcionalidade
do nosso plano Este é o lugar onde
escrevemos grande parte do nosso código. Ao lado, podemos ver
o painel de detalhes, que agora está
selecionando a classe padrão. Aqui, podemos ver a
depuração do nosso blueprint, que usaremos quando
estivermos depurando o código E no lado esquerdo, podemos ver minha guia Blueprint Em outros blueprints,
veríamos uma guia de componentes e algumas outras guias aqui,
um script de construção, que é usado para
postar código e lógica quando estamos executando o blueprint no
editor antes do mapa Vamos demonstrar
um pouco dessa lógica. E a porta de visualização, que na verdade,
vamos vê-los. Falar sobre eles
sem
vê-los não é um bom ponto. No
arquivo de conteúdo, vou clicar com o botão
direito do mouse e
criar uma nova pasta. E vou nomear
essa pasta como blueprints. Além disso, vou codificar por
cores essa pasta. Vou
clicar com o botão direito do mouse nessa cor e defini-la como azul. E dentro desse Blueprints, vou clicar com o botão direito do mouse
e ir para a aula Blueprint E aqui podemos ver os diferentes tipos de projetos sobre os quais
falamos anteriormente O ator, o peão,
o personagem, o controlador
do jogador,
o modo de jogo baseado,
o componente do ator, os componentes de
sincronização Diferente, há
muitas classes de plantas que podemos criar O que vamos selecionar
agora é apenas um ator. Vou nomear esse teste PP. E vamos abri-lo. Agora, como você pode ver, essa é a diferença com
o mapa tutorial. Aqui, temos
apenas o gráfico de invenção e minha planta e detalhes Já aqui, temos
a guia de componentes, a janela de visualização, o script de
construção e o gráfico de invento. De qualquer forma, isso tem acenos para demonstrar
algumas funcionalidades. E aqui temos
a guia de componentes. Isso é o que eu queria
explicar: na janela de exibição, podemos adicionar coisas
ao nosso projeto Por exemplo, podemos adicionar um cubo e vamos programar esse tubo neste projeto
para fazer algum comportamento Já aqui no mapa de níveis, por se tratar do nível, não
temos
esse hub de janela de visualização E o motivo é
que a janela de visualização do mapa
do tutorial
é basicamente essa janela de visualização Tudo nesse nível
é basicamente um componente. Não é, mas pode ser
um componente disso. Dizendo isso, vamos trazer
uma cópia de uma porta. Eu acho que isso é, esta é
a porta com uma maçaneta. Vou trazer essa porta. Vou pressionar Alt
e trazê-lo aqui. E eu vou girá-lo. Assim. Não, eu quero isso
do outro lado. Assim. 90 graus. Vá para os detalhes -90. Está tudo bem. Agora, isso, como você pode ver, não
está funcionando muito bem Mas o que eu vou
fazer é aqui, temos o
ponto de ruptura às dez Vou escolher cinco,
vá para baixá-lo. E acho que quebrou bem. Sim, bem. Agora, vou para o mapa do tutorial
e vou
clicar com o botão direito do mouse
e criar uma referência para o pacote Prop Pack EU six ou six Você quer dizer? Agora, isso é
porque eu escolhi. Quando eu tenho algo selecionado, digamos que, para
este exemplo de parede, eu possa clicar com o botão direito do mouse e
trazer uma referência para ele na planta do nível Na verdade, não precisamos da parede. Vou deletar isso.
Só precisamos do pacote de adereços Essa é a porta, vamos
chamá-la de porta de agora em diante, e essa é a porta um. Eu renomeei a parede. por isso que está no nível um. Não
deveria estar no nível um. Isso eu escolho isso. Isso deveria
estar em itens extras. Vou movê-lo
daqui para o Nível um e arrastá-lo e soltá-lo aqui. fosse mais
fácil fechar o arquivo Talvez fosse mais
fácil fechar o arquivo e renomeá-lo
aqui para uma porta tão boa Essa é a parede errada. E nós temos a porta aqui. Então, agora nós o renomeamos. Ao compilar aqui, você pode ver que o nome mudou aqui também Então, o que queremos fazer com
essa porta? Nós o temos aqui. O que faremos é
programá-lo para abrir e fechar com base na
proximidade do player. Não, quão perto. Na verdade,
o jogador chegará perto dela, a porta se abrirá. O jogador irá
para outro local e a porta se fechará. De qualquer forma, acho que disse
muitas coisas para esta aula. Nos vemos na próxima. Mas meu
4. Fundamentos da programação de Blueprint para iniciantes: De onde paramos foi com a
adição desta porta aqui. Nós o copiamos da porta, pressionamos e arrastamos, e o trouxemos aqui Também criamos uma referência
a ele, nosso plano de nível. H. Vamos começar a fazer
algo com essa porta. E ao fazer alguma coisa, quero dizer, basicamente
rotacione-a para que ela se abra Como fiz isso foi
selecionando a porta, pressionando E e, como podemos ver, ela mudou para o rotador Ao pressionar R, ele
muda para a escala Imo, e W traz o movimento. Também podemos ver essas
seleções aqui. O que precisamos fazer para mover essa
porta é basicamente girá-la, e esse é um ator estático, sendo
ator a palavra-chave Por que isso? Porque, como dissemos, nas plantas existem alguns comportamentos
prescritos Eu puxo um cabo da
nossa referência da porta e pergunto pelo ator. O que queremos mudar é
a rotação, então a rotação. Você pode ver que temos algumas
opções sobre rotação. Obtenha a rotação do ator, podemos definir a rotação do ator. Podemos definir a
localização e a rotação relativas. Falaremos sobre o
relativo e a diferença
entre o relativo e o
mundo em uma lição posterior. Mas agora,
vamos
usar apenas a rotação do ator definido, que é uma rotação mundial. Vou escolher esse
nó de rotação de atores definidos. Agora, esse nó tem uma
execução e, para saída, nosso valor de retorno, que é
vermelho, vermelho é pólen, falaremos
sobre isso mais tarde Uma rotação, entradas e
uma física de teletransporte. Lean pode ver que as coisas
são codificadas por cores, e isso nos leva
a um novo assunto O que são variáveis? As variáveis são como pequenas células de informação
em branco. Que tipo de informação
é o tipo de variável. Deixamos o M
Blueprint explicado. Então, o que meu Blueprint hospeda? O My Blueprint contém
informações sobre nosso código. Como você pode ver, ele mostra elementos que pertencem
ao plano,
variáveis, gráficos que estão aqui, temos os gráficos de categorias Se formos, vá para os gráficos. Veja,
já existem alguns eventos, esse evento cinza para nós. Se eu clicar duas vezes sobre isso, posso ser levado a todos os eventos. Portanto, existe um evento em nosso gráfico, podemos navegar diretamente
até ele a partir daqui. Também podemos criar novos gráficos
para coisas, por exemplo, este será o gráfico de
pontas, o gráfico de movimento ou qualquer
outro gráfico que quisermos Então, poderíamos ter
gráficos diferentes com eventos diferentes, mas eu não posso ter o
mesmo evento de gráficos Clique com o botão direito do mouse e abra
o evento de início do jogo. Eu posso trazê-lo aqui e
posso tê-lo aqui também. Mas não funcionará. Eu arrasto daqui e
digito print string, que é um nó que
imprime apenas uma string e a
conecta aqui e também a
conecta ao outro gráfico. Eu tento compilar,
você verá que recebo um erro vinculado a mais de uma
função com o mesmo nome Não podemos ter o mesmo
evento nos dois gráficos. Eles precisam ter
um nome diferente. Na verdade, você não precisa
do teste do plano, mas é bom mostrar uma coisa A próxima coisa que precisamos fazer é a categoria
da função.
O que são funções? Bem, no Norte, existem reutilizáveis que codificam blocos
lógicos que podem ter
saídas de retorno. As entradas podem ser chamadas várias A planta de
outras plantas. Eles são ideais para realizar tarefas reutilizáveis
específicas. Eles têm algumas
regras específicas, embora a função deva completar a lógica
antes de retornar. Eles têm
que completar o que está acontecendo aqui ou eles têm uma saída. E se eu clicar aqui para ver as saídas, quero obter esse valor Tudo o que está acontecendo aqui
dentro tem terminar ou continuar funcionando. Por exemplo, se eu trouxer
essa função
aqui e conectá-la aqui, isso terá que terminar suas operações para que
o código continue. O próximo. A
próxima categoria são macros, das quais não
precisaremos usar inicialmente, então não vamos nos preocupar
com elas funções que,
como eu disse, são como funções, mas
, mais versáteis,
podemos ter várias entradas de podemos ter E isso nos leva
ao ponto de execução. Como você viu antes, eu
conectei esse cabo aqui. Quando falei sobre a rotação do ator
definido, eu disse que há uma entrada de execução aqui
e uma saída de execução. Essas execuções precisam estar
conectadas para a execução do nosso código. Isso não funcionaria
porque está vazio. E, como você pode ver, eventos como
start play têm apenas
uma saída de execução pode ser considerada
como fazer alguma coisa. Faça alguma coisa, comece a tocar, faça alguma coisa sobre o carrapato
que vimos aqui, faça alguma coisa com o
ator, comece a se sobrepor Também temos
eventos personalizados que podemos criar por conta própria e
chamá-los em nosso código. Agora precisamos mover nossa porta
com nossa rotação do ator definido. Então, nossa rotação da porta, vamos ver os detalhes em -90 Arredonde isso de
89,999 para -90. Digamos que, quando
começarmos a jogar, excluamos a função. Digamos que queremos que
a porta fique zero. Então, agora, se eu apertar play, a porta não é zero. E quando pressiono Parar, posso ver o motivo Y
no registro de mensagens de erro, que é a mobilidade da
porta não definida como móvel Então eu vou
clicar na porta. Aqui, vou para a mobilidade
e o uso de dispositivos móveis Então, agora, se eu pressionar Play,
a porta está aberta. Eu acho que é isso para este. Vou continuar na próxima até
5. Usando linhas do tempo para animações suaves no Unreal Engine: Olá, bem-vindo de volta
ao verdadeiro Engine five, Blueprint Mastery Door Systems
e aos portais interativos Anteriormente,
paramos com o OD OpenRdor. Usamos nossa referência de porta
ou evento de início de jogo, usamos a lógica predefinida de rotação
de atores definidos E definimos a
rotação do ator para 000. E quando pressionamos play, podemos ver que a
porta agora está aberta. Eu queria
abri-lo de outra forma, eu poderia colocar dois -180 e
ele abriria de outra forma E se eu quisesse
alterá-lo toda vez, mas também quisesse que isso
acontecesse? Por exemplo, eu tinha quatro referências em D e quero que todas
tenham a mesma rotação. O que eu precisaria
aqui é de uma variável. Então, para isso, eu posso
ouvir o botão de adição, ou posso clicar com o botão direito aqui diretamente e promovê-lo
para uma variável, que é chamada de nova rotação Eu poderia renomeá-lo
usando a variável aqui e alterando a
rotação da porta Agora, como você pode ver, ele apareceu aqui na
minha guia de projeto nas variáveis da seção Vamos mostrar a criação
de outra forma. Vou deletar isso, e vou deletar
essa variável também, e vou adicionar uma variável
e puxá-la para rotação. Se arrastar e soltar
aqui me pedir para obter ou definir significa que
estamos obtendo o valor
que essa variável tem. Isso significa que
obteremos um novo valor para a variável. Se eu selecionar definir, por exemplo, podemos ver alguns
pinos de entrada e um pino de saída Também podemos ver que é colorido porque essa variável
é do tipo booleano Eu clico e vejo vários
tipos de variáveis. Os mais comuns são
os booleanos, que são sim ou não, que basicamente
codificam termos, podem
ser zeros Então, um booleano, isso é o que é. Um zero e um, verdadeiro ou falso. Em seguida, teremos números inteiros
que seriam os números inteiros. Por exemplo, um, dois,
três, quatro, cinco, seis ou menos um, dois,
três, quatro, cinco,
seis, quantidade ilimitada Bem, não é ilimitado.
Eles têm um limite. Acho que o limite
é algo entre
o quintilião e os fluxos, que seriam os números
com pontos decimais,
basicamente, esses são
os Em seguida, temos nome, sequência de caracteres
e texto. strings são todos os caracteres, e o nome e o texto
têm regras específicas Agora, vetores, vetores
aqui são três pontos
flutuantes Se eu trouxer um vetor, se
eu criar um vetor aqui, vamos mudar o tipo de variável. Podemos ver que tem XY
z. É três pontos. Eu posso dividir aqui, clicar com o botão
direito no nó
do pino aqui e dividir, posso ver três carros alegóricos, basicamente Isso é o que é um vetor. Pode se tornar uma cor. Isso
pode se tornar um movimento. Pode se tornar qualquer coisa que
três pontos representem. Pode se tornar um local. E o que temos aqui
é um vetor específico
, chamado rotador Se eu for aqui e
selecionar um rotador, que está abaixo do vetor, e alterar o tipo de variável Eu não quero configurá-lo. Eu quero obtê-lo. Agora, um atalho rápido
seria se eu arrastasse e soltasse aqui com o controle
pressionado, estou recebendo um getter Se eu arrastar e soltar aqui
com uma tecla alt pressionada
, vou pegar um setter Agora, se eu conectar isso aqui, eu compilo, preciso
compilar sempre e salvar, e vou até a variável e
altero isso para, digamos, Agora empilhe novamente e pressione play, e podemos ver que a
porta está meio Claro, se eu chegar perto
, nada acontece. E agora temos uma variável para alterar a
rotação da porta. Então, se tivéssemos muitas
portas, por exemplo, poderíamos usar essa variável aqui para alterar
a rotação. Se quisermos ver
isso acontecendo, o que podemos fazer é
colocar um atraso aqui. Que é um nó que cria
um estilo de tempo em nosso código. exemplo, ele espera o valor
que definimos em duração para concluir e
seguir em frente com o código Então, digamos que esperaremos 2
segundos antes que
isso aconteça. Vamos voltar ao mapa. Vamos jogar. Vamos dar uma olhada na porta.
E em 2 segundos, a porta se moveu e se abriu. Portanto, esse é um nó de atraso
que tem a ver com o tempo. Então, como nosso código é executado em
blocos, como podemos ver na lógica, uma coisa lógica a se pensar seria colocar um
pequeno atraso aqui, alterar a rotação
um pouco, colocar um pequeno atraso,
alterar a rotação, mas colocar alguns pequenos atrasos
que os olhos não conseguissem
perceber, por exemplo Bem, há um comportamento
programado. Já existe um comportamento escrito para isso para nós. Como em muitas
linguagens de programação e em projetos, bem, grandes programadores
criaram ferramentas, então esses comportamentos
são fáceis para nós O que faríamos para
conseguir esse efeito de que cada determinado
período de tempo, passasse um pouco,
seria chamado de linha do tempo Vamos pesquisar uma linha do
tempo
e pressionar Adicionar linha do tempo Como você pode ver, esse é um nó mais
complicado em
comparação com o simples atraso ou mesmo com a rotação do ator
definido. Tem muitas entradas. Jogue, jogue do início, pare, reverta, reverta
do fim, defina
nova hora, nova hora, a quantidade
que estamos definindo, atualize e finalize
e uma direção. A direção tem uma nova cor, e essa cor não
vimos aqui. Parece que a mordida pode ser traduzida
em mordida, para ser honesto. É por isso que eles
têm cores semelhantes. Mas isso é, como podemos
ver quando abordamos, uma direção AM do horário E. O E no início
começa para EAM, que é a abreviação de enumeração Basicamente, é uma lista
predefinida que
criamos e que não pode ser
alterada em tempo de execução É uma lista do que quisermos. Certo, o específico
é chamado de direção, e se vamos fazer um nó igual. Igual ao Enum, podemos ver aqui as opções que ele tem
para frente e para trás Há muitas
maneiras de usar números. O mais comum é com
uma chave que você pode ver
que na direção E da
linha do tempo, o mesmo nome da enumeração
aqui porque elas são enumeradas aqui porque elas são Eles precisam ter a mesma
enumeração conectada a eles, que tem um avanço
e um retrocesso Isso pode ser conectado,
por exemplo, à atualização, o
que significa que, enquanto a linha do tempo estiver
em execução, faça alguma coisa ou possa ser conectada
para terminar quando linha
do tempo terminar de fazer o que
está fazendo, eles
terminaram de avançar
ou terminaram de
retroceder Vamos usar
isso em breve. Ou agora, vamos simplesmente deletar isso porque
não vamos precisar dele. O que precisaremos é ao
atualizar a linha do tempo,
conectar a rotação do conjunto de atores Vamos deletar. Na verdade, não
vamos deletar. Vamos apenas conectar do
final para jogar. Quando o atraso for
concluído, reproduza a linha do tempo e mova
nosso ator, gire nosso Agora, o que vamos jogar? Não há nada. Não
preparamos nada para jogar. Não lidaremos com
o novo horário e o
novo horário definidos porque são
um pouco mais avançados do que o que
estamos fazendo agora. Então, o que precisamos fazer
é inserir a linha do tempo. Como você pode ver, esse é
um nó muito especial. Então, se eu clicar duas vezes nele, abrimos aqui,
e aqui, temos o
gráfico de eventos, e aqui está a linha do tempo, porta específica Temos um caminhão que
vamos ver o que é. Ele
adicionará algo como sistema
Tessian,
como, por exemplo, um caminhão de fluxo. O que
vamos
usar , o que
vou fazer é pressionar a tecla Shift
e clicar aqui para criar um ponto, clicar
e criar um ponto Agora, esses dois pontos
têm um tempo e um valor. Se eu definir a hora como
zero e o valor zero, isso seria o meio
do nosso sistema cartesiano Se eu for para a próxima
e pressionar, digamos quanto tempo a
porta levaria para abrir. Digamos que o ponto 0,5
e o valor de um, podemos ver que isso foi para o
valor um no tempo 0,5. Agora temos uma inclinação na qual
podemos dirigir algo com ela. O resto dos botões,
como você pode ver, é o botão de comprimento, que se eu diminuir
o zoom em 5 segundos, ele interrompe a linha do tempo Eu poderia definir esse 2.5, e isso interromperá
a linha do tempo aqui Mas há outro botão
aqui, use o último quadro-chave, que mesmo se eu adicionasse um caminhão
maior em 5 segundos, ele notaria que
o último quadro-chave está em 0,5 e interromperia
a linha do tempo Agora, se houvesse
mais faixas novamente, ele pegaria o último
quadro-chave da faixa mais longa Agora, é claro, existem
algumas opções, como reprodução automática, loop e outras
coisas para fazer, quais não
precisaremos no momento A única coisa que
precisaremos
fazer é nomear essa nova faixa, clicar e pressionar F dois aqui, e eu vou puxar
essa rotação da porta como Alpha. Vou economizar.
Vou fechar o cronograma porque
não precisamos mais dele. Certifique-se de que usamos o último quadro-chave se
você tiver 5 segundos, e eu vou fechar isso Agora temos um novo pino aqui,
o Alpha de rotação da porta. Esse é o valor
0-0 0,5 segundos 0-1. Isso funcionará por 0,5 segundos. Ele será atualizado
para esse valor, e isso corresponderá ao
valor de 0-1 nesses 0,5 segundos. Agora, como posso
conectar isso aqui? Não há alfinete verde. Bem, o que eu posso usar é, novamente, um novo nó com
comportamento prescritivo chamado nó de alerta, que é um
nó matemático, um larp, que é uma interpolação
de A para B,
basicamente, e eu posso
conectar o B aqui, que é meu destino
e minha rotação original,
que era -90, que era Então eu posso conectar
esse Alpha aqui. Também posso escolher o caminho
mais curto, se necessário, mas
às vezes isso pode atrapalhar as coisas Portanto, com base em suas rotações, você pode escolher se deseja
marcar isso ou não Vou até Mar
Map e aperto Play. E isso é para -60. Vamos colocar em menos 180 porque queremos abrir
para dentro Mas funcionou.
Nós vimos isso funcionando. Sim, a porta está se
abrindo sozinha, esperando 2 segundos, e essa linha do tempo está
animando nossa Eu acho que isso é
suficiente para este. Nos vemos
na próxima. Adeus
6. Criando abertura de portas interativas com gatilhos de colisão: Olá, bem-vindo de volta
ao Unreal Engine five, Blueprint Mastery Door Systems
e aos portais interativos Anteriormente,
explicamos algumas coisas sobre a linha do tempo
e como ela funciona Nós o adicionamos ao nosso plano de mapa
tutorial. Usamos o evento begin play. Usamos o atraso e
reproduzimos a linha do tempo para definir a rotação
do ator com
base no larp de um Criamos uma variável
para nossa nova rotação
e, dentro da linha do tempo,
criamos um caminhão de fluxo
0-1 usando 0,5 segundo Também clicamos em
usar o último quadro-chave, então a duração da linha do tempo é irrelevante para a duração dela Ele pega o último quadro-chave. Agora, isso acontece
quando começamos a jogar. Mas o que queremos
fazer é que isso aconteça quando o jogador
se aproximar da porta. Como faríamos isso? esse sistema de detecção de colisão, o que significa que temos um sistema para entender
quando um objeto, digamos, por exemplo, um jogador está colidindo com Por exemplo, a parede, por que não
podemos sair dessas paredes? Não é que eles sejam
sólidos ou algo assim. Dizemos ao jogo para o
programa que, para nosso peão, para esse personagem,
isso se comporta de forma sólida, por exemplo,
me impede de Então, como isso está acontecendo? Vamos acessar nosso botão de adição rápida
ao projeto e
procurar um gatilho. Caixa de gatilho. Vamos
trazê-lo aqui e verificar seus detalhes. Eu o tornei um pouco maior para que possamos
ver algumas coisas. Quando pesquisamos os detalhes, há uma guia específica chamada
colisões. Aqui está. E nesta aba, podemos ver
essas predefinições de colisão. Portanto, cada objeto irreal, como a parede, o gatilho de
colisão, a cápsula, a posição do
jogador quando aparece, tem suas Temos uma maneira de atribuir um tipo de objeto que
define que tipo de objeto é o que definimos, veja que esta é
uma palavra dinâmica. Vamos personalizar isso. Então, podemos mudar um
pouco isso. Personalizado, posso
alterar o
comportamento desse gatilho além da predefinição
original Como se a
predefinição original fosse gatilho, eu acho que é gatilho E com o costume, eu posso
dizer: Não, você sabe o que? Você
bloqueará a estática da parede ou bloqueará Se eu pressionar bloquear
patas, pressionar play, descobriremos aqui isso,
sim, aqui está Veja, eu não consigo superar isso.
Está bloqueando a lagoa. Por outro lado, se estivesse
sobreposto ao lago
, eu simplesmente passaria Deixe-me ver onde está
a colisão. Vamos tornar isso visível. Se eu for aqui e
pressionar visibilidade. Não, na verdade, escondido no jogo. Se eu desclicar aqui, posso ver isso no mapa Então, acontece que você
trabalha ao mesmo tempo. Ainda não programamos isso. Então, outra coisa sobre colisões é que elas geralmente
são invisíveis Eles estão sempre escondidos no jogo. Então, por exemplo, nossa porta, temos esse gatilho
na frente dela. E ele será responsável
por abrir e, na verdade, por apenas abrir a porta, vamos torná-la um
pouco maior. Vamos movê-lo para cá. Talvez um pouco
maior, mais largo. Sim, acho que é
um bom lugar. Então, vamos usar essa colisão. Eu tenho o gatilho selecionado, vou seguir o plano
de nível Vou clicar com o botão direito do mouse e criar uma referência
para a caixa de acionamento. Vou compilar. Agora, como
usamos essa caixa de gatilho? Bem, como vimos nas predefinições de
colisão, há três respostas principais:
sobreposição, bloqueio Vamos colocar isso de volta para
acionar os padrões de colisão já Então, o que queremos
não é ignorar, nem bloquear, porque não nos
importamos com
esses canais, e eles estão praticamente desativados Mas queremos que, quando
estamos sobrepostos, façamos algo quando provavelmente o
jogador se sobrepõe a Podemos verificar se o jogador
está sobreposto. Sim. Vamos voltar à
nossa caixa de gatilho e digitar drawable e digitar overlap E podemos ver vários
comandos para isso. Podemos ter atores sobrepostos. Podemos obter
componentes sobrepostos, que são diferentes Podemos sobrepor um ator. Podemos perguntar se está
sobrepondo ao nosso jogador. Mas podemos ver algumas outras coisas atribuídas e vinculadas aqui,
atribuídas à sobreposição inicial do ator,
atribuídas à sobreposição final do ator, vincular evento ao ator início da sobreposição e evento verdade, não há
muita diferença entre atribuir e vincular Ambos usam bind basicamente. Vamos ligar para Assign primeiro. Atribua um ator para iniciar a sobreposição. E também vamos chamar bind. Portanto, vincule a sobreposição. Vincule o evento na sobreposição
inicial real. Como você pode ver,
os dois chamam de bind. A diferença é que uma placa também
cria um evento para nós. Bem, se chamarmos bind, temos que criar
o evento nós mesmos E para fazer isso,
basta tirar proveito do evento e fazer um evento personalizado. Por que extraímos do evento Porque vinculação a uma caixa de gatilho
requer entradas específicas Este não é um evento personalizado
qualquer. É chamado de evento personalizado,
mas não é nenhum costume. Você pode ver que tem
essas duas entradas aqui, assim como essa também Se eu criar um
evento personalizado sozinho, você verá que ele não tem nada. Eu tenho que criar
essas entradas sozinho. Mas se eu
criar essas entradas, como se eu estivesse adicionando duas entradas, elas deveriam ser do tipo
ator objeto de Você verá que
agora consigo conectá-lo aqui. Eu posso compilar e está
funcionando porque o que isso requer são basicamente essas
duas referências de objetos atores Então, desde que eu
os criei, está tudo bem. Se eu os remover, deixe alguns funcionarem. Então, sim, veja, ele não tem as entradas, então não pode delegar Não é compatível. De qualquer forma, vamos
continuar
explicando quais são essas duas referências a
objetos atores. O ator de sobreposição significa
nossa caixa de gatilho,
basicamente, qualquer colisão de
caixa de gatilho que tenhamos usado Outro ator é o
ator que se sobrepôs. Então, o que precisamos fazer agora é excluir tudo isso e começar a jogar um
pouco mais. Vamos desconectar isso. Vou usar Alt e
clicar para desconectá-lo, e vou
conectar isso aqui Quando o jogo começar, vincule algo a essa
caixa de gatilho quando ela começar a se sobrepor Então isso é alguma coisa.
O que deveria ser? Em primeiro lugar, precisamos perguntar se o outro ator
é o jogador. Fazer isso para testar se o
outro ator é o jogador. Há várias maneiras. No momento, vamos
fazer isso com um nó de fundição, que é um pouco mais
caro do que outras formas, mas é uma boa maneira de
mostrar o elenco. Então, o que é elenco? Vamos primeiro ligar para ele. Vou chamar o
elenco para a terceira pessoa. Personagem. Basicamente, está
perguntando, você é isso? O objeto que está chegando é o objeto que
estamos solicitando Então, estamos apostando nisso. A razão pela qual estamos recorrendo a ele geralmente
é porque
queremos algumas informações
desse objeto. Novamente, existem outras
maneiras melhores do que fundir para fazer isso
em maior escala, mas para nós, no momento, isso
não criará nenhum problema. Então, por exemplo, se eu quisesse a velocidade
do personagem, eu poderia digitar aqui
velocidade obter velocidade, e eu obteria a velocidade
do personagem em terceira pessoa
ou Como se eu quisesse
verificar a colisão da cápsula.
Componente Apsu Aí vem com, que é
um personagem específico. Sabemos que cada
personagem tem uma cápsula, então eu posso obter essa informação
do personagem. Agora, se tivéssemos algo instantâneo específico
nesse personagem, por exemplo, ter um HP, poderíamos obter o HP
desse personagem a partir daqui. Por outro lado, se não fizéssemos isso, eu não conseguiria pegar,
digamos, a cápsula novamente. Não há
componente de cápsula de obtenção porque o outro ator pode
ser qualquer tipo de ator. Mas com o elenco, estamos
convidando o elenco para terceira pessoa. Você é um personagem de terceira
pessoa? E se você for, então se
o elenco for bem-sucedido, podemos obter algumas
informações a partir disso Se o elenco falhar, isso significa que não é o que estamos pedindo. Então, vamos perguntar: o que
está colidindo com
o outro personagem,
o personagem em terceira pessoa Se sim, então
vamos apenas reproduzir a linha do tempo, e pronto Vamos compilar. E vamos chegar perto da porta e
a porta se abriu. Eu acho que isso é
suficiente para este. Na próxima, vamos
fazer o fechamento da porta. Vamos colocar algo
aqui para pisar aqui, abrimos a porta, pisamos
aqui, fechamos a porta. Mas isso é para este. Eu vou
te ver na próxima. Adeus.
7. Técnicas avançadas de colisão no Unreal Engine: Olá, bem-vindo de volta aos portais
Andrea Engine five, Blueprint Mastery, Door Systems
e Interactive Na última lição,
paramos de criar essa colisão que, quando o jogador se aproxima,
a porta se abre E para fazer isso, usamos o esquema de nível
e criamos
o evento de vinculação em nossa caixa
de acionamento
ao iniciar o nossa caixa
de acionamento
ao Então, quando nosso jogador
está se sobrepondo, estamos acionando Estamos verificando se é nosso
jogador porque poderia ter sido outra coisa
com nosso nó de elenco
e, em seguida,
ativamos nossa linha do Agora, vamos colocar isso um
pouco em ordem. E vamos criar um
sistema similar para fechar a porta. Então, vou
selecionar nosso gatilho. Vou copiar e colar, controle bem o controle C. E eu vou
movê-lo para cá. Na verdade, eu poderia ter
feito o mesmo
usando apenas o t e
arrastando a partir de uma seta Portanto, copiar e colar ou Alt e
arrastar seria o mesmo. Agora, vou fazer
isso um pouco menor. Vou adiantar um pouco. E agora vou criar
uma referência para ela
selecionando-a na janela de exibição e voltando selecionando-a na janela de exibição e ao nosso plano de
nível.
Vou clicar com o botão direito do mouse e
criar uma referência
para a caixa de acionamento dois Agora, novamente, precisamos usar o evento de vinculação em
Actor start overlap Então, vou usar esse
evento, copiar e colar aqui. Vou conectar
a caixa de gatilho porque esse é o alvo. Target se refere a
quem, por exemplo, estou vinculando esse evento de e
para o evento, vou criar
um evento personalizado. Vamos chamar isso de
perto, do Tigger. Eu vou trazê-lo para cá. Vou copiar o elenco para
o personagem em terceira pessoa. Vou colocá-lo aqui e vou conectar
essas duas reversões. Então, vamos jogar. E quando chegarmos perto da porta, ela abrirá a porta. Se eu for até aqui,
vai fechar a porta. Talvez um gatilho seja
um pouco maior, mas tudo bem.
Sim, está funcionando Então, o que estamos fazendo basicamente
é a mesma linha do tempo, estamos revertendo a partir do
momento em que a linha do tempo Por exemplo, se formos diretamente para essa caixa,
nada acontecerá. É uma boa maneira de
demonstrar também algo. Se eu pressionar Alts, estou ejetando na Tenha cuidado para que isso
funcione apenas nessa janela de exibição. Se eu executar um jogo independente, se eu jogar no novo
editor Window Pie, se eu pressionar Alts,
ele não funcionará Não consigo ejetar daqui, mas posso ejetar de uma janela de visualização Então, vamos jogar na janela de exibição
selecionada, certo. Agora, vou usar alts e
ejetar dessa janela de visualização e vou trazer o mapa do
tutorial até aqui, o plano do mapa do tutorial Na verdade, um pouco maior, certo. Nós precisamos disso. E essa é a
maneira real do depurador de depurar visualmente os maneira real do depurador de depurar visualmente Você está selecionando qual blueprint
deseja ver funcionando. Porque se eu tivesse duas
dessas plantas em nosso mapa,
agora, eu não poderia ter plantas de
dois níveis, mas se fosse outro
tipo de planta e eu tivesse o dobro ou 100 vezes, todas elas apareceriam Portanto, preciso saber qual
deles estou depurando,
qual deles estou vendo para depurar qual deles estou vendo Então, vou selecionar
o mapa do tutorial. E vamos ampliar um pouco o
código, trazê-lo aqui,
e eu vou voltar
ao nosso jogo
pressionando F oito. Agora, eu não
precisei realmente ejetar, mas foi uma boa
oportunidade de mostrar a ejeção De qualquer forma, oito, de volta
ao nosso personagem. Agora estou movendo o personagem. E eu vou passar por esse. Você pode ver que está sendo acionado. Está se sobrepondo. Está funcionando, mas nada está acontecendo. Nada está acontecendo
porque já está no final. Então, isso aciona por
uma fração de segundo, um quadro para verificar
se está no final Onde, se eu for aqui, ele dispara o tempo todo Se eu for aqui agora, ele
dispara o tempo todo. E é assim que
você pode ver seu código, como ele está sendo executado,
onde está parando, onde tem algum problema. Às vezes, vale a pena ter
duas telas para isso, e a mesma tela pode ser um pouco incômoda, mas é factível De qualquer forma, vamos colocar
isso de volta aqui, pressione parar. A próxima coisa que faremos é, de alguma forma, dizer ao
jogador: pise aqui, neste lugar aqui
para fechar a porta. Então, para fazer isso facilmente, eu poderia simplesmente trazer um texto
aqui, apenas texto, texturner actor aqui,
vamos trazê-lo para
algum lugar que eu possa ver, eu preciso girar 90 e
trazê-lo talvez E se eu for aos detalhes, como dissemos, cada elemento
tem seus próprios detalhes. Agora, o texto tem
seu próprio detalhe
, chamado texto. Tudo o que eu digito aqui,
podemos ver no mapa. Então venha aqui para fechar a porta. Se eu quisesse colocar isso
em uma linha diferente, vamos continuar capitalizando cada
letra, cada primeira letra O que eu poderia fazer é ir até aqui, eu posso simplesmente pressionar Enter, e vamos para a linha abaixo. Desculpe, isso é uma distração. Preciso
tornar isso maior. Portanto, com o alinhamento horizontal, o alinhamento
vertical
também pode manipular nosso texto. Vou deixá-lo no centro
e no final do texto. Eu
acho que parece bom. Vou
movê-lo assim e talvez torná-lo um pouco menor 24. Bem, 20, 20 parece bom. E eu vou
movê-lo. Não, estava tudo bem. Então, essa é uma forma de
vermos algum texto. Venha aqui para fechar a porta. Mas se eu quisesse fazer o
texto aparecer acima da porta, em um certo tempo, eu
ainda precisaria de uma
caixa de colisão para fazer isso Agora, poderíamos preencher
o mundo com caixas de
gatilho e, usando o plano de níveis,
poderíamos comprá-las. Mas e se eu quisesse ter apenas uma caixa de gatilho com a qual eu pudesse fazer muitas coisas
e, dependendo das minhas necessidades, pudesse alterar sua
funcionalidade. É aqui que um
projeto de ator entra em cena. Essa é a diferença
entre o plano de nível, que é um plano responsável
por todo o nível, e temos o plano do ator, que é responsável
por si mesmo e por fazer as coisas que
deveria Então, vamos às nossas plantas. Vamos criar
um novo, não usar o teste. Vamos escolher a classe blueprint. Vamos escolher um Noctor e
vamos chamar esse texto de plotagem PP. Vamos inserir esse plano. Como dissemos, o plano de nível é responsável por todo
o nível Portanto, teoricamente, seus componentes
poderiam ser todo o nível. Mas esse projeto tem esse ponto de vista e,
como descrevemos, é aqui que podemos ver visualmente algumas partes
do nosso projeto, que
consiste nosso projeto E onde os colocamos está
o esboço do componente aqui. Então, para este projeto, precisaremos de
uma caixa de gatilho Uma caixa de gatilho em plantas, porém, não é
chamada de caixa de gatilho É chamada de colisão de
caixa de colisão, colisão de cápsula
ou colisão de Essas são as
classes padrão que temos disponíveis. Eles são 99% quase iguais. Eles são quase iguais, mas não são os mesmos. É por isso que são
chamadas de caixas de gatilho e são chamadas de colisão
de De qualquer forma, vamos seguir em frente
escolhendo uma colisão de caixas. Nesse caso em que estamos dentro
desse projeto, não
preciso referenciar a colisão
da caixa de alguma forma porque ela está dentro do plano,
enquanto
no plano de nível, enquanto
no plano de nível preciso referenciar essa caixa de
gatilho Agora, se eu trouxer essa
planta para dentro do mapa, podemos ver a colisão da caixa Mas eu não preciso
referenciar isso aqui porque pertence
a este projeto Quando preciso
chamá-lo no meu gráfico de eventos, posso simplesmente arrastá-lo e
soltá-lo daqui ou posso arrastá-lo e soltá-lo de
variáveis e componentes. Lembre-se de variáveis, componentes também
são variáveis. E como temos
o comportamento
da caixa de gatilho
perto de nossas mentes, vamos examinar o comportamento
da colisão da caixa Como você pode ver, ele tem um esboço de
detalhes muito diferente aqui E se eu for até o Viewport
e
selecioná-lo, ele fica mais próximo do outro,
com algumas diferenças, como por exemplo,
esses eventos
aqui antes de precisarmos
chamar Bind on event Então, podemos fazer isso
a partir daqui também. Então, vincule na sobreposição. E podemos ver que esses
eventos existentes aqui também começam a se sobrepor e se
sobrepor e tudo Mas como está dentro
do projeto, Areal nos fornece esses eventos
que podemos usar diretamente Por exemplo, eu quero que um
componente comece a se sobrepor. Posso clicar nele e
ele cria o evento, então não preciso vinculá-lo Um pouco mais de informação se eu o estivesse chamando de outro
modelo, por exemplo, se eu tivesse uma referência
a isso, digamos eu tenha essa caixa selecionada, trago uma referência
aqui para esta caixa Agora, desta caixa, posso obter o meu a partir
desta planta, posso obter o componente da caixa Eu desço a lista, pego a caixa, posso vincular aqui, porque se eu clicar aqui, podemos ver que não há eventos
como estava no blueprint Então, se eu quiser vincular de outro
lugar a esta caixa, ainda
preciso vincular assim Deixe-me terminar a demonstração. Então, vou vincular a sobreposição
e, em seguida,
criar um evento personalizado E, como você pode ver, tem mais opções do que
a caixa de gatilho. É por isso que estou dizendo
que não é exatamente o mesmo. De qualquer forma, isso é apenas
uma informação extra. Vamos voltar ao nosso plano e eu vou
deletar essa caixa Não precisamos disso
porque temos esse evento pronto para nós. E entre parênteses, você pode ver qual caixa é Por exemplo, tínhamos mais
cinco caixas que
diziam que esta é a caixa
15, mais 15 caixas. Podemos ver que esta é a caixa 15. Agora, eu acho que este é um bom ponto de
parada para este. Eu vou te ver
na próxima. Adeus
8. Controlando texto e luzes com programação de Blueprint: Olá, e bem-vindo de volta
ao Unreal Engine, cinco sistemas de portas
Blueprint Mastery
e Então, anteriormente, começamos a
criar nosso ator
Blueprint de texto baixo Adicionamos essa
planta no mapa e adicionamos um cubo de colisão,
uma colisão de caixas dentro da janela de visualização,
dentro dos componentes da E demonstramos um pouco a sobreposição do aceno de
início do componente, caixa 15 versus a inclinação da caixa
de gatilho, que era um pouco mais simples Agora, vamos continuar
construindo esse projeto. Os próximos componentes
que precisaremos são uma luz pontual e um texto. Renderização de texto. Agora, na linha de pontos,
precisávamos tornar o texto um
pouco mais visível, se estivesse oculto ou não,
não oculto, não
visível à iluminação. E bem, faça com que se
destaque um pouco melhor. E a proposta de texto
seria o texto que adicionamos ao nosso texto, da mesma forma que adicionamos a
etapa aqui para fechar a porta, que na verdade devemos trazer. Vou usar Alt e
arrastar alguma superfície aqui. E tudo bem. Talvez coloque um pouco mais baixo. Assim, o jogador sabe
onde deve pisar. Vamos tornar isso um
pouco menor também. Está tudo bem. Está tudo bem aqui. Sim. E agora precisamos colocar
esse texto acima da porta para dizer: aproxime-se
da porta para que ela se abra. Como queremos usar
isso várias vezes,
vamos usar o script de construção,
que, novamente, é exclusivo
da classe blueprint Bem, para a maioria das classes de blueprint, como dissemos, o nível, o blueprint é diferente em comparação com
um blueprint simples A maioria das classes de blueprint tem
o script de construção. O Sprint de construção é usado para fazer coisas no editor É muito bom usá-lo para geração
processual
e randomização, personalização Por exemplo, agora, precisamos personalizar nosso texto. Como cada instância
desse projeto que vamos trazer
para o mundo, se eu duplicar Queremos que o texto diga outras coisas em uma instância e outras coisas em
outra instância. Portanto, esse é o mesmo modelo, mas temos duas instâncias
com texto diferente Uma maneira de fazer isso seria utilizar esse script
de construção. Vamos colocar nossa tendência de
texto aqui, basta arrastá-la e soltá-la Uma dica rápida para isso seria se eu segurar a tecla Control e arrastar e soltar, estou ficando melhor Se eu estiver aguentando, vou pegar um setter. Como você viu, eu arrasto e solto daqui,
é a mesma coisa. É a nossa tendência de texto. Se eu renomear este textnder M, você pode ver que ele também está sendo
renomeado Então, guia de componentes,
lista de componentes em variáveis. Não vamos nos preocupar
com um setter, sim. Vamos apenas
usar o one getter
e vamos definir o texto A diferença entre
esse texto definido e obter essa renderização de texto definido M seria que isso
se refere ao valor, deixe-me escolher a renderização do texto. O valor do texto em que isso se refere à entidade
de renderização do texto. Então, isso mudaria
se eu tivesse predefinido variáveis com renderizações de texto, eu poderia alterá-lo assim De qualquer forma, um pouco confuso. No momento, vamos
apenas fazer o valor da renderização do texto. Novamente,
detalhes diferentes quando estou aqui, detalhes
diferentes quando estou
selecionando aqui. Eu não preciso estar no viewpod
seria
a mesma coisa, mas detalhes diferentes de
uma perspectiva variável e detalhes uma perspectiva variável e diferentes de uma perspectiva de
componente Agora, vamos continuar. Script de construção, precisamos
alterar nosso valor de texto. Então, vou promover
isso para uma variável. E já o nomeou
por nosso valor. Vamos adicionar o
texto na frente dele. Valor do texto. E o que vamos fazer é
usar esse botão aqui, editável
por instância ou
encontrá-lo aqui e usar
o I aqui Você pode vê-lo
clicando automaticamente em Instância editável com o e aqui Também vamos
expô-lo no spawn,
caso estejamos gerando Bem, não
vamos gerá-lo, mas se você quiser
gerar esse projeto, você o exporá Agora, vamos compilar, salvar
e voltar ao nosso mapa e demonstrar
o que acabamos Temos esse valor de texto e tudo o que colocarmos como valor
aqui seria nosso texto. No momento, está vazio. Então,
se formos para nossa janela de exibição, podemos ver que não
há texto Na verdade, desapareceu.
Se eu pressionar aqui um, dois, três, podemos
ver um, dois, três. Então, o que quer que adicionemos como
valor a essa variável, podemos realmente semear o
correspondente à nossa renderização de texto, e isso está acontecendo
por meio do script de construção. Agora, isso significa que isso acontece antes que o jogo seja executado,
antes de eu pressionar play. E outra coisa é que
pressionamos instance Edit
e expomos em span Então, se clicarmos nessas plantas e
analisarmos os detalhes aqui, deixe-me aumentá-las um
pouco Podemos ver na categoria
padrão um valor de texto. Para ter mais certeza, vamos
digitar meu valor de texto. E podemos ver que isso
mudou o valor do nome. Então essa é a nossa variável. Então, o que quer que eu escreva
aqui, tipo, olá ,
oi, vai se
tornar o novo texto. E aqui podemos ver a
definição de instanciação, como uma planta diz oi,
a outra planta
não diz a outra planta E digite olá e
este diz oi, e esse diz olá. Portanto, tornar a variável pública
ou expô-la realmente editável
por instância nos dá a oportunidade de alterar
a variável aqui Agora, o padrão da categoria,
é outra coisa. Quando vamos para a
variável em si, podemos ver que há
vários detalhes aqui. Um dos detalhes
é a categoria. Podemos categorizar nossas variáveis e manter como se
fossem componentes Eles estão em componentes como uma lista. Se eu adicionar este a uma categoria
chamada digamos texto, agora podemos ver que isso
pertence ao texto da categoria. Além disso, se eu sair
daqui e, na verdade, precisar compilar
para ver essa alteração, podemos ver que, em vez
do padrão, ela diz texto Poderíamos fazer várias configurações aqui para definir a posição
da luz pontual, do texto e da caixa, mas não iremos tão
longe no script de construção. O que podemos fazer, porém, seria trazer a luz pontual
e definir
a intensidade. E digamos, dê a ele um valor
padrão de 1.000 e agora promova isso para uma variável, vamos deixar
com uma nova intensidade. Vamos mudar a
categoria também para clara e também definir a cor. Talvez você queira
configurar uma cor diferente. Vamos definir o
valor padrão como branco. Sim, branco, branco,
não. E vamos promover isso para uma
nova e variável cor de luz, além de uma categoria
editável por instância Agora, em vez de mudar
a categoria aqui, o que eu posso fazer é simplesmente
arrastá-la e soltá-la aqui e ela entra
nessa categoria. Agora, vamos trazer isso aqui. Na verdade, eu posso simplesmente
duplicar isso. Agora, ter essa
opção em vez de uma e arrastar outro
cabo também é válido Isso não cria um problema. Isso até deixa um
pouco mais claro o que é o quê. A outra coisa que eu
queria explicar é por que pressionei um valor padrão aqui e
depois promovi para variável. Bem, quando eu faço isso dessa maneira, se eu compilar a variável
promovida, nova intensidade mantém o valor que eu tinha como padrão, e a cor também
seria branca Então, agora, se eu for, não
cliquei nisso
para ser editável por instância Vamos expô-los no spawn, talvez para um
uso mais avançado, compilar e salvar Vamos ao nosso mapa
e agora podemos ver a categoria de texto e a categoria de
luz aqui. Na verdade, não
precisamos dos dois. Só precisamos de um por enquanto, e vamos configurar um
pouco o posicionamento. Então, o que queremos
alcançar aqui? Se eu o tiver selecionado, posso escolher os componentes
desse projeto Se eu escolher essa porta, posso escolher os componentes
dessa planta Se eu escolher a parede,
posso escolher nos detalhes
os componentes
do que estou escolhendo. O que vou fazer
é escolher a caixa. Então, quando o jogador se move em direção à porta porque
não há outro lugar para se mover, acionará esta caixa Eu acho que este é um
bom lugar para colocá-lo. O jogador pode pular. Então, vamos torná-lo um
pouco mais alto. Então, eles vão
vasculhar essa caixa. Vamos pegar a mensagem. Vamos jogar basquete. Eu vou
pegar isso daqui. Uma rotação de 90, e
vamos definir um texto. Também digamos que chegue perto para abrir a porta. Nada mudou. Ok, erro meu. Não devo
fazer isso com a renderização do texto. Devo fazer isso com a planta, meu valor de texto próximo
para abrir a porta Tudo bem. E vamos mover
esse texto acima da porta. E vamos tornar a frase
um pouco mais curta. Vamos apenas nomear essa
abordagem para abrir. Novamente, é um erro.
Deve estar na planta, não na renderização do texto, porque
substituímos essa renderização de texto a partir
daqui Portanto, não é muito a
abordagem Não, para abrir. Acho que abrir precisa de um
P. Então, aproxime-se de abrir. Vamos selecionar o
texto mais tarde novamente. Coloque-o um pouco melhor. E vamos trazer também
a luz acima dela. Então, isso faz com que o jogador
olhe para o novo ponto de luz que ele vê. Acho que está configurando isso. Vamos
ver como fica. Ótimo. A próxima coisa que devemos fazer é um pouco
de funcionalidade, mas acho que esse é um bom ponto de
parada. Nós o configuramos. Criamos os outros componentes, os configuramos no mapa, e acho que esse é um
bom ponto de parada. Eu vou te ver
na próxima. Adeus
9. Dicas de interação de programação com Blueprints: Bem-vindo de volta ao
Unreal Engine five, Blueprint Mastery, Door Systems
e portais interativos Anteriormente, criamos
nosso texto de fluxo BP. Na verdade, adicionamos
mais alguns componentes e
criamos o
script de construção que controla o texto, a cor e a intensidade. Nós o adicionamos ao nosso mapa e usamos os próprios
componentes. Escolhemos a planta
e, a partir dos detalhes,
escolhemos os componentes que
queríamos e
os movemos para o espaço de acordo
com o que desejamos Vamos continuar com
a parte de codificação. Quando o jogador se sobrepõe, vamos perguntar novamente se é nosso
jogador quando o outro Desta vez, vamos fazer
isso um pouco diferente. Vamos acessar
nosso navegador de conteúdo, vamos até uma terceira pessoa, vamos
até planos de pastas
e abriremos
nosso BP em terceira Na terceira pessoa, há o código que se move
ou joga ao redor. Há o
roteiro de construção e o mirante. O painel de visualização consiste na malha do personagem, na cápsula, câmera Boom ****, na câmera
e no componente de movimento do
personagem Agora, o que queremos é usar
a cápsula e ir até os
detalhes e pesquisar Tug e adicionar o Tug P agora, o que são tags? As tags são rótulos ou
identificadores simples, se você desejar, que podem ser atribuídos aos atores ou componentes do
blueprint e ajudam a categorizar e identificar objetos
no mundo do jogo,
facilitando a filtragem, a
localização ou o acionamento de
comportamentos específicos Por exemplo, agora,
o que vamos fazer, vamos salvar e compilar.
Vamos voltar para. Vamos perguntar se
não é o outro ator, mas o componente ao qual sobrepomos Tem a etiqueta?
Na verdade, tem etiqueta. O componente tem uma tag,
e vamos
escolher porque essa é a tag
que inserimos aqui. Vou fechar isso.
Não precisamos mais disso. E se o componente que se sobrepôs
à caixa tiver a tag P
, usaremos uma ramificação, que é um nó I. Então, basicamente, se
isso estiver correto, se for verdade, a condição, nossa condição agora é que o componente tem tag,
ela passa de verdadeira. Caso contrário, passa de falso. Portanto, é uma declaração Is
com uma condição. E, claro, ele
precisa da execução. Se tivermos a tag do componente P
, dispararemos a ramificação verdadeira. Caso contrário, disparamos
o galho falso. Se for verdade,
precisaremos do renderizador de texto e da luz pontual Vamos desenhar
uma visibilidade definida. Agora, esse é um
nó que controla a visibilidade de um componente Devemos
transformá-lo em verdadeiro e acessar nossos detalhes na renderização do texto
e pesquisar por visibilidade. E se transforma em pulso, e o mesmo fazemos
com a luz pontual. Como você pode ver,
mudei a entidade, o componente em que estou clicando, e ela manteve a tag aqui. Então, isso é muito útil. Estou tentando apagar a luz,
desligar , compilar e salvar Então, isso transformará a
visibilidade de ambos em verdadeira. Vamos testá-lo. Se eu for
jogar, não consigo ver nada. Eu passo por aqui, me aproximo para abrir. Perfeito. Passe aqui para
fechar, aproxime-se para abrir. Vamos tornar nosso segundo
nível visível. Vou clicar no
olho no segundo nível
e agora está visível. E, na verdade, se
entrarmos nesta sala,
vamos duplicar isso Vou apenas selecionar isso
e arrastá-lo aqui e selecionar a parte inferior
também e arrastá-lo aqui, talvez um pouco
mais aqui. Eu poderia copiar o texto também
girando e, com alt, vou duplicá-lo
e arrastá-lo até aqui Então, sim, acho que está tudo bem. Vamos selecionar nosso novo gatilho, acessar nosso mapa tutorial, trazer a referência
e conectá-la aqui. Então seria isso. Agora, vinculamos esse gatilho também a esse evento Então, se eu vou jogar, eu posso
ir aqui, me aproximar para abrir. Na verdade, me aproximo para abrir, e eu vou passar por
aqui e fechar, abrir, fechar. Ótimo. Nossa próxima porta
será aquela em que pressionarmos E e ela se abrirá. Então, vamos trazer nosso ator de
colisão aqui. Na verdade, vou
trazer um novo. Envie o texto aqui. Vamos configurar a tecla de texto
para abrir D. Vamos colocar espaço aqui. Novamente, se eu quisesse
mudar a aparência
do texto, eu poderia
selecionar uma renderização de texto. Eu poderia mudar as opções aqui. Eu poderia mudar a cor, e não expusemos
todas essas variáveis. Acabamos de expor qual seria
o texto. Onde queremos colidir? Digamos que quando o jogador tenha
andado pela metade da sala, digamos que em algum lugar aqui. Novamente, para mover isso, estou apenas selecionando-o nos detalhes. Vamos colocar a luz
em algum lugar aqui. E vamos trazer o
texto. Qual é o texto? Oh, não é visível. É por isso que eu não consigo ver. Então, vou pesquisar
a visibilidade nos detalhes do texto. Vai se tornar realidade. E agora eu tenho o texto. Eu meio que não gosto disso, então vou
mudar algumas configurações. Vou enviá-lo para o centro e próximo ao centro. Tudo bem. Acho que isso parece melhor. Sim, esse lugar é bom. Podemos pintar em grande escala
em outra ocasião. Agora, vamos verificar se eu preciso colocá-lo novamente em
invisível, a visibilidade. Certo? Vamos testá-lo. Vamos até esta porta
e não há mensagem de texto. Estou fechando a porta.
E isso pareceu ótimo. Agora, a única coisa que precisamos
é abrir para fazer essa porta. Então, vamos começar com a
criação do projeto. Clique com o botão direito do mouse, vá para a classe
Blueprint e
selecione unactorblueprint, porque não precisamos
possuí-la , não
precisamos movê-la É apenas uma entidade com
algumas funcionalidades. Então, ator blueprint, vá
chamá-lo de PP one way door. Opa. Talvez uma maneira de. Então, vamos abrir esse plano. Na verdade, vamos criar
uma pasta para as portas. Vamos ter uma pasta chamada
portas dentro das plantas, e eu vou arrastá-la
e soltá-la aqui E vamos trazê-lo para o mundo. Vamos
configurá-lo depois. E outra forma de
abrir o blueprint além de clicar duas vezes aqui,
seria usando o esboço, escolhendo o blueprint que eu quero editar e, se eu o tiver
trazido ao mundo,
posso simplesmente clicar aqui, em Editar Blueprint, ou
simplesmente selecionar Open Blueprint Editor selecionando Então, eu vou abri-lo. E para esse projeto, precisaremos de
três componentes Vamos adicionar uma caixa de colisão. Isso detectará se o jogador
está ao alcance ou não, para que ele possa abrir a porta ou não E também
precisaremos de uma seta Então, sabemos para onde
a porta está voltada, que é a frente e
depois qual é a parte traseira, e
precisaremos de uma malha estática Então, para a
malha estática, na verdade, porque eu não quero
pesquisar os ativos. Como a temos aqui,
posso simplesmente selecionar esta navegação com a
desculpa, não esta seta. Os detalhes aqui, eu
vou ver a visibilidade e vou
selecionar a porta. E na malha estática, posso ver qual malha estática é a entidade
da malha estática. Vou até aqui, e
aqui está a porta. Agora, vou voltar à minha planta e
adicionar uma malha estática, e ela já
selecionou a porta para mim Ótimo. Agora, é um
pouco de inicialização P. Isso realmente não importa.
Eu só vou trazê-lo para cá. E o resto podemos mover do próprio mapa
selecionando a planta Isso é girado em 90 graus porque o movimento será no espaço relativo Agora, o que isso significa? Quando eu giro a porta aqui, primeiro lugar, eu giro toda
a planta Então, mesmo que eu girasse a
porta de outra forma, ela estaria no espaço local
e mundial Isso significa que estou girando
com base nas coordenadas e no
sistema cartesiano do Baseado
no eixo XY Z
do mapa e nos locais em que
podemos ver tudo. Portanto, a localização e a rotação seriam relativas às
coordenadas desse sistema. Mas o que vamos fazer é girar essa parte, que eu realmente coloquei na
seta Agora, certifique-se de que essas
coisas não são parentais
e, se isso acontecer, elas não têm
uma seta aqui,
basta arrastá-la e
soltá-la na raiz Nós o anexamos.
Não criamos uma nova raiz. Então, tudo é uma
entidade por si só. Por exemplo, se eu
colocar a flecha na porta e mover
a porta
, estou movendo
a seta com ela. Se eu separá-lo, você também
pode fazer isso. se algo estiver preso, Por exemplo, se algo estiver preso,
se você arrastar e soltar
sobre si mesmo, ele se soltará. Então, agora, se eu mover a porta, a seta, como você pode
ver, permanece lá. Agora, vou
mover essa porta em um local relativo, rotação
relativa. Diferente da rotação do
ator definido. Como você pode ver, quando
eu movo o ator aqui, o ponto pivô era o centro,
o centro do Já eu quero mover
a porta com base em seu próprio ponto de articulação
na rotação relativa
na planta Mas acho que estou divagando. Acho que devemos vê-lo em ação, e deixaríamos
este para o próximo curso, a próxima lição. Então, eu
vou te ver então. Adeus.
10. Trabalho de base para a interação do jogador com portas: Bem-vindo de volta aos portais
Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, concluímos nossa
configuração para nosso texto de fluxo de BP, adicionamos um código de que, se o outro ator sobreposto tiver um componente
que tenha a tag P, que é o que está sobreposto
, , Para fazer isso, adicionamos uma tag ao nosso componente de
cápsula de personagem. Então, na terceira pessoa,
o modelo do personagem em terceira pessoa da BP BP. No componente da cápsula,
procuramos por tag. E adicionei a tag
P. Outro lugar onde as tags poderiam ser adicionadas que
discutimos é também o ator. Não demonstramos isso, mas se usarmos os padrões de classe
e pesquisarmos novamente por tag, podemos descobrir que o ator
tem sua própria guia para tags, onde podemos ver também as
tags de outros componentes Então, vamos fechar isso. Em seguida,
configuramos o texto de fluxo da BP
para a próxima sala e começamos a
criar a nova porta,
que é a porta unidirecional da BP Então, neste projeto, deixamos um pouco de
deslocamento na rotação Eu posso ver. Isso deve ser zero. Não menos zero, mas zero. Mudamos um
pouco a localização porque o Pivot está
um pouco deslocado e explicamos que
vamos mover
a porta com base no
distema cartesiano desse modelo,
que é o espaço
relativo local e não o porque o Pivot está
um pouco deslocado
e explicamos que
vamos mover
a porta com base no
distema cartesiano desse modelo,
que é o espaço
relativo local e não o sistema cartesiano mundial. Então,
rotação e escala da localização mundial. Sim, essa é uma diferença muito
grande. A localização mundial e
a localização relativa, a rotação mundial e
a rotação relativa. É claro que é muito
importante distinguir
entre elas porque, por exemplo, se estivéssemos girando,
digamos, corretamente, a porta na palavra localização, digamos que ela estivesse girada
corretamente, por exemplo,
poderíamos mover a Dessa forma, ele gira
com o ator corretamente e se abre assim
usando a rotação mundial Bem, isso significaria que essa porta se
abriria somente dessa maneira. Se eu quisesse fazer dessa maneira
, ainda não funcionaria. Não funcionaria assim. Subiria até a
rotação mundial que definimos. Portanto, é importante
distinguir isso. Então, vamos voltar aqui. Vamos configurar isso para ficar em
algum lugar no meio. Está tudo bem. Agora, o que vamos fazer para
animar essa loja Vamos ver
nosso mapa tutorial. Vamos roubar a linha
do tempo daqui. Vamos copiá-lo e,
na verdade, apenas uma linha do tempo, e vamos
acessar nosso gráfico e colá-lo aqui Como copiamos e colamos, nossos valores
estão
dentro de 0-0 0,5 0-1 Então esse é o nosso drive Alpha. Agora, para fazer a
localização relativa em comparação com o mundo, e é por isso que eu
não copiei isso, que é definir a rotação do ator, e estamos colocando um alvo como esse ator e
dando uma nova rotação, precisamos pegar nossa porta,
que é apoiar a porta traseira um,
e definir a rotação relativa É um nó muito semelhante. Como você pode ver, ele
também se teletransportou,
pois este tem apenas teletransporte , mas isso significa que está varrendo se não
estiver se teletransportando E vamos
conectar isso aqui. No caso anterior, passamos por um rotador Mas, neste caso, eu
quero clicar com o botão direito aqui
e dividir o rotador, e eu vou
simplesmente flutuar. Então eu vou
larp aqui a partir de 02, acho que vamos até a porta Vamos girá-lo.
Acho que é -90 Abre para dentro -90. Ok. Poderíamos ter visto
a flecha aqui também. Tão original, então de
zero a -90 de A a B. Agora, como chamamos isso? Na outra planta, usamos apenas a
colisão aqui, e chamamos a porta aberta Então, novamente, poderíamos ter
usado a colisão. Vamos trazer uma caixa novamente para que possamos fazer com que até mesmo a
colisão comece a se sobrepor E poderíamos simplesmente dizer
que quando o personagem tem P., então colocamos
um galho novamente. A maneira como eu trouxe
o galho tão rápido foi selecionar B e clicar. Isso traz um galho. Então, se for verdade, então jogue. E então temos uma porta de
colisão novamente. Mas quando colidimos com
ele, ele deve se abrir. Nós não queremos fazer isso.
Queremos pressionar E. Então, como não criaremos um sistema completo de entradas para alterar vínculos para adicionar
vínculos e tudo mais, usaremos apenas
E para abrir portas, o que podemos fazer é usar o controlador
do Então, eu vou comprar o controlador
do player. Vou explicar em um segundo e habilitar a entrada do controlador
do player. O alvo deve ser próprio e o controlador do jogador deve
estar no controlador do jogador. Agora, a maneira como eu movo isso é
pressionando troll e apenas arrastando e soltando
onde Se eu pressionar Alt e clicar,
ele o desconectará. Se eu tiver algo
conectado ao controle, posso conectá-lo em outro lugar. Agora, o que é um controlador de player e o que está ativando a entrada? Um controle de jogador no
Unreal Engine é uma parte do jogo que processa as entradas
do jogador, como ações
do controlador do teclado, e as
traduz em comandos para
o personagem do jogador ou qualquer outro objeto no jogo Ele atua como um elo entre o jogador e a palavra do
jogo, basicamente. Normalmente, o controlador só
obteria entradas diretas, mas podemos habilitar a entrada de outros atores para permitir que eles
reajam a ações específicas Por exemplo, aqui,
vamos esperar que a ação E abra a porta. Então, para conseguir isso, vamos usar nossa
colisão aqui Vou me desconectar
pressionando e clicando nessas coisas Na verdade, eu preciso disso, então vou cortar e colar. E eu vou
conectar isso aqui. Então, se nosso jogador
colidiu com um cubo, habilitaremos a
entrada aqui, Ops, error Isso deveria estar aqui. O alvo deve ser eu mesmo. habilitando a entrada desse ator nesta porta e o controlador do
player é o controlador do player. Mas quando saímos dessa caixa, queremos não habilitar a entrada
para, basicamente, desativá-la. Então, vou selecionar a caixa. Vou clicar na sobreposição final do componente. Clique rapidamente. Vou copiar e colar isso.
Vou conectar isso aqui. E vou copiar e
colar o controlador também e chamar a entrada de desativação. Vou definir o alvo para si mesmo e conectar o controlador do
player. Então, agora, como
ativamos E quando pressionamos
E? Bem, isso é fácil. Se eu clicar e digitar o teclado, podemos ver
que existem basicamente
todos os botões do teclado, e se eu chamar E, vamos encontrar E. Aqui está. Eu o chamo de, ele cria
um evento por si só. Então, como habilitamos a entrada, isso fará alguma coisa. Demonstre isso por um segundo. Vamos colocar uma sequência de caracteres impressos aqui. Diz olá. Então, eu
vou jogar no mapa. Se eu estiver pressionando E
agora, não faz nada. Se eu chegar perto
da porta e entrar nessa colisão e
pressionar E, ela diz olá Se eu sair, não fará
nada novamente. Portanto, isso só
funciona enquanto a entrada está ativada. Agora, se tivéssemos outras
execuções com E, temos a vinculação
primária de substituição, que substituirá tudo o que o
EE estiver fazendo em outras coisas e consumirá também a entrada Também existem modificadores, como se você quiser ter
shift e E ao mesmo tempo, qualquer forma, há muito sobre isso Mas isso é basicamente
um nó de entrada. Para animar nossa porta, poderíamos simplesmente
conectá-la diretamente aqui Mas então só
conseguiríamos abrir nossa porta. Se eu for assim e pressionar E, só
consigo abri-lo.
Não consigo fechá-lo. Mas acho que esse é um bom ponto de
parada para este. Eu vou
te ver na próxima. Adeus.
11. Codificando o sistema de porta de interação com o jogador: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente,
conversamos um pouco sobre as rotações relativas
e finalizamos nossa linha do tempo e definimos a rotação
relativa
usando uma volta em um flutuador porque o X e o
Y não mudarão. Somente o eixo Z, o
eixo Yo, aprenderá de zero a -90 a definir a rotação
relativa E sempre
estará nessa rotação. Então, temos a seta para
nos dizer onde está a frente e para
onde a porta
se abrirá. Se quiséssemos
abri-lo dessa maneira, a única coisa que
precisaríamos fazer
seria mudar isso de -90 para 90, e ele abriria
em 90 graus A próxima coisa que fizemos foi
ativar a entrada com o controlador do player
por meio desse modelo e desativá-la quando começamos e terminamos se sobrepondo quando nosso
player começa e termina sobrepõem usando a etiqueta do componente P. Em seguida, demonstramos
um nó de entrada, o botão E, que quando
pressionamos enquanto estamos
no tubo de colisão, ele funciona e Vamos continuar fazendo com que a porta possa
abrir e fechar. Em algumas aulas atrás, falamos um pouco
sobre enumerações, que existem listas predefinidas
que elas não podem ser
alteradas Vamos criar um desses porque o
que mostramos
já existe no motor da Unreal e é sobre direção Poderíamos usar isso, mas
vamos torná-lo um
pouco mais avançado para
alguns outros usuários também. Vamos clicar
e ir para o Blueprint e, a partir do Blueprint, vamos
escolher a Agora vamos chamar
isso de estado de porta E, e eu vou abri-la. Aqui, temos o botão
que adiciona enumeradores. Como dissemos, é
basicamente uma lista
e, como você pode notar, ela as nomeia de forma diferente
porque não pode ter o dobro do mesmo enumerador Se eu virar isso para zero,
aparecerá um erro. Numerador zero, o novo enumerador
zero já está em uso. Vamos abrir. Fechar. Abrindo. Na verdade,
um P e fechamentos. Agora, eu vou salvar e
vou fechar isso. Agora, eu tenho essa lista aqui, mas como faço para trazer
a planta Eu não posso simplesmente arrastá-lo e
soltá-lo? Ele não pode criar um aceno a partir desse tipo de ativo Então, para fazer isso, vou até
nosso stub de variável e vou pressionar o
botão de adição aqui para criar uma nova variável e ir
para o tipo de variável
aqui e pesquisar o estado E D. Eu gostaria de estar digitando e aqui está na categoria Enumerações
IAM, é nossa enumeração Dor state Vou clicar aqui
e
nomear a variável também como estado da porta. A maneira como fiz isso foi
clicando aqui ou você sempre pode pressionar F dois
e ele irá para Renomear Vamos trazer isso aqui
e explorar um novo nó. Esse nó é o nó do switch. Como dissemos anteriormente, o nó do switch precisa estar conectado a uma enumeração
específica, a chave na
enumeração, basicamente,
porque existem opções
baseadas em números inteiros, por exemplo,
com base em o nó do switch precisa estar
conectado a uma enumeração
específica,
a chave na
enumeração, basicamente,
porque existem opções
baseadas em números inteiros, por exemplo,
com base em muitas coisas. Se digitarmos switch on, você verá que tudo com E é
uma enumeração Muitas coisas do Niágara, mas há muitas
variáveis para ativar O mais utilizável é, na verdade,
o switch on string. Assim, podemos personalizar nossos estojos. Uma caixa semelhante poderia estar aberta. Como se pudéssemos
tê-lo com cordas e pudéssemos tê-lo aberto E então isso dependeria do que está chegando de uma string Novamente, uma string é um
tipo de variável que pode aceitar bem, basicamente texto, qualquer texto. Isso pode ser um número, pode
haver uma letra, pode
haver um símbolo,
qualquer coisa que seja um texto. Também existe uma variável de texto, mas ela foi projetada para um tipo
diferente de uso, mais para localizar conteúdo Ele é otimizado para exibir diferentes tipos de textos
se eles precisarem de tradução e formatação para
diferentes idiomas Mas para nós agora, isso é apenas um exemplo porque vamos
usar uma enumeração Então, ao pressionar E, quero que isso faça algo diferente com base no
estado da porta. Agora, precisamos definir um
valor padrão para isso. Estado. O primeiro valor que temos
em nossa enumeração é aberto, o que não queremos Queremos que seja fechado. Então, vou dizer isso para
fechar e compilar novamente. Portanto, o estado padrão
quando pressionado é fechado. Então, quando a porta estiver fechada, vamos jogar desde o início. Quando a porta estiver aberta,
vamos reverter a partir do final. Enquanto jogamos, poderíamos realmente mudar o
estado aqui e dizer que quando pudéssemos
conectá-lo aqui e depois aqui, eu vou
duplicar isso e conectá-lo
aqui e aqui, e isso fecharia
e isso abriria Então, quando pressionamos E, se estamos no estado aberto, estamos fechando a porta e invertendo
a animação Se estivermos de perto, estamos abrindo a porta e reproduzindo a
animação corretamente. Mas eu quero demonstrar
o nó do once. Então, como dissemos, essa atualização da
linha do tempo é executada constantemente Isso significa que isso executa
todos os quadros, basicamente. cada quadro, ele executa o que sai
desse final de execução. Se eu fizer uma vez aqui, significa que ele
fará essa execução
e, uma vez atingido esse ponto, ele simplesmente parará aqui
depois de ter feito isso uma vez. Para fazer isso de novo, precisaríamos reiniciar. E se eu clicar neste botão
Iniciar Fechar aqui, isso significa que ele precisaria ser
reiniciado antes de fazer isso uma vez, o que quer que tenhamos
aqui e concluímos. Então, isso significa que se, por exemplo, quisermos
mudar, deixe-me cortar isso. Abrir vai reverter a partir do final e fechar vai
jogar desde o início. Então, está abrindo
e fechando. Sim. Agora, vou
colar isso aqui. Se eu quisesse alterar isso
durante a execução da linha do tempo, precisaria fazer isso uma vez e precisaria redefini-la
quando a linha do tempo terminasse Então, vou colocar o nó de
leitura aqui. Vou colocar um nó de leitura também aqui e vou
conectá-lo aqui Agora, posso usar essa
enumeração em vez
desta para determinar
onde a porta está se fechando Então, vou
mudar uma linha do tempo. E se for para frente, significa que estamos
abrindo a porta. Se estiver ao contrário,
significa que estamos fechando a porta. E isso seria executado uma vez
e, quando a linha do tempo
terminar, ela será reiniciada, então você pode
fazer isso novamente na próxima vez Vamos testar isso.
Vamos jogar. Estamos nos aproximando da
porta. Estamos nos mudando para cá. Pressione para abrir,
pressione para fechar e nada acontecerá. E o motivo é bem
simples porque, no final, não especificamos se abrimos
ou fechamos. Então, o que eu vou
fazer é ir para um nó de sequência. Agora, o que é um nó de sequência? Parece que fará algumas coisas em uma
ordem, o que acontecerá, mas isso não significa que
esperará que uma linha
termine e depois passará para a próxima. Ele executará todos os
pinos simultaneamente em uma ordem, mas eles
dispararão quase simultaneamente Tipo, se eu tivesse uma
string impressa aqui que diz olá. E eu tinha uma
corda estampada aqui também. Isso diz, na verdade,
vamos numerar. Um, dois. Vamos mover isso um
pouco mais alto. Vou colocar um atraso aqui. E eu vou colocar
outra corda aqui. Digamos que isso é três
e isso seria quatro. Então, o que devemos ver aqui seria um,
dois, três, quatro. Mas o que acontecerá é que
veremos um, dois, quatro, três porque os três
têm um pequeno atraso aqui. Vamos fazer isso em 1 segundo. Na verdade, 0,2 foi predefinido não ter
um número exato, mas imagine se um quadro levar
16 milissegundos para renderizar e fizer todos
os cálculos do jogo Imagine a rapidez com que
cada nó é executado. Portanto, 0,2 é tempo suficiente. Vamos testá-lo. Vamos apertar play, e eu preciso ir até a
porta para testá-lo. Você vê um, dois, quatro, três. Você pode vê-lo novamente no registro, um, dois, quatro, três. Isso nos diz que
isso não espera uma execução
termine para executar a próxima, depois uma, depois duas, depois três. Vou deletar tudo isso porque não é realmente necessário. E vou remover alguns pinos de execução.
Só precisamos de dois. E vamos conectar
este ao reset, e vamos duplicar essa
funcionalidade aqui Vamos também conectar
a direção
ao interruptor e mudar para frente, ele estará aberto, e para trás, ele
estará próximo Então, agora devemos ser capazes de
ver a porta aberta e fechada. Sim. No entanto,
falta alguma coisa. Um jogador deve ser informado que pode abrir
e fechar a porta. E, para ser sincero, estamos muito perto da porta
para começar a abrir. Como se a colisão fosse
muito pequena. Então, quando estou aqui, isso acontece. Então eu acho que essas duas coisas
vão acontecer na próxima lição, e eu vou ver
você então. Adeus
12. Projetando um widget de UI simples no Unreal Engine: Olá, e bem-vindo de volta ao Unreal Engine, cinco sistemas de portas Blueprint Mastery e Anteriormente, terminamos com a abertura e o
fechamento da porta. Criamos um estado. Então, quando pressionamos E, alternamos com base no estado
da porta usando essa
enumeração E do estado da porta,
que abrimos, fechamos fechamos E quando a porta está fechada, ela inverte a linha do tempo
ou, quando está aberta, reproduz desde o início Demonstramos ao Once Node
que, enquanto isso está em execução,
estamos executando essa
ação uma vez e redefinimos quando
a linha do tempo termina
e, quando a linha do tempo termina,
estamos definindo o
estado da porta como aberta
ou estamos definindo o
estado da porta como aberta Dissemos que a caixa de colisão aqui é um pouco pequena Agora, em vez de
mudar para todas as portas, vou até
aqui e
vou selecionar essa caixa, e vou
estendê-la um pouco mais. Isso parece bom. Talvez um pouco mais porque eu não quero que isso seja demais, porque
se for demais, o jogador poderá
abrir a porta a uma
distância maior do que a desejada. Poderíamos ter outros
mecânicos verificando isso,
mas, por enquanto, isso bastará Portanto, uma mecânica mais complexa
incluiria traços de linha e verificadores
de distância de pontos específicos Vamos considerar isso corrigido. A próxima coisa que devemos
fazer é
saber ao jogador que você
está ao alcance e abrir
ou fechar a porta. Então, o que vamos usar é um widget. Vamos criar
um widget de planta que adicionaremos
à nossa janela de visualização
e, quando o player
estiver perto de uma porta, ele dirá aberta ou fechada de
acordo com o Então, vamos começar
criando uma nova pasta
na pasta de conteúdo
que chamaremos de UI. E eu vou
codificá-lo por cores para um azul claro. Ótimo. Agora, aqui dentro,
vou clicar, não
vou
acessar os projetos
porque não há nenhum plano de
interface Em uma categoria diferente, uma categoria exclusiva
chamada interface de usuário, qual podemos ver fonte, ardósia, pincel e outras coisas Mas o que queremos é
um modelo de widget. Assim como nos outros projetos, há muitas classes que podemos predefinir e escolher Mas o que queremos é
o widget do usuário. Vamos clicar nisso
e chamá-lo WG por W JD,
acho que é por isso E eu vou abri-lo. Agora, instantaneamente, podemos ver que essa não é uma interface de
projeto comum Isso é algo diferente. Bem, não exatamente, porque
estamos na aba de designers. Por aqui, há uma guia gráfica, que é
mais familiar do que quando comparada
ao designer. No entanto, temos uma diferença de eventos. Temos que pré-construir e
construir em vez de começar a jogar. exemplo, se formos aqui,
começamos a jogar e o ator do evento começar a se sobrepor
e o tique é o mesmo Agora, a pré-construção é como o script
de construção É como executar isso, mas não exatamente também. Muitos detalhes, eu acho. Vamos nos concentrar na guia do
designer por enquanto e passaremos para
o código um pouco mais tarde. Então, o que estamos vendo aqui? Aqui, estamos vendo basicamente
uma representação visual das resoluções e da aparência do nosso
widget nelas Ele não se encaixa no
momento porque
não temos nada no widget A segunda coisa que vemos é o esboço de
detalhes e uma paleta. Uma paleta tem alguns
elementos de interface do usuário, como uma borda, como um botão, como uma caixa de seleção Esses são os mais
comuns, controles deslizantes de texto. Ele também tem alguns recursos mais avançados, como
inserir caixas de texto, caixas de
combinação, listas e formas de
realmente configurar o Uma delas é a tela. O que é uma tela? Resumindo, ele nos permite definir uma localização e uma escala na janela de visualização no tamanho da
tela que desejamos Isso não significa que deva necessariamente ocupar
a tela inteira. Pode ser uma tela que
seja um widget menor, mas é uma referência
baseada no espaço Digamos, por exemplo, que
se eu trouxer um botão aqui, eu possa dizer onde ele está
e quão grande ele é. Por outro lado, se eu não tivesse a tela e
trouxesse apenas um botão
, não haveria nenhum ponto de
referência para ela. Isso é apenas uma resolução para desfazer. Vou deletar o botão. Basicamente, isso é
o que é uma tela. Tem muito mais detalhes
e características,
mas, em poucas palavras, é isso
que é Para o nosso caso, usaremos algo muito simples
além da tela. Não usaremos
botões nem nada. Vamos usar apenas algum texto. E para fazer com que esse texto
tenha uma certa forma, usaremos uma caixa horizontal porque queremos colocar
dois elementos de texto, um que poderia ser o
botão a ser pressionado e outro que seria o texto
que diz abrir ou fechar. Portanto, mesmo separá-los ajuda se quisermos mudar
o botão e, claro, alterar o texto fechar ou
abrir, em vez de termos que
digitar toda vez que
digitar abrir, fechar. Agora só precisamos
digitar abrir ou fechar. Pequena diferença, mas
em uma escala maior
, faria a diferença. Agora que tenho
a caixa horizontal e quero
ancorá-la em um determinado lugar, tenho isso como uma flor aqui
que diz ao motor tente colocá-la em algum lugar aqui As âncoras têm muito, muito mais
funcionalidades, como se eu pudesse
colocar a âncora no meio e depois deslocar a caixa
que está localizada no Existe o tamanho da
caixa, como quisermos. No momento, não nos
preocuparemos com essas coisas. Vamos fazer com
que pareça meio que ok. Ou seja, vamos tornar a resolução
um pouco mais correta, porque eu a deixei em resolução aleatória que nem sempre
é muito válida. Então, eu vou colocá-lo aqui. É a resolução. Acho que se você considerar que o jogador
está em algum lugar aqui, acho que se ele aparecer talvez mais à esquerda, no
centro, na direção. Sim, acho que esse
lugar é bom. E eu vou
mover essa âncora. Vou quebrar a
âncora também em cantos e colocá-la
aqui. Sim, tudo bem. Isso é bom. Onde
deve aparecer o abrir ou fechar e o
botão que usamos. Temos nossa caixa horizontal e precisamos colocar
alguns elementos nela. Vou escolher um texto. Vou adicioná-lo
à caixa horizontal e vou
adicionar outro. O primeiro texto seria fácil. Eu diria apenas E. O segundo texto, na verdade, vamos colocar também esse símbolo aqui e um espaço e
um espaço antes do símbolo. Sim, fica melhor
com esse símbolo. Agora, a próxima coisa, deveria dizer abrir ou fechar. Então, digamos que abra e feche. Parece estar bem. Não
podemos deixar como está, mas vamos brincar um pouco
com isso. Digamos que eu
queira estar um
pouco mais à esquerda. O que vamos
fazer em vez de alterar os tamanhos para preenchimento alinhamentos horizontais
e tudo mais, vamos
descer até aqui, que é a transformação de renderização,
e movê-la um
pouco para a esquerda, 20,
20 parece bom, talvez 15 renderize Essa é a opção,
e isso a move um pouco para a esquerda
ou para a direita, para cima e para baixo. Você pode escalá-lo,
selá-lo, incliná-lo. Na verdade, isso
distorce tudo porque eu não escolhi isso. Isso precisa mudar 15. Sim, acho que está tudo bem. Vamos ver isso em ação. Vamos realmente
adicioná-lo ao nosso painel de exibição. Vou compilar e salvar
e vamos ver nosso widget. A pergunta que surge é como faço para trazer um
widget, é claro, para o meu visor, que contém
apenas algumas notas e está lá A outra pergunta
que surge é onde coloco esse código? Onde eu uso um código que
coloca um widget em ação? Bem, poderíamos
colocá-lo na porta. Isso significa que cada porta
precisa criar um widget. Não é um comportamento muito ideal. Eu poderia colocá-lo
no plano de nível. Isso significa que esse widget
existiria nesse nível e seria
criado somente aqui Mas vamos ter
um nível para o qual estamos
fazendo a transição,
e precisamos que esse widget mantenha lá,
sendo Então, eu poderia usar a instância do jogo, que funciona em todo
o jogo. Mas se eu tivesse menus principais, se tivesse outros níveis em que
não usaria esse widget, isso significa que
esse widget
estaria sempre na instância Portanto, o denominador comum que posso usar entre
dois níveis
agora com o que estamos lidando
seria o modo de jogo, porque esse nível usará
esse modo de jogo,
o nível de transição
usará esse modo de jogo Então, colocar o código aqui
agora para este exemplo
faz sentido. Então, vou navegar até o nosso modo de jogo
a partir das configurações mundiais.
É a terceira pessoa. Nós poderíamos encontrá-lo aqui também. Então, em terceira
pessoa, plantas, modo de jogo em
terceira pessoa,
se abrir assim, não
é um problema Isso é basicamente o padrão do plano do modo de
jogo. Se formos até,
digamos, por exemplo, nossa porta e acessarmos
nossos padrões de classe, podemos ver esses detalhes aqui Então, como não
abrimos o esquema, este é um modelo somente de dados Não fizemos mais
nada com isso. Ele mostra somente os valores
padrão. Podemos clicar aqui, abrir o Blueprint
Editor completo e, hoje, podemos ver o
script de construção, a janela de visualização, que no modo de jogo tem usos
muito específicos e com os quais
não nos preocuparemos E o que precisamos é
do gráfico de eventos. E o que faremos é
chamado de evento start play, que acontece quando
o jogo começa, e vamos
criar um widget Agora, para a classe,
selecionaremos a porta do widget
e, para o jogador proprietário, obteremos o controlador do
jogador Poderíamos ter widgets diferentes que pertencessem a um policial local, por exemplo, e seu proprietário mudaria com
base no índice de jogadores Se eu deixar como e, não
conseguiremos
ver o widget porque acabamos de criá-lo Acabamos de criar uma
variável com isso. Em nossa opinião, não foi
invocado. Para fazer isso, precisamos adicionar ao viewpot para que
nosso widget apareça Então, vou compilar e salvar acessar o
Bloqueio do Tutorial e pressionar Play E aqui podemos ver nosso widget. Basicamente, o que estamos
verificando é se está em uma boa posição quando queremos
abrir e fechar a porta. Acho que se aparecer
ali mesmo, tudo bem. Você pode colocá-lo
em qualquer outro lugar que desejar. E eu acho que é
isso para este. Nos vemos na próxima vez em que
implementaremos
a mecânica para
mostrar e ocultar o widget Adeus.
13. Programando a visibilidade do widget de UI com base nas ações do jogador: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, acabamos finalizando a
parte de design do nosso widget, que eu fechei Então não, eu não tenho aqui isso. Criamos um modelo de widget. Nós o chamamos de WG Door. Adicionamos um painel de tela
à nossa hierarquia. Bem, esse é um ponto
que eu não expliquei bem. Aqui, temos
a hierarquia, que nos mostra quais elementos
estão dentro do widget É como a
guia de componentes em plantas,
mas para widgets, e a hierarquia aqui
nos diz qual widget é o primeiro, o
segundo, o que pertence Além disso, não expliquei
muito sobre a caixa horizontal. Acho que é meio
autoexplicativo. Ele permite que os widgets sejam
dispostos horizontalmente. Se passarmos o mouse sobre permite que widget seja disposto
em um fluxo horizontalmente, se cobrirmos alguma coisa,
se selecionarmos alguma coisa
e passarmos o mouse sobre ela,
ele nos dará uma dica de ferramenta sobre isso Vá lá, faça a coisa. Eu simplesmente não quero. Então, sim, basicamente,
na paleta, é mais fácil ver
as dicas de ferramentas aqui Tem que estar no próprio ícone. Nós criamos o widget. Nós a adicionamos à nossa
janela de visualização por meio de
criamos e a adicionamos à visualização por meio
do modo Quando o evento começou a ser reproduzido, criamos o widget e o adicionamos
ao viewpod Agora, nós o hospedamos no modo de jogo porque ele será
compartilhado entre os níveis e queremos que esse widget
exista em todos os níveis Mas não queremos adicionar o widget
na janela de exibição
quando o jogo Queremos adicioná-lo à
janela de visualização quando o chamamos. O que faremos é promover
isso para uma variável, que é nossa referência de widget Quando estamos criando, estamos
recebendo um valor de retorno, que é uma referência
ao que criamos. E vou chamar
isso de wg dot Rep. Como você pode ver, o tema
com as referências é um pouco importante
na programação Chamando referências, tendo maneiras referenciar algo
como tínhamos
no esquema de nível em que
estávamos referenciando as caixas de acionamento quando
temos a referência
ao outro componente, que perguntamos se ele tem uma tag Referências são uma coisa. As referências são o
Alpha e o Omega, se preferir, da programação
orientada a objetos Agora, armazenamos uma
referência do widget. Então, vamos
criar um evento personalizado. Vou chamar isso de widget. Vou conectá-lo
à janela de exibição externa e vou trazer
a referência até
aqui e
conectá-la ao alvo Porque se
saíssemos da janela de visualização, isso provavelmente provocaria
um erro ou não faria nada
porque não haveria alvo
porque o alvo em si
significa um modo de jogo Não é um widget, então
não pode ser adicionado à janela de visualização. Mas a referência do widget no Cam foi adicionada à janela de visualização e
isso funcionará corretamente Agora, a próxima coisa que
fazemos é criar outro evento personalizado e
chamar esse widget de remoção de pontos Vou arrastar um cabo da referência
do widget e
dizer remover do pai É assim que estamos removendo widgets da janela de visualização,
uma das Então, vamos utilizar
essas duas funções. Vamos até nossa porta de sentido único. Vamos ao gráfico de eventos. Vamos para a nossa colisão. Então, quando estamos colidindo
e começamos a se sobrepor, devemos mostrar nosso Para chamar isso, preciso ter
acesso ao modo de jogo, então preciso de uma referência
ao modo de jogo. Felizmente, o Unreal Engine tem uma boa maneira de obter o É chamado de modo de jogo G. Mas isso retorna
um valor genérico. Temos um modo de jogo específico. Temos o modo de jogo em terceira
pessoa, ou temos o modo de jogo doors ou podemos ter qualquer
tipo de modo de jogo. Isso retorna somente um modo de jogo
genérico, referência de
objeto baseada no modo de
jogo. Para verificar se é nosso modo de jogo, precisaremos lançar. Então, vamos lançar um jogo em
terceira pessoa. Como dissemos, o elenco está
perguntando algo: Você é essa coisa, basicamente, esse objeto
é esse
tipo de objeto? Então, vou converter
para um molde puro, que apenas remove
o pino de execução e torna tudo um
pouco mais fácil. Se tivermos sucesso e nosso
modo de jogo for o modo de jogo porque o sucesso é como
quando era um lançamento impuro, era como lançar uma
falha, lançar com sucesso Agora temos um BollOnt que
nos diz se foi bem-sucedido ou não. Então, se tivermos sucesso, poderemos obter
algumas informações Podemos obter algumas funções e eventos do modo de jogo em terceira
pessoa. O evento que queremos
agora é adicionar o widget. aqui, posso simplesmente
arrastar outro cabo e dizer, remova o widget de pontos e
conecte-o aqui Vou compilar e
salvar e vamos testá-lo. Vou até a primeira porta, ela se abre, segunda porta, temos um widget e
ele está sendo removido Agradável. Mas o fato é que
nosso widget não corresponde ao que
deveria estar dizendo exemplo, agora, deveria estar
dizendo aberto e agora, deveria estar dizendo fechado, o que é correto, mas está apenas 50% correto.
Nem sempre está correto. Então, vamos corrigir isso. E para fazer isso,
vamos
para o nosso modo de jogo em terceira pessoa e vamos
criar uma função. Então, o que é uma função? Basicamente, é um conjunto
de ações ou lógica, se você quiser, que é reutilizável Ele pode ser usado várias
vezes e pode ser chamado simultaneamente
várias vezes, além de executar
tarefas específicas todas as vezes. Como um evento, se
for chamado novamente, eles normalmente são
você a nova chamada, enquanto as funções simplesmente
serão executadas novamente. Um exemplo disso
praticamente
seriam várias colisões sobrepostas,
como, por exemplo,
muitas balas atingirem você no mesmo
fragmento Isso será indicado em ordem, qual deles acertou primeiro e
qual deles será o segundo, etc. Se fossem funções, todas seriam
executadas imediatamente Eles serão empilhados e executados
imediatamente. Então, basicamente, poderíamos
ter criado um evento, mas para esse cenário, criamos uma função. Agora, outra coisa sobre
funções é que, claro, elas têm entradas, como
podemos ver em seus detalhes, mas também podem ter saídas Por exemplo, se eu
quisesse
saber se foi bem-sucedido ou não, eu poderia ter uma saída de um
Bollian e, como você pode ver, ele criaria um nó de retorno E esse booleano pode
ser verdadeiro ou falso, por exemplo, se algo que eu
não ouvi for bem-sucedido ou Vou excluir isso
e vou excluir
a nota de devolução porque não
precisamos dela. Vamos compilar e salvar talvez mais um detalhe sobre as funções e
pronto Funciona, eles não podem ter coisas
temporais dentro deles. Eles podem ligar
externamente para coisas temporais, mas não podem se
atrasar aqui Não podemos ter um cronograma aqui, não
podemos ter cronômetros Portanto, o tempo é algo que
não pode estar em uma função. Agora, nossa função,
o que devemos fazer? Vamos chamar isso de
atualização, widget, texto. E precisaremos de uma
nova entrada do tipo string. Vou ligar para
ele com jet text. Agora, o que isso fará, obteremos nossa referência do
Widget D. Vou trazê-lo aqui,
e vou receber uma mensagem de texto. Na verdade,
vamos ao nosso widget. Vamos até nosso designer. Agora, queremos mudar
esse texto aqui, o texto que diz fechar. Se virmos isso em cima
dos detalhes, há um nome que
podemos colocar ou podemos realmente colocá-lo aqui, mas eu vou
escolher estar aqui. Vamos chamar esse widget de
texto. Texto do meu widget Agora, ao lado dele, há um botão
chamado É variável. Se não for clicado, isso significa
que é estático Ele não pode ser modificado,
mas se eu clicar em uma variável, ele pode ser modificado por meio de código. Há muitos motivos para isso aconteça nos
bastidores, mas não vamos entrar em
muitos detalhes. Vamos para o nosso modo de jogo novamente, não para o gráfico de eventos em nosso modo de jogo na
função Widget update, e vamos
receber o texto do meu widget E a partir daqui, vou
definir o texto como fizemos com renderizações de texto
no texto de fluxo
do BP Vou conectar isso a, isso é um texto. Podemos transformar essa
string em um texto. E pode se conectar diretamente. Se eu deixasse a corda
, não importaria. Eu o
traduziria automaticamente para uma sequência de texto. Mas por que não deixar essa parte
um pouco mais clara Vou
simplesmente alterá-la para texto e conectá-la aqui. Então, temos uma função
que muda nosso texto. Preciso compilar o widget porque transformamos esses
dois Precisava ser
compilado, também está salvo e
agora está tudo bem. Eu acho que esse é um
bom ponto de parada. Continuaremos
na próxima
implementando essa nova função. Adeus por enquanto.
14. Atualizando widgets de UI com entradas de blueprint externas: Olá, bem-vindo de
volta aos sistemas de portas Unreal
NGINfb Blueprint
Mastery e portais interativos. Anteriormente, adicionamos
a funcionalidade adicionar o widget da porta
ou remover o widget da porta com
base no fato de estarmos colidindo
com a colisão da Para fazer isso, criamos
dois eventos personalizados,
usamos o at viewpod e os removemos do pai
e os conectamos à referência
do widget que armazenamos
no início da reprodução Em seguida, fomos até nossa porta unidirecional
BP
e, no início e no final dos eventos de
sobreposição da colisão, adicionamos o widget ador e dos eventos de
sobreposição da colisão, adicionamos o removemos a Ao obter o modo de jogo e para o nosso modo de jogo em terceira
pessoa. Em seguida, criamos uma função no modo de jogo em terceira pessoa, que chamamos de
atualização de texto do widget Agora, essa função tinha
uma entrada de texto do Widget
e define o texto por meio da referência
do Door Widget,
e obtivemos o
texto do meu Widget a partir dele por meio da referência
do Door Widget,
e obtivemos o texto do meu Widget Agora, vamos continuar criando o sistema que
atualizará o texto do widget Para fazer isso, vamos até nossa
porta unidirecional e criar outra função
que chamaremos novamente de widget de atualização. Texto. Nesta função,
obteremos nosso modo de jogo, e podemos fazer o modo de jogo e o
modo de jogo,
e podemos lançar dois modos de jogo em terceira pessoa e
converter para puro. Mas o que podemos fazer, já que o usamos com tanta frequência
neste projeto, começar nosso jogo inicial Podemos copiar esse código daqui. Na verdade, vou
cortar esse código daqui, começar a
jogar e colar aqui. Vou conectá-lo como
um nó de fundição desta vez. E eu vou promover
isso para uma variável. E como você pode
ver, Area
já o chamou de
Game Old em terceira pessoa da BP, muito conveniente Vou compilar e
diz que não é possível compilar porque o destino dessas duas funções
foi Isso é o que eu quis dizer antes. Além
disso , o alvo se refere a quem
deve fazer isso. E eu, no momento, não tem uma função de
widget ador Mesmo que isso acontecesse,
o alvo predeterminado
dessa função seria o alvo da
PA em terceira pessoa Portanto, mesmo que eu crie um evento
personalizado, adicione o jato. Você pode ver que
ainda haverá um erro porque o alvo é P. Chamamos
isso do modo de jogo. Para que o erro desapareça, vamos apenas trazer nossa referência
de nossas variáveis
aqui e vamos
conectar isso aqui e
conectar isso aqui. E acho que essa
variável de string não é usada em nenhum lugar. Sempre podemos encontrar referências. Meu nome Não, ele
não é usado em nenhum lugar, então vou excluir isso e compilar novamente, e agora o erro desapareceu Vamos voltar ao texto do
widget de atualização do widget. Agora, não precisamos
disso. Podemos trazer apenas nossa referência do modo de jogo porque isso armazena
basicamente o modo de jogo, essa instância do modo de jogo, e vamos
atualizar o texto rígido Agora, temos nossa
função aqui, precisamos preencher o tipo
de texto que ela aparecerá Então, para fazer isso, obteremos o estado da porta. Vamos ativar o
estado Dor porque é isso que controla e podemos, na verdade
, mostrar outro nó. Isso seria muito melhor. Vamos conectar isso aqui. Há outro nó em que
poderíamos criar algum texto e , em seguida, adicionar o texto lá
e definir esse texto. Poderíamos fazer basicamente uma
string ou, desta vez, um texto. E poderíamos ter vários
setters baseados no switch. Então, poderíamos ter este
neste caso,
este neste caso, este neste caso, e depois conectar esse texto aqui. Agora, a outra coisa que podemos fazer é que
há outro nó
que podemos usar em variáveis
específicas, chamado de seleção. Os nós selecionados têm
um índice curinga, o que significa que podem se tornar
alguns tipos de variáveis Então, se eu pressionar aqui, podemos ver os tipos de
variáveis que ela pode se tornar. E, como você pode ver, isso pode
se tornar uma enumeração. Então isso significa que eu posso
conectar isso aqui, e isso me dá uma escolha para
cada elemento para cada
enumerador Então, quando o enumerador está
aberto, ele me dá essa escolha. Quando está fechado, me
dá essa escolha. Agora, vamos sentir o que
precisamos para cada caso. Para abrir, precisamos fechar. Para fechar, precisamos abrir
e, para os outros dois, não
precisamos de nada porque
não estamos interagindo com
a porta naquele momento Então, vamos compilar, salvar e vamos testá-lo Na verdade, não, precisamos codificá-lo primeiro porque apenas
criá-lo não significa que o codificamos Quando o widget deve ser atualizado? Obviamente, antes de
adicioná-lo à janela de exibição. Então, vou simplesmente partir
das funções, vou arrastá-las
e soltá-las aqui e conectá-las aqui. Vou copiar, colar
e conectar abaixo também. E o widget
também deve ser atualizado quando bem, basicamente, o próximo ponto que devemos atualizar é sempre que
estivermos mudando de estado, já que nosso estado
afeta o widget, o que o widget
deveria Então, vou arrastá-lo
e soltá-lo aqui e vou conectar
os dois cabos aqui. E como você pode ver, eu posso ter duas execuções
conectadas a um nó Agora eu vou fazer o mesmo. Vou copiar isso e colar aqui nessas duas execuções. Uma seria a atualização e a outra
seria o acabamento. Agora, vamos testá-lo. Agora, pressione play para abrir. Temos aquele E ali que não
está fazendo
exatamente o que queremos. Não desaparece. Mas, sim, vamos consertar isso. Então, o que vamos
fazer é bem simples. Em vez de atualizar o widget
na atualização dos cronogramas, o que vamos fazer é remover o Então, vou copiar
esse código aqui, modo de jogo em terceira pessoa do
BP remover a porta e
colar no final de uma linha do tempo da atualização da
linha do A próxima coisa que precisamos fazer é depois de atualizar
o texto do widget, também
devemos
adicioná-lo ao portagym de visualização
da Vou pressionar copiar e vou colar isso
aqui e conectar isso aqui. E isso deve
funcionar. Vamos testar. E funciona. Incrível. Eu acho que é
isso para este. Te vejo
na próxima. Adeus
15. Programando um sistema de porta giratória de duas vias: Olá, e bem-vindo de volta
ao Unreal Engine, cinco sistemas de portas
Blueprint Mastery
e Anteriormente, terminamos com
nosso sistema de widgets para mostrar fechar ou abrir com
base na necessidade de
abrir ou fechar nossa porta Então, criamos essa função, atualizamos o texto do widget dentro da porta
unidirecional do nosso VP , que está chamando a função que criamos
na lição anterior, atualizamos o texto do widget
do modo de jogo e preenchemos o texto correspondente
ao Agora. Como temos esse E incômodo
aqui no widget, acabamos adicionando um código para remover o
widget da porta enquanto a porta está abrindo ou fechando e também adicionando-o quando a
porta está aberta ou fechada, quando a animação
termina na linha do Então, agora vamos continuar
até a próxima porta. Então, vou tornar
o nível três visível e ir até aqui. Essa porta deve se abrir em frente ao local em que
o jogador olha. Então, para fazer isso, vamos duplicar
nossa porta atual Mas vamos economizar também. Você viu esse pequeno
asterisco aqui, esse asterisco branco.
Deixe-me fazer uma mudança. Onde está a porta,
aqui está a porta. Você vai fazer isso aqui. Então, o asterisco aparece. Você vê que esse asterisco
aqui significa que algo mudou
no blueprint e precisa ser salvo, que esse ativo não foi É isso que esse
asterisco significa. Vou salvar novamente, Control Shift S para salvar tudo, e vou
duplicar esse plano Vou chamá-lo de BP, oponha-o ao jogador D. A ortografia pode estar
correta, pode não estar Nunca saberemos. Então, eu vou abrir isso, e esse é o mesmo modelo Esta é uma versão duplicada
do projeto que tínhamos. Mas antes de começarmos a
fazer algumas mudanças, o que não será muito. Vamos até o mapa do tutorial e trazer um novo texto flutuante E vamos selecionar
nossa luz pontual. Vamos trazê-lo
aqui, aqui. Acho que aqui está tudo bem. Além disso, a colisão da caixa de
colisão está aumentando. Isso é bom. E,
por fim, o texto Mas, vamos preencher o texto primeiro. Vamos selecionar a planta. Vamos ao meu valor de texto. Esta porta se abre
em frente ao jogador. Tudo bem E agora
vamos selecionar o texto. Não consigo ver o texto. É porque é invisível. Sim, em vez de fazer
isso toda vez, vamos modificar uma coisa na planta. Vamos
abrir a planta Ao começar a jogar, vamos
trazer o texto e definir a visibilidade como falsa. E vamos até minha
renderização de texto e dar visibilidade. Verdadeiro. Vamos compilar e
salvar de volta em nosso mapa Agora podemos ver o texto
e, quando o jogo começar,
ele desaparecerá. Vou trazer isso aqui. Vou voltar para
a planta, ir até o
texto para formatá-lo Vamos aumentar um pouco o tamanho
aqui. Então, mude e entre aqui. Pressione a tecla Enter aqui
e Tada será selecionada novamente. Sim, isso é bom. Talvez
um pouco menor. Agora, como isso se
transforma em um segmento, basicamente em um ponto de encaixe, posso desabilitar isso aqui de
cima e simplesmente fazer isso e habilitá-lo novamente para
ativar os pontos de encaixe Então, vamos trazer nossa nova
porta aqui também. Então, ao lado de um jogador,
vá trazê-lo aqui. De que lado devo virar cá ou para cá, para cá. Vamos manter o mesmo bot. Sim, está tudo bem. Sim. Está tudo bem. Então,
vamos à funcionalidade. Não vai mudar muita coisa. Vamos encontrar a porta. Vamos fechar
as outras plantas que não precisamos mais. Eu não preciso disso.
Salve o modo de jogo. Sim, na porta oposta, e pronto. Agora, o que queremos mudar
está basicamente na linha do tempo, se esse ângulo é -90
ou 90 com base na posição em que
o jogador está Poderíamos ter várias
colisões e verificar de cada lado se o jogador está deste
lado ou deste lado Mas há outra maneira
mais rápida fazer isso e mais fácil. Vamos criar uma função
para calcular a direção. E nessa função, vamos obter a localização de
nossos atores, então chegue à localização. E
também precisamos da localização do jogador. Para colocar o jogador
nesse cenário, podemos simplesmente levar o jogador para
casa e, a partir disso , também
podemos duplicar isso e nos conectar aqui Então, temos dois locais, o jogador e a localização
da porta. Agora, a porta tem uma frente
porque temos a seta. E se abrirmos o player, o player também
tem uma parte frontal. Agora, vamos voltar à
nossa direção de cálculo. A partir desses dois locais, precisamos encontrar a direção da porta até o jogador. Está atrás de mim ou
está na minha frente? Então, para obter a direção, um vetor de
direção único a partir de dois. Isso produz um resultado vetorial, o que significa que, com
base em onde estou, Y e X e Z podem
ser menos, podem ser mais Vamos demonstrar isso. Eu
vou imprimir uma sequência de caracteres. Vou conectar isso
aqui e vamos jogar. Vamos colocar isso aqui. Agora, vamos entrar pela
porta. Este abre. Esqueci de conectar
essa função. Vamos conectá-lo
pressionando E, na verdade. Então, vou calcular a
direção. Aqui. Então, quando estou pressionando, você vê que todas as variáveis
, exceto Z, são negativas Mas se eu for até aqui,
eles serão negativos novamente. Bem, agora o X é positivo
, porque eu estou
do outro lado, se levarmos
em consideração os centros, aqui, o X é mais, enquanto aqui, é menos Então, eu realmente não posso dizer
qual deveria ser. Se eu for do outro lado, o Y também mudará. Se eu tivesse essa loja aqui, então o Y ficaria menos, o Y ganharia mais aqui Então, isso realmente não
termina o trabalho. O que precisamos fazer é
criar um produto pontilhado. E o que é devolve um produto. Isso realmente não
explica muita coisa. Então, o que basicamente
é um produto pontilhado? É uma forma de comparar
duas direções. Temos a direção
do nosso ator aqui, e a próxima direção
seria o vetor direto. Vetor de avanço. Aqui está. Não essa. Desculpe. O ator para frente aqui está,
obtenha o vetor para frente do ator. Então, basicamente, essa é
a frente da porta. Então, temos essa
direção e temos a direção da
porta até o jogador. Então, temos essa direção
e a frente da porta. Agora, com base nessas
direções, o produto escalar, ele nos diz o quanto
esses dois vetores, essas duas setas estão apontando
na mesma Se o produto escalar for um número positivo
alto, eles estão apontando em
uma direção similar. Se for um número negativo, eles estão apontando na direção
oposta. E se for zero,
eles estão apontando para o
ângulo reto um do outro. Basicamente, o que ele faz é calcular o cosseno
do ângulo entre eles É isso que o dot product faz e nos dá uma flutuação como
retorno negativo ou positivo E é isso que
usaremos para verificar se é maior ou igual a zero. E se for maior
ou igual a zero, criaremos
uma nova variável. Vou chamar isso de ângulo aberto. Vamos
transformá-lo em um carro alegórico. Vou trazer um
setter aqui. E, novamente, vamos fazer
um nó de seleção, selecionar flutuar. Agora, veja, se
eu arrastar o cabo, selecione, eu pego
este, selecione flutuar e eu pego este, selecione Este tem o cartão branco, enquanto o outro tem
um ouro por padrão Então, vou
conectar isso aqui. Vou conectar
o resultado do nosso maior erro igual a
zero do nosso produto escalar. E isso seria, eu acho que A seria
-90 e B estaria 90 à frente da
porta é positivo, então ela se abre do lado oposto Sim, acho que é isso. Agora, onde vamos conectar essa direção de
cálculo. Se o conectarmos
ao início aqui, não
faremos isso. Sempre vou calcular a
direção. Então, quando eu vou em frente
à porta para
fechá-la, ela vai sair. Eu vou mudar a direção. Mas se eu conectá-lo somente
quando a porta estiver fechada, vamos conectá-lo para jogar
desde o início e, claro, trazer o ângulo até aqui. Agora, dessa forma, ele só calcula quando a porta está fechada
e, quando vai
de aberta para fechada, usa o mesmo ângulo calculado anteriormente Agora, vamos testá-lo. Poderíamos fazer com que o
jogador começasse conosco. Ok, ele abre dessa
maneira, fecha corretamente. Ele abre dessa maneira,
fecha corretamente. Então, agora temos uma porta
que abre e fecha. Ok, eu passo por
isso na física do jogo. Agora, temos uma porta
que abre e fecha, como para onde o jogador
está olhando Ok, eu acho que
é isso para este. Vamos continuar
pela próxima porta dupla. Vai ser o mesmo, mas o
dobro na próxima aula. Adeus por enquanto.
16. Criando e sincronizando portas duplas com planos: Olá, bem-vindo de volta ao Unreal Engine, cinco portais
Blueprint Mastery, Door Systems e
Interactive Anteriormente, terminávamos
com nossa porta de mão dupla, basicamente, o oposto
da porta de abertura do jogador. O que fizemos basicamente
foi criar uma
função de direção calculada que, com
base na localização do ator
e na localização do jogador, obtivemos uma direção unitária. Calculamos o produto escalar com nosso vetor direto do ator e comparamos se
é maior ou igual a zero para calcular
o novo ângulo. Em seguida, adicionamos esse novo ângulo ao nosso larp em nossa
linha do tempo como alvo Agora, vamos fazer os mesmos
quatro em porta dupla. Vamos tornar o
nível quatro visível. E vamos trazer, na verdade, eu posso trazer este. Sim, eu posso trazer esse.
Vamos trazê-lo aqui. Vamos mover a luz
dessa maneira desta vez. E também o texto. Vamos renomear o texto. Vamos selecionar a planta.
Não consigo ver nada. Eu não selecionei a planta.
Eu selecionei a raiz. Portanto, essa é uma lei dupla. Não. Vamos mexer um pouco. Também temos que fazer a
entrada. Somos uma variável. Oh,
eu me escondi de mim. Então eu acho que está tudo bem. E vamos criar nossas novas portas em forma de planta de
porta, e duplicaremos o
oposto do jogador Agora, vamos chamar isso de porta BPW. E vamos abri-lo,
compilar e salvar. Então, o que temos que fazer
aqui é bem simples. Vamos duplicar
essa malha aqui. Vou clicar
e duplicar ou posso copiar e colar,
e pronto E então o que vamos fazer é colocar essa malha aqui. Vamos precisar de um pouco de espaço. Então, vou mover
isso para cá. Vamos duplicar esse
conjunto relativo, a rotação relativa, e o larp, e vamos
conectá-lo aqui E precisamos do Alpha. Precisamos conectar o alvo, que é a nova malha. E o que precisamos fazer também
é multiplicar isso por menos um porque vamos negar
a rotação. Então, também precisamos corrigir as mensagens
estáticas aqui, e é hora de
selecionar a nova porta. Então, vou
compilar e salvar. Eu vou voltar para o mapa. Eu vou até a
nossa porta Tuggle aqui . Vou selecionar
a primeira parte. Vou encontrá-lo no navegador condat por meio dessa
opção de malha estática aqui, pressionando este botão,
e aí está Vou voltar ao nosso plano,
selecionar
a primeira porta e
usar o ativo selecionado no Navegador
de conteúdo Agora vamos fazer o
mesmo no próximo. E selecione a próxima
loja e importe-a. Agora, pelo que
vejo, há uma espécie de cenário oposto aqui. Então esse seria esse
e esse seria esse. Eu acho que eles estão bem espaçados. Agora vamos movê-los para o
centro da planta. Sim, tudo bem.
Vamos aumentar também o tamanho da colisão. Está tudo bem por lá. E vamos testá-lo porque acho que talvez seja
necessário fazer o oposto. Então, vamos voltar para o nosso
quarto e trazer a nova porta para girá-la Há uma grande
possibilidade de vermos uma animação divertida porque
eu troco as portas. Mas se não
testarmos, não saberemos. Então, vou fazer com que os
jogadores comecem aqui para que não percorramos todo
o nível. O que é a loja?
Oh, eu devo ter deletado isso por
acidente, traga-o aqui. Tudo bem. De qualquer forma,
vamos começar aqui. Vamos jogar. Esta é uma porta
dupla aberta, fechada. Sim, abre em frente. Ele se abre para mim
em vez de se afastar de mim. Sim. Então, poderíamos deixar como está ou podemos
simplesmente trocar esses dois Tenho certeza de que havia uma maneira
de fazer isso mais rápido. Menos cliques. Mas de qualquer forma, sim. E temos uma porta dupla. Agora, tudo bem que
tenhamos uma porta dupla, mas vamos começar a adicionar
alguns sons às nossas portas. Vamos adicionar um som de abertura
e fechamento. Então, de aberto, queremos
reproduzir som para D. Esse é um nó que reproduz um som que
podemos definir, mas não podemos
manipulá-lo depois Ele não tem uma saída
para salvar o som. Portanto, tem
poucas configurações por aqui. Vamos usar
o multiplicador de tom
e, para o som,
vamos encontrar a porta aberta Porta aberta para esta. Então, agora, o que vamos
fazer com o tom, vamos fazer uma flutuação
aleatória no alcance para tornar o tom de
abertura um pouco mais alto, do normal para o mais alto E o mais alto seria
um ponto, digamos 15. E vamos
duplicar esse código. Se eu colocar depois do
cálculo ou antes, realmente não importa, mas vou
colocá-lo depois. Vamos abrir um espaço aqui. E em vez de
multiplicar o tom com flutuações aleatórias
de um a 1,5, vamos fazer Então, 0,8 a, digamos, 0,99, o que faria com
que parecesse mais pesado, como um tom mais baixo, basicamente Então, vamos testar isso. Sim. Temos um
som na nossa porta. Pão. Eu acho que
é isso para este, no próximo,
vamos começar com nossa porta de atalho.
Adeus por enquanto
17. Programando uma porta de atalho para acesso mais rápido: Olá, bem-vindo de volta
ao Unreal Engine five, Blueprint Mastery door Systems
e Então, da última vez, terminamos
com nossa porta dupla. Agora, vamos abrir o próximo olho. Aqui estamos na nossa porta de
atalho, que será uma porta que, de
um lado, não abre Diz trancado. E
quando você vai do outro lado, você pode desbloquear. Para fazer isso, precisamos
fazer um pré-trabalho muito pequeno. Precisamos voltar ao nosso estado de
enumeração I Dor, e precisamos adicionar
um enumerador,
e vamos chamá-lo de bloqueado e precisamos adicionar
um enumerador,
e vamos chamá-lo de bloqueado.
Vou economizar. Mas como isso realmente não mudará nada
nas portas anteriores, ter trancado aqui não
adianta nada, porque essa
porta não pode ser trancada. Mas mesmo no widget de atualização, ele não digita nenhum aqui Eu esperava dizer
não algo assim, mas parece que está
deixando tudo vazio Então, isso realmente não afetou. Mas talvez em outros sistemas, adicionar aos enumeradores
depois de
usá-los não seja recomendado Agora, adicionamos a
categoria bloqueada em um enumerador. Vamos até a pasta da porta e vamos duplicar o
oposto do player novamente. Vamos chamar isso de porta curta
da BP. Vamos abri-lo. Novamente, precisamos mudar
algumas coisas, mas não muitas. Então, a primeira coisa que faremos é separar a
parte de animação e som de um evento por
si só, para que possamos chamá-lo. Só quero colocar isso aqui. E vou
criar um evento personalizado e chamá-lo de animação de portas. E conecte-o ao switch. Também queremos alterar o estado
padrão da porta para trancada. Compile e salve. E agora precisamos criar um mecanismo
para verificar se a porta está trancada. E isso é bem simples. Vamos trazer
nossa enumeração. Vamos fazer um número igual,
não um operador igual, porque o
transformamos em um byte e queremos que
seja um número igual, para que possamos escolher entre
os enumeradores Então, vou escolher bloqueado. Vou colocar um galho
novamente com B e clicar. E quando estiver pressionado, vou verificar
se está trancado. Precisamos de um pouco
de espaço aqui. Tudo bem Então, se não estiver trancada, vamos apenas
animar a porta Animação de portas. Vamos
reproduzir a animação da porta. Mas se estiver trancado, precisamos criar uma
mecânica ou as regras de bloqueio Então, vamos criar
um evento para clientes. Chame isso de mecânico de fechaduras
para cães com atalhos. Já. E precisamos ligar
para cá. Então, atalho, mecânico de bloqueio. Agora, sempre que pressionamos E, verificamos se está bloqueado,
se estiver bloqueado , o
mecânico está tocando Vamos verificar se o jogador
está na parte da frente. E o que podemos usar é basicamente
a direção de cálculo. Só precisamos basicamente do
tornozelo calculado. Mas eu quero demonstrar outra
coisa. Quero copiar esse
código aqui, que nos diz que se estiver
acima ou igual a zero, está na frente, se for menor, está na parte de trás. E o que vou fazer é
criar outra função. E vou
chamar essa função frente, ponto de interrogação. E vou tornar
essa função pura, e funções puras
sempre precisam de uma saída. E vou renomear
essa saída para front side. Vou colar o
código que copiamos. E conecte
esse operador a esse resultado aqui, e temos essa função. Agora, vamos chamar
essa função. Vou até nosso mecânico de portas
mais curtas e trarei essa parte frontal Como você pode ver, é muito diferente em comparação com
as outras funções. Vamos ver a direção
calculada. Ele tem uma entrada de execução
e uma saída de execução. Este é apenas verde. É como o controlador get
player. É como se o componente tivesse uma
etiqueta. Se parece com isso. Isso ocorre porque as funções puras executam
apenas algumas operações sem definir algo dentro definir qualquer variável ou qualquer
coisa dentro daqui. Como você pode ver, é apenas uma função de
expressão matemática pura e tem uma saída
de um booleano Nós não configuramos nada. Poderíamos definir variáveis
locais porque as funções têm essas variáveis
locais aqui que existem apenas na função enquanto ela
é executada e, em seguida, elas desaparecem quase, mas toda vez que
a função é executada, cria essas novas variáveis
e, toda vez que as usa, as libera posteriormente, o que é muito ótimo. Portanto, funções puras não
devem ter coisas que estejam sendo definidas, a menos que
sejam variáveis locais. Este é o resumo disso. E, claro, eles
não exigem execução e resultam
de alguma ação. Então, vou
pressionar um galho aqui, vou conectar
isso aqui, e perguntamos se
estamos na frente. Novamente, isso poderia ser feito
se os ângulos fossem -90, estaríamos
na parte frontal Então, eu só queria demonstrar
essa função pura. E também podemos colocar um não aqui e não um
bullan e um negativo Portanto, o verdadeiro significará desbloquear, e o falso
significará não desbloquear. Se for falso, estamos
na parte da frente. Se for verdade,
não estamos na frente. Estamos na parte de trás porque
colocamos isso não aqui, que torna esse
bullian oposto Se for verdade, queremos
definir o estado da porta. E isso seria fechado porque depois de destrancarmos
a porta permanece fechada Então, podemos tocar um som. Toca um som, acho que se
chama Dog and Lock. Sim. E como essa porta
deveria estar trancada, vamos até a porta e
temos que demonstrá-la
ao jogador de alguma forma. Vou selecionar uma porta e vou mudar o material para acho que é
a porta 1 trancada. Sim, aqui está. A porta
um está trancada, então é vermelha. E quando o desbloqueamos,
ele deve mudar de cor. Vamos ver o gráfico uniforme
aqui quando o configuramos para fechar, tocamos o som desbloqueado e vamos abrir nossa porta Vamos montar o material. E então vamos selecionar
a porta um. E, como você pode ver,
há um índice de elementos. Se o DR tivesse mais materiais
, eu poderia selecionar o índice
apropriado para alterar. Mas temos apenas um material, então apenas alteramos o índice zero do
elemento. A próxima coisa que deve
acontecer é atualizar o widget pois basicamente ele passará de
bloqueado para aberto E temos que definir aqui também
que está dizendo bloqueado. Quando a porta está trancada,
o widget diz trancada. Mas e se eu estiver em
um site que eu possa desbloqueá-lo? Deveria estar dizendo desbloquear. Então, para fazer isso, vamos fazer uma seleção. Vou fazer um texto selecionado. Como você pode ver,
já tínhamos essa opção, aquela com um
Bleian se B, escolha A, se A for verdadeiro, e
aquela que é select, que tem o nó selvagem Certifique-se de usar
aquele com um booleano. Vou trazer a frente
leste novamente. Vou conectá-lo aqui. E se estiver na
frente, digamos, parece trancada
do outro lado. E se estivermos do outro lado, deveria
dizer desbloqueado Agora, vamos compilar e salvar. Então, que atualizamos corretamente. O que resta a fazer é
fazer alguma coisa quando o
jogador tenta abri-la, pressiona E, a porta está trancada e ela está
do lado errado Então, o que vamos criar
é uma animação do chocalho da porta. Mas vamos fazer
isso na próxima. Eu acho que isso é
suficiente para este. Eu vou te ver então. Adeus
18. Adicionando efeitos visuais a uma porta de atalho: Olá, e bem-vindo de volta
ao Unreal Engine, cinco sistemas de portas
Blueprint Mastery
e Anteriormente, começamos
com nossa porta de atalho. Adicionamos o enumerator, um novo enumerador ao nosso Vimos que isso não mudou nada em nosso
código porque não é
recomendável adicionar
novos enumeradores depois de já os ter usado
em vários lugares, mas isso não importou para nós porque temos
um código muito pequeno
e atualizamos o
widget para dizer, e atualizamos o
widget para dizer, não na
porta dupla da nova porta Atualizamos para dizer que,
se estiver na
parte frontal do player, parece bloqueado; se estiver
na parte traseira, desbloqueado E criamos essa função es
front side pure com o código que usamos
na direção de cálculo. Também separamos a animação da porta da pressão E, que leva a verificar
se a porta está trancada. Se estiver bloqueado, está jogando
nosso mecânico Trectlock. Se não estiver, está
reproduzindo a animação. Quando estamos na
parte de trás da porta, estamos destrancando a
porta e trocando o material porque configuramos o material para ser
um com um brilho vermelho,
mas agora, quando o destrancamos,
será será Mas paramos sem
criar um chocalho. Então, vamos criar o chocalho. Vamos criar um novo evento personalizado. Vamos chamar isso de chocalho de porta de
evento personalizado. E aqui precisaremos de
um cronograma novamente. Vou apenas copiar
essa linha do tempo aqui e apertar
play desde o início Mas acho que temos
um som para um chocalho, então vou tocar primeiro o som com
di e depois
tocar do início até a linha do E eu acho que o som
é chamado de chocalho. Sim, sinal de chocalho da porta. Aqui estamos. Agora, vamos
descobrir uma coisa. Por quanto tempo a
porta deve tremer? Acho que 0,5 está bem. Vamos fazer isso um
pouco mais. Digamos que 55. Não 0,55, não apenas 55. Eu sacudiria por 55 segundos. Bem, depende da pessoa
que está tentando abri-lo. Digamos 0,55 e
vamos definir o valor zero porque, no
início e no final, ele deve estar
na mesma posição Como se o jogador estivesse tentando
abri-lo, mas realmente não conseguisse. Agora, como vamos
criar o sorteio? Bem, para mim, a solução
agora é bem simples, mas o chocalho
não será realmente perfeito, mas será um chocalho Vou apenas
persistir e clicar em pontos
aleatórios abaixo de um e acima de menos um e talvez movê-los
um pouco mais perto Digamos que ele esteja empurrando. E vamos ver, ele
dá um puxão aqui e depois dá um grande empurrão. E ele continua empurrando dessa maneira e depois solta
e depois arrasta novamente, e então empurra
novamente, uma Não sei,
algo assim. Você pode jogar muito com isso. O que podemos fazer para
torná-lo um pouco mais suave pode ser usar
a função automática
e, como você pode ver,
ela o torna mais suave Mas, na minha opinião, ter idas
e vindas severas pode parecer melhor para alguém que
está tentando abrir uma porta. Vou deixar as
coisas assim. Se quiser, você pode selecioná-los todos
e fazer a coisa automática, selecionando-os e fazendo automático para interpolar
entre os pontos Agora, o que fazemos na
atualização com esse Alpha? Bem, é claro,
vamos ao larp. Eu vou para o larp. Isso
será Alpha 0-1 0,5 Isso é uma vírgula 1.5. Y zero a 1,5. Então, esses são os graus
da rotação. Vou apenas copiar
o nó de rotação também e este, a malha da porta, também,
a referência da porta. Agora, vou
conectar isso aqui. Agora, como usei valores
negativos
aqui, menos de zero, esse 1,5 também
contará como um ponto negativo negativo, como
um ponto de ajuste imaginário
no Então, isso vai
e volta disso. E se fossem mais graus, acho que não ficaria
muito bom,
não que parecesse muito bom agora, mas é mais normal ter graus
pequenos aqui. Agora, uma última coisa
antes de fazermos o teste, vamos conectar o
chocalho da porta aqui Vamos chamá-lo de rattle vamos compilar e
salvar, e vamos jogar Eu não adicionei a
porta no mapa. Deve estar faltando
alguma coisa. Vamos adicioná-lo no mapa. Agora,
essa é a porta dupla. Essa é a porta de atalho. Onde está a
seta frontal aqui. Poderíamos mudar a cor da seta, para que não combine com o dispositivo,
esse dispositivo aqui, ou
torná-la um pouco maior
e mais grossa, Para fazer isso, basta acessar os componentes do blueprint, selecionar a seta e
acessar seus detalhes Agora, para mim, essa configuração foi criada
para algo diferente. Eu só vou mudar
isso para tornar a jogabilidade mais inteligente. Uma porta de atalho
faz mais sentido. Vou selecionar tudo isso. Eu vou empurrá-los até aqui. Isso
os deixará um pouco mais
altos e os empurrará Vou deletar
isso. Eu vou trazer isso aqui. Talvez por aqui.
Você não precisa fazer isso. É só para mim, faz mais sentido usar um atalho para irritar o jogador ao contornar as
coisas Então, ter que fazer essa distância em comparação com essa
distância é maior. Então o jogador pensa: Ok, talvez eu deva trancar
a porta como se realmente valesse a pena
abrir a porta, ir daqui até aqui, instantaneamente e depois dar a
volta completa De qualquer forma, problemas de desenvolvimento. Vamos progredir. Vamos
trazer o jogador aqui. Vamos testar a porta.
Ok, está chocalhando Parece trancado
do outro lado. Sim, vou por aqui. Se formos até aqui,
posso pular daqui? Não. Ok, eu o desbloqueio. Eu nunca vou fazer isso de novo. Vou direto para
a próxima sala. Na verdade, tudo
está desbloqueado agora, então eu não posso ganhar o jogo Mas de qualquer forma, acho que
é isso para este. Continuaremos
na próxima com a criação um interruptor e uma porta que
se abre com esse interruptor. Adeus por enquanto. Te vejo então.
19. Construindo um modelo de alavanca para desbloquear portas: Bem-vindo de volta ao
Unreal Engine five, Blueprint Mastery, door Systems
e portais interativos Anteriormente, terminamos
com nossa porta de atalho. Criamos um evento personalizado,
depois tocamos um som, depois criamos uma nova linha do tempo
e, com base nessa linha do tempo, definimos a
rotação relativa novamente E chamamos esse
evento aqui. Agora, é hora de nos
aprofundarmos um pouco mais nesse projeto. Vamos abrir o nível seis, e é hora de nossa porta que está se comunicando
com um interruptor, apenas algumas informações extras
antes de prosseguirmos Tudo o que
criamos são objetos. E quando estávamos criando
um novo modelo, estávamos selecionando uma classe Esta é a porta da classe BPW. Esta é a porta unidirecional da classe
BP, etc., etc. O mesmo vale para isso também, não para a enumeração A enumeração é
apenas uma variável. É uma enumeração. Então, por que estou falando
sobre aulas? Uma definição inteligente seria
que eles são objetos com propriedades
e comportamentos
específicos que permitem aos desenvolvedores
criar várias instâncias. Isso significaria que
podemos ter duas dessas portas. Eles têm o mesmo comportamento, têm as mesmas propriedades e são
instâncias completamente diferentes dessa classe. Dizendo tudo isso, o que
fizemos até agora, por exemplo, no
começo aqui, usamos as referências de classe para fazer algo
no blueprint de nível Usamos a classe de portas
aqui para girar esse ator. Em outros exemplos, nós
realmente não ligamos para nenhum outro ator. Mas, novamente, um exemplo seria a seleção que fazemos para
o jogador nas colisões Na verdade, não fazemos casting. Fizemos o casting
no começo aqui. Isso, novamente, requer a aula. Ele pede a aula. Você é da classe de personagem de terceira
pessoa da BP? Se você é desta turma, estou obtendo algumas
informações de você. O que a próxima etapa precisa, essa porta é algo que
chamamos de interface de projeto Vou chegar,
clique e vá para o
Blueprint e vá para o
Blueprint Vou chamar isso de BI Ds. Agora, o que é uma interface de
blueprint? Essencialmente, é uma forma de executar funções em classes diferentes que podem implementar
seu próprio código. Não é exatamente comum, mas
posso chamá-los para qualquer classe que implemente,
acho que seria melhor mostrá-la como exemplo Mais uma coisa, é uma
das formas mais ideais de comunicação com o
blueprint exemplo, uma planta precisa se comunicar com
outra planta e eles não se
conhecem exatamente Eles não sabem em que
classe são os outros. Vamos duplicar nossa
porta trancada, nossa porta de atalho. Vou duplicar isso, e vou chamar
esse interruptor. Então, agora, vamos voltar às
nossas portas VI e abri-las. E quando eu o abro, você pode ver que
parece uma planta, mas tem do outro lado a guia M Blueprint e
os Isso ocorre porque só podemos
ver uma função aqui, aquela que ela nos criou. Se eu adicionar mais funções, podemos ver outra função. E o único gráfico
que existe aqui são essas
funções, basicamente. Que, como você pode ver, eles
não têm uma execução. A execução será criada no blueprint que os
hospedará Então, eu vou deletar este. Vou dar um nome a essa porta de destrancamento. Agora, o que podemos fazer aqui
além de nomear uma função, poderíamos colocar entradas
e saídas e dizer que essa função
funciona sempre Sempre tem essas
entradas e saídas. Vamos salvar, compilar e
vamos para o nosso switch,
switch, este Então, como implementar a
interface aqui? Vamos para as configurações de
nossa aula. Vamos acessar as interfaces. Vamos pressionar
AD e
procurar pontos de BI Agora vou compilar
e, como você pode ver, uma nova categoria apareceu nas
principais interfaces do meu Blueprint E se eu abrir isso,
podemos encontrar a porta da fechadura. E se eu clicar duas vezes nele, criaremos um evento para ele. Agora, se isso tivesse uma saída, seria uma função e eu
entraria na função. Agora, o que acontece quando
abrimos a porta? Bem, quando você abre a porta, temos esse código
em algum lugar aqui. Sim. Não precisaremos de
toda essa mecânica, então vou simplesmente deletar
essa parte, o bloqueio de atalho Precisamos que o chocalho da porta assuma a posição
do atalho mecânico da fechadura
da porta, que não existe E precisamos desse código. Vamos recortar e
colar aqui. E o material
é a correção. Então, em termos de codificação, essa porta está pronta
porque quando pressionamos E, duas coisas acontecem
ou a porta será destrancada e
abrirá ou fechará, ou a porta será trancada
e chocalhará e chocalhará Como você pode ver,
estamos ligando do nada para este evento com portas
destrancadas Isso ocorre porque vamos
chamá-lo por meio de outro esquema por meio do switch
usando a chamada de interface Agora vamos criar
esse switch Blueprint. Vamos acessar
o Content Browser. Vamos para
nossa pasta Blueprint. Vamos clicar com o botão direito do mouse
e criar um novo ator. Vou chamá-lo de
interruptor BP. E vamos abri-lo. Vamos começar com os componentes. Vamos adicionar, é claro, uma caixa ou lesão Vamos adicionar um texto. Renderize, na verdade, não. Não precisamos de uma licitação. Precisamos de duas malhas estáticas. Então, vou
selecionar a malha estática e duplicá-la Agora, para a primeira malha estática, vamos compilar, salvar e
voltar ao nosso mapa Vamos até nossos adereços e vamos selecionar
este aqui,
que é a alavanca do pote de suporte Vamos vinculá-lo. Tudo bem, vamos voltar ao
switch e aplicá-lo. Agora, para a segunda malha estática, vamos fazer o
mesmo: baixá-las, selecionar a segunda, vinculá-la, voltar ao switch
e adicioná-la aqui Na verdade, vamos adicionar uma seta
porque sim, eu pensei assim. Eles estão meio que errados. Então, vou girá-los 90 graus e fazer com que
seja uma alavanca, não um De qualquer forma. E também, vou girar 90 graus dessa maneira Então, ele olha
para cima
porque vamos animá-lo para descer. Vamos comparar e economizar. E agora precisamos de algumas
funcionalidades nas portas. Então, eu vou para qualquer
porta que realmente não importa. Eu vou para a porta
dupla agora. Vou encontrar o início do jogo e vou copiar
esse modo de jogo com limite e
torná-lo uma variável. E eu vou colocar a
caixa no switch e colar aqui. E essa variável, como você
pode ver, não existe. Quando uma variável não
existe, ela é cinza. Para que ela exista, podemos simplesmente criar uma variável
aqui e nomeá-la ou podemos clicar com o botão direito nela
e criar uma variável como
modo de jogo em terceira pessoa e pronto A próxima coisa que
vou fazer é separar essa
seta
da malha estática Mas não era isso que
eu queria dizer. O que eu
queria dizer é que vou
selecionar essa malha estática, que é a alavanca que
vamos girar E no início do jogo, eu vou
trazê-lo até aqui e
vou obter uma rotação
relativa. Então, não precisarei
calcular nada. Vou apenas armazenar
essa variável do movaiable e
conectá-la aqui Então, vamos usar
essa variável agora para girar o interruptor, o fígado Mas antes de começarmos a animar, vamos terminar copiando
o comportamento que queremos Também queremos o comportamento da
colisão. Então, vou colocar
tudo isso aqui, vou controlar e vou
colá-los aqui. Veja, atualize o texto do widget.
Precisamos desses dois. Então, vou apenas criar uma função
correspondente, confirmar. Mas essa função
está meio vazia. Mas isso não importa, porque
precisamos de algo diferente para fazer coisas
diferentes desta vez. Não é uma porta. Então, o que faremos
basicamente é
criar uma variável, chamá-la de vendida e trazer
uma filial até aqui. Se estivermos resolvidos, obteremos nosso modo de jogo em terceira
pessoa e removeremos o widget da porta do widget Bem, é um
widget de fígado no momento, mas nós o chamamos de widget de porta Não importa. E se não for resolvido, atualizaremos o texto. E use o tipo. Então, o jogador sabe
que pode usar o gatilho. E essa funcionalidade
agora é copiada, e nós também meio que copiamos texto
do widget de atualização
ao mesmo tempo Um lembrete rápido. O que isso faz é que, quando estamos
sobrepondo ao player, estamos habilitando a entrada
neste plano Estamos atualizando o widget e o
adicionamos à janela de visualização,
ou o removemos e desativamos a
entrada quando terminamos Eu acho que isso é
suficiente para este. Eu vou
te ver na próxima. Adeus.
20. Implementando o desbloqueio de porta remota com comunicação Blueprint: Bem-vindo de volta ao
Unreal Engine five, Blueprint Mastery, sistemas de portas
e Anteriormente, terminamos
com nossa porta de troca. Criamos uma interface de diagrama que explicamos como os
esquemas se comunicam
quando eles não
sabem quem é esquemas se comunicam
quando eles não o outro plano,
qual é o tipo de vantagem do
outro plano, e a implementamos em
nossa porta de comutação BP
acessando as configurações da classe
e implementando-a nas interfaces
implementadas que explicamos como os
esquemas se comunicam
quando eles não
sabem quem é o outro plano,
qual é o tipo de vantagem do
outro plano,
e a implementamos em
nossa porta de comutação BP
acessando as configurações da classe
e implementando-a nas interfaces
implementadas. Nós pressionamos o anúncio e o
implementamos. Em seguida, obtivemos o evento de
desbloqueio da porta que criamos na interface do
Blueprint e conectamos a cadeia de eventos que queremos que aconteça
quando a porta for destrancada Bem, agora não é uma porta. Bem, é uma porta, na verdade. E então
continuamos alterando
o evento de pressão para sempre
chocalhar se estiver bloqueado
e, se não estiver bloqueado, desbloquearemos e
reproduziremos
a animação de desbloqueio A animação aberta. Em seguida, criamos
o switch BB, no qual copiamos a funcionalidade de sobreposição da colisão
da caixa Adicionamos a colisão da caixa. Também adicionamos duas
medidas estáticas e uma seta. E pelo que eu posso ver, a flecha está girada incorretamente Vou redefini-lo para o
padrão. Agora está correto. Vamos continuar com a
animação do switch. Então, vamos usar
o E do teclado. E a primeira coisa que
vamos perguntar é o
interruptor? É o switch? O interruptor realmente girou? Caso contrário, diremos que
sim, porque isso passará apenas uma vez e
reproduzirá a animação. Agora, aqui,
vamos atualizar o widget. Então, ele para de mostrar
o uso do texto e vamos reproduzir o som. Que vamos
mexer no campo novamente. Vamos fazer uma carga
aleatória no alcance. E vamos
passar de 0,8 para um. E o som seria, acho que há um interruptor. Não, se chama lever
ever Q. Aqui estamos. E agora precisamos de um cronograma. Então, um cronograma. Vamos entrar
nessa linha do tempo. Vamos criar
um novo caminhão de fluxo. Vamos clicar e
criar dois pontos. Um será vezes 0,15, e será um, e o outro
será zero, zero Agora, vou pressionar esses dois botões para
ajustá-los horizontalmente,
verticalmente, e vou pressionar como
quadro-chave Além disso, desta vez,
vou selecionar os dois e vou
usar a curva automática. Portanto, o movimento é um
pouco mais suave. Agora, quando a linha do tempo é reproduzida, primeiro precisamos de
um pouco de espaço Vamos precisar mudar a rotação
da alavanca. Então, vamos obter
nossa malha estática 1. Vamos definir a rotação
relativa. Vou conectar isso
aqui e vou
alertar e vou usar a rotação
relativa que temos. Vou conectar o
Alpha aqui. E para o B, o que
eu
vou fazer é fazer o rotador Vou para -90 e vou
quebrar o rotador Sem eixo, desculpe. E vou rolar
e arremessar o núcleo para permanecer o mesmo, porque nós o giramos
para olhar em direção à flecha Então, agora, ele manterá a
mesma rotação que tínhamos e mudará o Z para -90 Também vou selecionar
o local ordenado para que ele
faça um pequeno movimento A próxima coisa que vamos
fazer é pegar novamente a malha estática e fixar o material. Então, quando terminamos e
a animação termina, ela semeia os adereços no material, o que transforma esse
amarelo Agora, a parte interessante, como enviamos a
mensagem para a porta? Bem, como dissemos, temos essa
interface de projeto que pode enviar uma mensagem para qualquer
ator que a tenha Ele pode enviar uma mensagem para
qualquer ator, basicamente. Mas se o ator tiver a interface do
blueprint, ele fará algo com ela Se isso não acontecer, não
fará nada. Então, vou criar uma
nova variável aqui, e vou
tê-la do tipo ator. Então isso significa que
pode ser qualquer ator. Qualquer ator que eu possa
selecionar e preencher essa variável pode se tornar o objeto para o qual estou
enviando a mensagem Vou chamar
esse ator de porta. E lembre-se da
instância editável. Vou clicar nele e
expor no spawn, é claro, vou compilar
e dizer, agora, vou colocar o interruptor
e a porta no nível Vamos trazer o interruptor aqui e vamos trazer a porta também. Essa não era a melhor localização. Vamos colocá-lo aqui. Acho que é uma boa
altura, um bom lugar. Você pode colocar
o que quiser. Agora, vou selecionar
a colisão da caixa e vou trazê-la
um pouco para frente Faça-o um pouco maior. Então, quando o jogador
está aqui dentro, ele pode interagir
com o switch. Agora, como obtemos
essa referência? Por aqui, não
encontraremos aqui. Desculpe, eu
selecionei o plano. Eu tinha selecionado a caixa. Então, de volta ao plano. Aqui nos detalhes, podemos encontrar esse ator de porta. Eu posso usar esse
ator escolhido do SN. E eu posso selecionar
qualquer ator que eu quiser. Como agora, eu
selecionei a parede. Eu posso selecionar essa história, mas ela não fará nada. Enviaremos esse código
que implementaremos. Basicamente, vamos programar para fazer isso. Você só vai
pegar o ator e
dizer a mensagem de destrancar a porta. E como você pode ver, tem esse pequeno
envelope aqui Isso significa que ele envia
essa mensagem. Agora, eu poderia perguntar se esse ator
implementa a interface. Eu poderia selecionar a
interface que eu queria, vidor e se não
pudesse colocar uma ramificação aqui, e se não
tivesse a interface
, basicamente não enviaria
a mensagem Eu também poderia perguntar se é um ator
válido caso eu esqueça, por exemplo, de selecionar um ator e essa
variável esteja em branco. Eu poderia ter uma string de
impressão aqui, string de
impressão, o switch
não tem um ator. Não é um interruptor. É um fígado. Talvez eu deva renomear
esse blubrid. Vamos. Então eu vou chamar
essa porta do fígado. Vou até aqui e
nomearei esses dois fígados. OK. Portanto, isso
garantiria que temos um ator e também a interface
implementada para esse ator. Podemos ter outra mensagem
de erro aqui dizendo
que o ator
não tem interface. Não implementa interface. E agora podemos ter
dois códigos de erro. Vou compilar e salvar.
Eu vou até aqui. Vou girar essa porta para
a rotação de coleta e
colocá-la , está bem? Talvez um pouco mais alto,
e está tudo bem. Agora, vamos trazer também o texto em que
descrevemos as portas. Também não colocamos um aqui. Então, vamos fazer isso. Vamos trazer um novo texto baixo. Vamos definir a mensagem, seguir esse caminho e pegar uma
flecha, outra pergunta. E vamos girar o texto. Opa, não é uma planta,
o texto em si. E traga isso aqui. Vou torná-lo um
pouco menor. E também traga a luz. Tudo bem, e agora a colisão Vamos apertar play. Tudo bem, funciona. Indo por aqui. Estou trancando a porta,
vindo por aqui. E o interruptor vai para o nosso lugar
errado, vamos consertar isso, e a porta não abre
porque, antes de tudo, eu não selecionei a porta
no ator do interruptor. Então, vou selecionar
essa porta desta vez, e vamos até a alavanca, não trocar e trocar isso Então não é Ya que queremos, e deve ser tom. Então, vou conectar
isso aqui e s -90 aqui. Vamos também trazer isso aqui. Então, da maneira errada novamente. Não é a maneira correta.
Então não é 90. É 180 e é mais 180. A terceira vez é o charme. Yay. Conecte a animação. Agora, a porta está aberta
e podemos seguir em frente. Então, vamos trazer o
texto aqui agora que funciona, vamos trazer um novo. Vou trazer um texto flutuante. E eu vou colocar por mensagem de texto. Use a alavanca para abrir
a porta. Tudo bem. E no turno, digite
para ir uma linha abaixo. Vou selecionar o texto.
Vou movê-lo para cá. Agora, desta vez,
vou trazer
a luz acima do fígado. Então esse lugar se ilumina. O jogador vê para
onde deve ir. Um pouco de design de jogo, mesmo que não seja necessário.
É sempre bom tê-lo. E eu vou
aumentar isso aqui. Vou trazê-lo aqui.
Sim, aqui está tudo bem. Esta sala está pronta. Agora,
continuaremos com o
uso de duas alavancas para abrir uma
porta, mas de uma maneira diferente No momento, a alavanca envia uma mensagem para a porta
que diz destrancar O próximo
será o oposto. A porta perguntará às
duas alavancas: Você está resolvido. Eu vou te ver
então. Adeus por enquanto
21. Criando mecânica de quebra-cabeças de vários botões para sistemas de portas: Olá, e bem-vindo de volta ao Unreal Engine, cinco portais
Blueprint Mastery, Door Systems e
Interactive Anteriormente, terminamos com
nosso fígado Door, basicamente. Acho que no final das contas chamamos isso de
alavanca. Sim, porta do fígado. Ele não foi atualizado aqui
porque não atualiza nomes automaticamente. Assim, podemos atualizá-lo. Além disso, uma coisa
que notei é que, no texto do widget de atualização, ele não deveria dizer que parece desbloqueado Vou deletar
isso, só vou
dizer bloqueado. E
pode ser isso. Então, agora terminamos
com a porta do fígado. O que fizemos foi
adicionar alguns textos também e finalizamos com a parte
animada do fígado. E adicionamos algumas mensagens de erro também para o caso de o ator
da porta não estar definido. Agora, vamos continuar
com a próxima parte. Vamos tornar nosso nível
seis, eu acho, sete, nosso nível sete visível, e esse é o
ponto de virada depois, vamos descer. Vamos começar atualizando nossa
interface de projeto para cães Vamos adicionar uma nova
função chamada SOD. Essa função,
vamos usar uma saída e vamos chamá-la de SOD. Isso vamos usar em nosso fígado. Então, vamos
até nosso fígado, acessar as configurações
da aula e adicionar uma
interface que é BI dots. Agora,
vamos às interfaces. Na verdade, vamos compilar o esquema de
colisão do
primeiro nome de interface por causa do Vamos chamar isso de booleano vendido. Sim, você não pode ter a
mesma variável de nome duas vezes
e, se ela pertencer
à interface, ela também pertence ao blueprint e isso cria um problema Eu tenho que compilar isso primeiro, e agora este, e é Uh, vamos clicar duas vezes em resolvido e trazer o que resolvi
e conectei aqui Então, agora, sempre que resolvido estiver frio, retornaremos
nossa variável I resolvida. Como chamamos isso de “eu resolvi”? Vamos para nossa nova porta. Então, vamos
duplicar a porta do fígado. Vou chamar essa porta com
vários quebra-cabeças e vamos abri-la Muitas coisas não
mudarão aqui. A única coisa que
vamos
mudar é criar uma nova função. Vamos chamar isso de cheque de respostas
do quebra-cabeça. E também terá uma
saída booleana ou quebra-cabeças resolvidos. Ok. Vamos construir em seguida. Agora, o que vamos fazer é
usar esse evento de desbloqueio de portas,
que, como copiamos, tornou-se um evento normal Vamos até a interface. Vamos chamar a interface de uma. Isso aconteceu porque
duplicamos o projeto. Então, vamos ao
nosso evento, desbloqueie a porta e traremos as respostas
do quebra-cabeça de cheques. E se isso voltar a ser verdade, abriremos a porta. Se não, vamos falar
por aqui. E em vez de chamar
isso pelos interruptores, ligaremos quando
pressionarmos E e a porta estiver trancada. Então, quando terminar, seremos chamados de evento de
desbloqueio da porta. Agora, quando eu o chamo de
dentro da planta, Cedar não tem
esse envelope aqui, mas tem o alvo
em Isso acontece quando você está chamando
internamente um blueprint. Uma função de interface de modelo. Então, agora, para continuar com nossas
respostas do quebra-cabeça de verificação de funções, primeiro precisamos criar uma
referência aos quebra-cabeças, como fizemos com a troca aqui, precisamos fazer com a
porta e os quebra-cabeças Então, como fazemos isso? Vamos criar
uma nova variável do tipo actor object reference e vamos
chamá-la de quebra-cabeças Agora, por que quebra-cabeças? Até agora, usamos variáveis únicas,
o que significa que elas têm um
único tipo de contêiner. E por que dizer essa palavra contêiner? Porque temos mais três tipos
diferentes de contêineres. Se selecionarmos os
quebra-cabeças de variáveis e passarmos até aqui, podemos ver como criar essa matriz,
conjunto ou mapa de contêineres
variáveis , que são os outros três
tipos diferentes de contêineres Então, um contêiner
é um único. A segunda é matriz, a
terceira é definida e mapeada com regras específicas em cada uma. Mas a funcionalidade básica
permanece a mesma, mantendo uma lista de elementos, uma lista de variáveis, basicamente. Vamos usar array, que contém um
tipo de variável. mapa pode conter dois
tipos de variáveis, e definir é que cada variável basicamente na lista
deve ser exclusiva Agora, selecionaremos o primeiro
tipo de lista, a matriz, e mais uma coisa importante
sobre essas listas é
pensar que cada variável que elas contêm na lista tem
uma ordem específica. Por exemplo, se eu compilar isso, podemos ver quebra-cabeças
e elementos de matriz E se eu clicar em um elemento de
matriz, tenho um elemento de matriz aqui. Segundo, terceiro, e esses estão
em uma ordem específica. Isso é zero, isso
é um, isso é dois. O mesmo acontece o resto da lista
: eles mantêm uma ordem específica e sempre
mantêm essa ordem ,
a menos que a alteremos. Agora, quando eu disse que os atores do set precisam
ter um elemento único, isso significa que o primeiro elemento não deve ser o
mesmo que o segundo. Por exemplo,
se fossem números inteiros
, teria sido um, dois, três, não poderia ter
sido um, um, um Vamos demonstrar
isso por um segundo. Vamos mudar o
tipo de variável para inteiro. E vamos compilar, ver
se os elementos foram redefinidos. Então eu adicionei zero. Se
eu tentar adicionar novamente, não
consigo porque o
zero já existe. Se eu transformar isso em
um, posso adicionar. Se eu tentar transformar zero em
um, ele não vai me deixar. Se eu tentar transformar um em
zero, ele não vai me deixar. Então eu tenho que transformar isso para dois, por exemplo, e então
ele adicionou zero novamente. Então, quando isso continua, é muito contraproducente
preencher os conjuntos manualmente De qualquer forma, vamos
voltar à nossa matriz, que pode conter
várias vezes uma, por exemplo, precisa
compilar para fazer isso Várias vezes
zero, por exemplo, e deve ser do tipo
ator sem tipo. Ok, então uma variedade de atores. Então, temos essa pequena lista
bacana de atores, que não está preenchida Vamos torná-lo
editável por incenso e também o
exporemos no spawn Precisamos compilar
e depois acessar nosso mapa
e trazer nossos novos atores Vamos trazer dois fígados, um aqui e
outro aqui E vamos trazer a nova porta e
também uma porta com vários quebra-cabeças. Vou
substituí-los melhor mais tarde. Vou preencher a matriz do quebra-cabeça. Então, vou apertar esse
botão aqui, mais um, e vou selecionar
o primeiro para ser esse e o
segundo para ser esse. Agora, se a ordem
importasse, importaria a
forma como os selecionamos Mas, no nosso caso, vamos apenas
verificar se os dois estão resolvidos. Agora, não precisávamos realmente
criar os atores agora porque o código seria, na verdade, vamos
fazer o código. Vamos conferir o quebra-cabeça Acers e agora
traremos nossa nova variedade de quebra-cabeças Agora,
descobriremos um novo nó, que seria o
de cada loop. Agora, além dos quatro em cada loop, há também um loop de quatro e
um loop de quatro com intervalo e um de
quatro em cada loop com intervalo. E, claro, há
um reverso para cada operação. Agora, o que é um loop? Porque a palavra mais comum, como podemos ver aqui, é loop. Um loop permite que você repita as ações várias vezes, tão
rápido quanto possível. Como podemos ver, ele
tem uma execução em um loop corporal e um
nó completo como nós de execução. E tudo aqui é o mesmo,
com exceção do intervalo. A pausa é que podemos ligar alguma forma para parar
o que quer que isso esteja fazendo. Por exemplo, nas coisas em que estamos procurando algo
e o encontramos, podemos parar quando o encontramos
e completar o loop. E a outra diferença é que esses dois,
para cada loop com intervalo, temos uma entrada de matriz, enquanto esses são configurados
manualmente para fazer algo uma quantidade
específica de vezes. Por exemplo, se
quiséssemos que acontecesse duas
vezes, poderia ser um loop 0-1
porque loops e matrizes também são algo
importante e os outros contêineres começam
com zero como o primeiro índice, o primeiro número
dos elementos Teremos o elemento zero
e, em seguida, teremos o
elemento um e o elemento dois. Então, isso também é importante. Agora, vamos excluir isso e
fazer nosso loop for funcionar. Então, o que vamos fazer é, e aí vem a
mensagem resolvida. Vamos perguntar se está resolvido. Não, chamamos isso de resolvido. Sim, mensagem resolvida. Agora,
isso nos retorna, resolvido ou não, o quebra-cabeça que estamos perguntando. E também, apenas um lembrete de por que
usamos uma chamada de interface porque
essa é do tipo ator Então, isso significa que pode
se tornar tudo novamente. Pode se tornar um interruptor,
uma alavanca e um interruptor. Pode se tornar um botão
e um interruptor pode se tornar uma porta e um interruptor ou qualquer coisa.
Pode se tornar qualquer coisa. Já se tivéssemos
o tipo de classe em vez de ator aqui, teríamos uma alavanca P, uma alavanca Se tivéssemos essa, só
poderíamos que essa matriz contivesse apenas
portas hepáticas e
seríamos capazes de obter informações
diretamente para elas. Mas isso
possibilita a obtenção de qualquer ator que implemente esse tipo
de interface de blueprint Agora, vamos completar
a lógica disso. Vamos colocar uma ramificação aqui porque, se apenas conectássemos, o nó de retorno aqui, retornaríamos constantemente para cada corpo, se
fosse resolvido ou não. Mas essa função está prestes a verificar todos os quebra-cabeças, não apenas um Portanto, o nó de retorno deve
acontecer no final. Agora, o que faremos é que, na primeira vez que encontrarmos um
quebra-cabeça que não está resolvido, promoveremos
essa variável, mas uma variável local desta vez. Então, ele só existe
nessa função
e, na verdade, vamos
desconectá-lo Se um deles for falso, quebraremos
o loop quatro. Sim, use o loop
para loop com intervalo ou com intervalo. Ok. Com o controle, estou apenas
reconectando todos os pinos. Ok, então quando encontrarmos um
quebra-cabeça que não está resolvido, vamos desligá-lo e quebrar o loop quatro. Então, o que também precisamos fazer é dar a ele um valor
padrão de True. Então, se isso nunca quebrar, isso retornará
essa nova variável. Na verdade, vamos dar um nome a
ele também. Vamos dizer que está tudo resolvido. E isso o completará. Agora, vamos explicar um
pouco rápido novamente, desde o
início, o que estamos fazendo. Estamos resolvendo
nossos quebra-cabeças. Definimos uma
variável padrão, a variável local. Isso significa que
sempre que é executado, ele começa como resolvido. Mesmo se a desativarmos na
próxima vez em que for executada, ela começará do
zero porque é uma variável local. Agora, vamos analisar nossos
quebra-cabeças com um loop for. Verificamos se eles estão resolvidos. Se eles não forem resolvidos, desativamos essa variável, quebramos o ciclo e produzimos
o resultado Então, vamos testar essa loja. Vamos ajustar os interruptores. Coloque-os na parede.
Bem, não na parede, mas... Isso é só lá dentro? Não, também é o oposto. Então, nós o giramos. E a porta também é oposta. Sim, acho que está tudo bem.
Talvez um pouco. Dessa forma. Ok,
vou fazer com que os jogadores comecem. Vou movê-lo para cá. Não jogue. Vai usar
o único discurso? Oh, vamos sacudir a porta primeiro. Está chocalhando. Segundo
interruptor, e ele foi desbloqueado Ótimo. Então, terminamos
com essa porta também. Supostamente, não podemos fechar. Oh, talvez essa porta não
devesse abrir dessa maneira. Talvez e apenas vá para o gráfico de caneta. Oh, ele se abre em frente
ao player. Ok. Você sabe o que? Vamos deixar
como E. Se você quiser, pode jogar com o ângulo. Na verdade, podemos
simplesmente desconectar isso e ir para 90, eu acho Sim, eu não vou
deixar isso como E. Eu não
posso, me desculpe. Eu não
posso viver com as. Fazendo isso. Sim,
funciona corretamente. Porque colocar o
ângulo sempre 90 desativa basicamente a direção
calculada De qualquer forma, terminamos e
chegamos ao momento em que
faremos os itens de física. Vou te
mandar o próximo.
22. Programando um interruptor de pressão para ativação de porta: Olá, bem-vindo de volta
ao Unreal Engine five, ao
Blueprint Mastery, ao door Systems
e Anteriormente, terminamos
com nosso quebra-cabeça múltiplo, multiquebra-cabeça w.
Adicionamos dois switches e adicionamos uma interface, uma nova função de interface que chamamos de SLP, e implementamos isso quando o SLT é chamado porque é uma função
com um nó de retorno, ele retorna o
status ESL do Nomeei também com E salt a variável
resolvida que tínhamos porque chamei SL também de
variável da interface, que gerou um erro porque não
podemos ter dois nomes, duas variáveis com
o mesmo nome, uma que retorna e uma
variável do blueprint Depois continuamos e modificamos um
pouco, a porta do fígado. Na verdade, no final, removemos o ângulo aberto e ajustamos
90 para a linha do tempo. Dessa forma, contornamos
a seção calculada
e ela se abre em nossa direção e
não em direção às Também alteramos a porta de desbloqueio do
evento para verificar as respostas do quebra-cabeça. Agora, também chamamos
a porta destrancada de nossa interação porque os interruptores
não estão chamando a porta Vendo isso, também criamos essa função de verificação de
respostas de quebra-cabeças que precisava da
matriz de atores dos quebra-cabeças, que era a nova variável, a nova variável de contêiner
que encontramos O que é basicamente uma
lista em uma determinada ordem. Para preencher isso, adicionamos
o ator no mapa
e, a partir dos detalhes padrão do
ator que expomos essa variável, adicionamos dois com um símbolo de
adição aqui, elementos de
matriz, e
os escolhemos para serem essas duas opções Então, quando estamos verificando
se o quebra-cabeça foi resolvido, estamos usando um
loop de quatro idades, um novo nó que
usamos para examinar a lista de quebra-cabeças e perguntar
se eles foram resolvidos Se eles não forem resolvidos, temos uma variável local, o
que significa que, quando
a função é executada, sempre é redefinida para a variável
padrão, e o padrão é verdadeiro Então, quando sai de resolvido
e não está resolvido, volta às quedas e
quebra o ciclo de forragem Agora, é hora de
fazer as trocas. Então, vamos abrir nosso novo mapa. Nível oito. Oh, não colocamos
o texto aqui, e as colisões estão um pouco altas e as colisões estão um pouco altas
. Vamos consertar a
colisão primeiro Vamos selecionar os interruptores e
mover a caixa um pouco para
fora para facilitar
a colisão com o jogador Queremos fazer o mesmo com
a outra caixa. Sim, tudo bem, eu acho. Além disso, vamos aumentar um pouco a caixa da porta,
porque quando a porta estiver aberta, eu deveria conseguir
fechá-la um pouco mais e talvez torná-la
mais alta por causa das escadas Sim, acho que está tudo bem. Tudo
bem, vamos trazer uma mensagem. Vamos realmente duplicar isso. Tudo bem se o fizermos.
Vamos colocar o texto. Se eu clicar duas vezes no texto, ou se eu conseguir selecionar um texto enquanto
seleciono a planta, posso simplesmente clicar no texto Eu me concentro instantaneamente no texto e o trarei aqui. E vamos mudar o texto
para usar os dois. Ambos. Alavancas para destrancar a porta Tudo bem, vamos também trazer a
luz. Onde está a luz. E a colisão, vamos
transformá-la um pouco assim. Talvez em algum lugar aqui. Sim, acho que está tudo bem. Então, quando entramos, uh, sim. Acho que se eu viesse
de K, tudo bem. Acho que simplesmente entro nela. Sim. Use os dois rios
para destrancar a porta. Oh, há dois rios
aqui. Ótimo. Agora, nova sala, vamos começar
com os itens de física. Vamos fazer essas coisas se moverem
porque isso é mais engraçado. Então, vamos selecionar todos eles. E é bem simples. Podemos simplesmente ir aos detalhes. Vou pesquisar física. Simule a física e
deixaremos as configurações como porque
elas são
perfeitas para o que queremos fazer Então, agora, se eu for até eles, talvez
devêssemos começar. Então agora eu posso empurrar
essas caixas. Ótimo, mas devemos fazer o
pequeno quebra-cabeça com as caixas. Isso não é suficiente. Então, o que vamos fazer é
criar um switch, primeiro de tudo, usando
essa malha aqui. Então, deixe-me voltar para o quarto. Vamos para o conteúdo e
vamos para Blueprints, clique com o botão
direito do mouse em New Blueprint
class type actor E vamos chamar esse interruptor BP. Sim, porque esse
é o interruptor. A outra era a alavanca. Uma delas é confundir essas duas. Agora, vamos abrir o switch BP e adicionar à malha Srtic Isso vai duplicar
isso. Selecione o primeiro. Vou ancorá-lo aqui. Vamos até os interruptores. Detalhes. Física. procurar essa malha estática. E vamos implementá-lo até o
número um, na verdade. Então esse é esse e
aquele sem número
seria a base. Pesquise novamente
aqui e implemente. Tudo bem. Agora, a próxima
coisa que precisaremos é, obviamente,
de um hub de colisão Então, caixa de colisão. E vamos
escalá-lo para ser do tamanho
do tijolo interno e
empurrá-lo para cima até o ponto em que ele não toque na caixa,
porque não queremos ele seja acionado
pela própria malha estática Então, também vamos
fazer com que seja fino assim. Talvez um pouco mais fino. Eu vou desativar. Eu posso
realmente fazer isso daqui. Eu vou fazer isso 2.2. Não, 0,16. Sim,
acho que está tudo bem. Então, algo precisa
entrar em
contato tão próximo para ser considerado
que está no interruptor. É para isso que
vamos usar isso. Isso é o que
diremos a
esse plano : o switch
precisa ser desativado. Há
algo em você. Então eu acho que esse tamanho, perto da caixa está bom. Ok, vamos ao gráfico de eventos e precisaremos que
os dois eventos de sobreposição comecem e terminem se
sobrepondo nesta caixa Então, obteremos a sobreposição inicial e
obteremos a sobreposição final Agora, desta vez
não faremos a fundição ou o outro componente etiqueta porque
teremos dois interruptores. Teremos que
voltar para o nosso quarto. Vamos trazê-los
para o nível do jogo. Então, um switch estará,
por exemplo, aqui, e digamos que o outro
switch talvez esteja aqui. Sim, vamos colocá-lo aqui. Então, um, teremos que
colocar uma caixa nele, e o outro,
teremos que ficar de pé sobre nós mesmos, e então a porta se abrirá. E quando
sairmos do gatilho, a porta descerá. Então, teremos um
certo
tempo para passar por essa porta. Então, se começarmos aqui, talvez haja mais
chances de falhar. Mas, basicamente, estamos criando uma pequena
mecânica de jogo aqui ao mesmo tempo Então, como há uma chance o ator estar
em cima do switch e uma caixa ao mesmo tempo
estar em cima do switch, podemos usar algo
diferente dessa vez. Vamos voltar ao switch, pegar nossa caixa
e
pegar atores sobrepostos, o que nos dá uma lista
com tudo
que se sobrepõe à caixa, nos dá uma lista
com tudo
que tudo o que
se sobrepõe a essa colisão aqui Existe um
filtro de classe se precisarmos apenas pesquisar um tipo específico, e isso retornaria apenas uma
lista dessa classe específica. Mas para nós, cuidamos
de quase tudo. Então, o que
faremos é usar, como você pode ver, esse ícone aqui
também é um ícone de matriz. Isso nos indica que, se
voltarmos para a porta de vários
quebra-cabeças, veja, temos esse ícone aqui,
enquanto aqui, o temos
com uma caixa vazia no meio Basicamente, essa caixa vazia é
apenas um símbolo de conexão. Então, se eu ler em voz
alta, por exemplo, aqui, podemos ver que a caixa foi preenchida, mas está vazia. É só para dizer que isso não está
conectado a algo. O que vamos fazer
é obter o comprimento dessa matriz. E se for igual a zero, então fazemos algo
ou não fazemos algo falso ou falso Basicamente, na sobreposição,
se não for zero, criaremos uma linha do tempo qual reproduziremos a animação Na sobreposição final, se for zero, reverteremos a animação Mas acho que esse é um bom ponto de
parada para este. Te
vejo na próxima. Adeus.
23. Projetando uma porta de portão com sistemas Blueprint: Olá, e bem-vindo de volta ao Unrealizing five Bluepin
Mastery Door Systems e portais Unrealizing five Bluepin
Mastery Door Systems e portais interativos. Anteriormente, terminamos
com as colisões da porta multiquebra-cabeça A loja que pega
esses dois quebra-cabeças, esses dois interruptores
para abri-la Agora, também adicionamos esse texto,
esse esquema de fluxo de texto que
iluminaremos esse texto, e continuamos
ativando a física
nessas caixas e
criamos o esquema do interruptor, qual adicionamos duas medidas
estáticas para
representar a parte inferior e a parte superior
do interruptor e uma colisão de caixas que a transformamos em
forma de paralelogramo de três D acima da parte inferior, uma
muito forma de paralelogramo de três D acima da parte inferior Em seguida,
usamos os eventos de sobreposição inicial
e sobreposição final dessa colisão
de caixa Criamos uma filial em
que a questão, desta vez é que estejamos recebendo todos os atores
sobrepostos E se esse comprimento for
maior que um, perguntamos se isso é
basicamente verdadeiro ou falso, mais que zero ou menor que
zero, porque é igual. Então, se fosse menos, é
impossível ser menos, mas se fosse menos, ainda seria verdadeiro do que falso. Se quiséssemos ser
zero e acima, poderia estar abaixo,
igual a zero. Isso seria cobrir
o abaixo de zero. Então, vamos adicionar a linha do tempo. Vá para desenhar o cabo e
pressione Adicionar linha do tempo. Agora, vamos entrar na linha do tempo e criar um caminhão de fluxo Vamos criar dois pontos. O primeiro,
é claro, zero, zero, e o segundo,
digamos, 0,5, dois, um. Vou ajustá-lo com
esses dois botões e usar o quadro-chave La para
compilar e salvar Agora, o que faremos na atualização? Bem, semelhante
à rotação de mudança que usamos desta vez,
defina a rotação relativa. Desta vez, usaremos
definir localização relativa. Vamos obter a
primeira malha estática. Vamos definir a localização
relativa. Vamos
conectá-lo para atualizar. E vamos dividir esse vetor porque
só queremos mudar o Zen. Então, para isso, vamos usar o larp e vamos
conectar o Alpha aqui Agora, para o valor, precisamos de 02 talvez menos dez Sim, menos dez é bom. Então vá para desfazer. Então, menos dez. E isso faria com
que caísse. Se formos testá-lo,
vamos apertar play. E eu pisei
nele, ele caiu. Agora, não sobe,
talvez devêssemos colocar isso um pouco mais
no chão, porque o personagem não parece ser
capaz de subir com facilidade. Então, acho que essa
caixa também será difícil. Sim. Então,
vamos pegar isso. Vamos empurrá-lo até aqui e vamos
fazer os mesmos obstáculos O mesmo para este.
Vamos apenas insistir assim. Sim. Tudo bem. Agora, vamos voltar
ao modelo e criar a direção
oposta Então, vamos usar
a mesma pergunta. Vamos copiá-lo,
colá-lo e colocá-lo aqui, e então vamos
usar o inverso. Então, vamos
compilar e salvar, e vamos testá-lo. Vamos compilar e
apertar play. E desce, sobe. Desce, sobe. Ótimo. Agora, como temos um lingote no fígado que diz
que está resolvido, o mesmo que precisamos
para essa troca Então, vamos criar essa
variável resolvida, e vamos trazê-la até aqui. Agora, quando a linha do tempo
terminar e continuar,
então mude a direção da linha do tempo,
vamos configurá-la então mude a direção da linha do tempo,
vamos configurá-la Está resolvido de duas maneiras. E, na verdade, também podemos
mudar o material. Vamos pegar a de malha
estática, que é nosso pacote de adereços, a caixa de gatilho,
essa, a laranja E vamos ajustar material. Não
precisamos de duas referências, material
fixo, e
isso é, eu acho, pressão da placa de
pressão ligada. E vamos
copiar isso também e ativá-lo quando
sairmos da caixa de gatilho. Bem, quando a caixa do gatilho não
tem nada sobre ela, também
precisamos
resolver a venda. Quando saímos. Não vamos esperar até que
todo o cronograma termine. Bem, na verdade, isso é
mais um design de jogabilidade. Por exemplo, se você esperar o término do cronograma e depois desativá-lo, ou se você o desligar
diretamente ao sair, escolha
é do desenvolvedor Não é uma coisa obrigatória. Então, estamos fazendo isso quando saímos instantaneamente, em vez de esperar que o
botão toque E isso deve ser um plano de placa de
pressão, não ligado. Tudo bem. Então, vamos testar isso.
Fica verde, fica normal. Fica verde, fica normal. Veja, se eu passo muito rápido
, ele gira mais rápido porque continua
tocando de onde estava. Agora, vamos colocar uma caixa em um botão e ver
se não funciona. O motivo pelo qual isso não
funciona é que, por padrão, essas caixas em suas configurações de
colisão têm a geração de
eventos de sobreposição desativada Se eu ligar isso, significa que essa caixa não
ignorará essa colisão. Mas não queremos que isso
aconteça em todas as caixas. Só queremos essa caixa, aquela com as cores
e diz push. Então os outros não fazem nada, e esse nós fazemos alguma coisa. Então, vamos ativar isso para
gerar eventos de sobreposição. Vamos compilar, apertar play, apertar essa
caixa e funcionou E se eu sentar aqui,
isso também funciona. E o próximo passo seria
fazer com que tudo funcionasse em conjunto
e criar a porta. Agora, vamos continuar com isso apenas para demonstrar
que não está funcionando. Sim, não está funcionando, mas se eu pisar, está funcionando. Então, vamos continuar duplicando
nossa porta multiquebra-cabeça. Então, vamos até nossa porta
multiquebra-cabeça, alguma forma para encontrá-la Eu posso pressionar
aqui. Não, na verdade, eu preciso dele no navegador
de conteúdo. E do jeito que estou indo manualmente. Ah, sim, esse botão aqui. Se eu pressionar esse botão,
ele me levará até ele. Então, duplicando isso,
vamos chamar
essa porta multiinterruptora BP.
Vamos abri-lo. E o que não
precisaremos, não precisaremos de uma entrada. Essa porta se abre sozinha e não precisaremos de um chocalho Isso não será necessário. Precisaremos da porta destrancada. E não precisamos
do começo, na verdade, podemos criar
um widget para essa loja, como fazer algo
para abrir essa porta Então, basicamente,
vamos atualizar o Widget. Esta loja terá dois estados. Terá sido fechado. Vamos definir fechar por padrão
e, em seguida, abrir,
fechar e abrir básicos. Mas vamos fechar e
abrir. Realmente não importa. Então, quando estiver fechado,
diremos, mas os dois botões
precisam ser pressionados. Vamos capitalizar os primeiros. Na verdade, não é
preciso ser pressionado em todos os outros casos, não
precisamos dizer nada. Então, ao compilar save, temos um erro porque estamos chamando rattle quando não há E, claro, não
precisamos da parte frontal. Não precisamos
calcular direções. Não importa que seja usado. Vamos
excluí-lo onde for usado. Então, precisamos que quando está
aberto esteja abrindo, quando está perto de
quando está perto de abrir, quando está aberto para fechar. E não precisamos realmente
ser do começo ao fim. Precisamos que continue
de onde estava. Então isso vai funcionar, e isso vai se inverter
porque essa porta
vai descer quando os
dois interruptores estiverem desligados, e quando os dois estiverem
ligados, ela se abrirá. Então, nós queremos, no entanto, que ele toque um som
quando estiver fazendo isso. Então, vamos tocar som. E toque som. O primeiro
seria o elevador de porta e o outro
também será o elevador de porta. Mas queremos que
aquele que está
descendo tenha um som um
pouco mais profundo, então ele vai para 0,8 polegadas. Então, parece mais profundo. E isso acreditará nos usos, e
isso seria a partir dos sons. Agora, a próxima coisa que precisamos
fazer é realmente
mudar esse modelo. Então, vamos
encontrar nosso modelo aqui, que não
tem certeza de qual aqui está. Isso deveria ser
um pacote de adereços. Eu vou encontrá-lo daqui. Sim, nós o encontramos. E
vamos aqui e colocá-lo. Está girado de forma errada,
mas isso não importa. Só que eu não
gosto do lado. Oh, tem o material errado. Sim, porque eu
troquei a porta, mas o material
foi mantido o mesmo. Agora, posso pressionar isso
aqui para retornar ao padrão. E isso é algo
que aconteceu. Se você alterar a malha,
o material será mantido o mesmo da malha anterior menos que você tenha
um material padrão, que o altere para o
material padrão da nova malha. Mas se você substituiu o material
na malha anterior, ele manterá o material
substituído De qualquer forma, vamos
continuar, vamos trazer a porta um pouco
mais para o meio. Acho que está tudo bem. Vou pressionar um pouco para cima. Ok, compile e salve. E vamos trazê-lo
para o mapa também. Vá para as plantas, vá para as portas
e troque a porta com vários interruptores Poderíamos ter chamado
isso de outra coisa. O lado da frente é
o lado da frente, certo? Cook poderia ser um
pouco maior. Poderíamos fazer isso um pouco. Isso o estica um
pouco, mas sim, vou fazer com que eu
goste um pouco maior. É muito grande agora. Nunca, como você pode ver, nunca faça isso na planta porque quando você está fazendo
isso com o ator inteiro, você também está fazendo
menos do que as colisões Portanto, mesmo que pareça bom, pode não funcionar corretamente. Então, se eu quisesse fazer isso, eu tinha que ir até o
próprio adereço e depois fazer isso Sim, acho que está tudo bem. Tornando-o um pouco maior
e um pouco menor. Eu também posso fazer isso dentro
do loop. Eu posso desfazer todas essas mudanças
e simplesmente fazer isso aqui. Tudo bem. Vamos tornar a caixa de colisão
um pouco maior também. Tudo bem. Então, isso também deve ser
um pouco maior. Ele. Agora, essa porta
só será destrancada dessa maneira Então, se começássemos dessa forma, teríamos sido bloqueados. Isso não importa. Agora, eu
acho que é isso para este. Na próxima,
vamos fazer a codificação para fazer os dois
interruptores, abrir a porta Adeus.
24. Implementando truques para a mecânica de portas com interruptores de portão: Olá, bem-vindo de volta ao Unreal Engine, cinco portais
Blueprint Mastery, Door Systems e
Interactive Anteriormente,
quase terminamos com o visual de nossa porta deslizante,
deslizando para cima com a mecânica de vários Agora, o que fizemos foi terminar com a linha do tempo,
jogando desde o início, jogando ou revertendo com a sobreposição dos eventos de início
e E quando acabou, dissemos que estava resolvido. Mas quando acabamos com a sobreposição, dissemos que ela não é
resolvida instantaneamente Também estamos alterando o material e usando a localização relativa
definida. Também duplicamos
nossa porta com vários quebra-cabeças e excluímos algumas coisas, e mantivemos a
animação da porta, o Adicionamos um som de reprodução e o
conectamos para tocar e
reverter , em vez de tocar do
início e reverter do final. Também excluímos a entrada E. O que precisamos excluir
é o widget add Door. Na verdade, não
precisamos excluir completamente o widget Addo Deixe-me desfazer. Ok, precisamos adicioná-lo a fechado porque somente
quando a porta estiver fechada, queremos que ele mostre o widget Agora, pensando nisso, deve
haver um bug em todo lugar. Então, vamos jogar e testar
um pouco. Acho que há um
bug de que, quando
estivermos fechando a
porta e nos afastando, mostrarei o widget.
Então, estou fechando. Sim. Porque estamos
adicionando o widget, irrelevante para saber se estamos
dentro da colisão Então, para corrigir isso, precisamos mudar algumas coisas. Mas vamos
fazer isso mais tarde. Agora vamos continuar
com a porta. O que vamos corrigir é adicionar algumas regras aqui
e, em cada projeto, enviaremos apenas uma
referência ao ator Agora vamos continuar
consertando a
porta multiinterruptora e concluindo-a O que precisamos fazer é ir
até nossa porta destrancada. Em primeiro lugar, vamos torná-la uma interface porque a
duplicamos Então, vou
clicar duas vezes em Unlock Door, criar o evento de interface. Vou trazê-lo aqui
e deletar este. Agora, o que precisamos verificar
é atualizar o texto do widget e alterá-lo para remover o widget Então, vou copiar
o código daqui. Vou colá-lo aqui. Então, quando estamos
destrancando a porta, o widget sempre é removido, mesmo que esteja na vista E, claro, chame animação
da porta porque,
quando estamos desbloqueando, precisamos chamar essa A próxima coisa que
precisaremos é de uma porta com fechadura, a mesma, mas para trancar Então, vamos
voltar às nossas portas de BI e
criar um novo evento, uma nova função, e vamos
chamar essa porta fechada. E
vamos até nossa porta e vamos chamar
o evento de interface. E o que precisamos a partir daqui, isso realmente
precisa ser fechado, sim. Então, quando estiver fechado e executar a animação da porta,
ele será aberto. Então, precisamos do oposto disso. Não precisamos do
som aqui porque já
estamos tocando
um som aqui. Também não precisamos da mudança de
material. Então, havia algumas coisas
que precisávamos remover, mas precisamos de todo o resto. Bem, na verdade, também não
precisamos do widget de remoção. Então isso precisa
ser girado para aberto, e então estamos executando a animação do cachorro, que
quando estiver pronta, será aberta, então reproduzirá o som fechado e
reverterá de onde quer que esteja. Agora, precisamos
convocar esses eventos. Na verdade, não precisávamos disso, então estou lidando com o
que chamamos esses eventos Bem, muito simples no
switch que criamos. Quando terminamos de
pressionar o botão, ligamos, bem, precisamos de
uma referência para a porta, então vamos
criar uma variável. Vamos fazer
isso do tipo ator e podemos fazê-lo do tipo ator porque temos a interface
blueprint Vamos chamar essa porta e torná-la
editável por instância e expor no spawn para que possamos editá-la a partir do editor e também
ao gerá-la a partir de Vou selecionar isso
e selecionar a porta e selecionar isso e isso e
selecionar a porta também. Então, agora temos uma
referência à nossa porta. Onde está o interruptor aqui. E vamos receber
essa referência de porta
e a mensagem de porta destrancada Envie a
mensagem da porta destrancada aqui. E então precisamos enviar
a mensagem de registro aqui. Então, estamos acabando com a sobreposição. Estamos informando que
isso não foi resolvido, estamos configurando como não resolvido e estamos enviando Lock E quando
começamos a se sobrepor, quando a linha do tempo termina, enviamos Unlock Door Agora, teoricamente, isso deve
funcionar. Vamos dar uma olhada. Preciso empurrar essa caixa primeiro. Tudo bem. Eu toquei o som, ele não deveria ter
tocado o som. Então, uma boa situação
para usar o depurador. Vamos ver o que está acontecendo. Então eu vou encontrar a
porta, interruptor de várias portas. Eu vou ejetar. Eu vou
trazer isso aqui. Vou
desencaixá-lo, corrigir o zoom. Faça isso um pouco menor. Faça isso um pouco
maior, um pouco mais. Aqui está. Selecione a porta
multiinterruptora. Assim de novo.
Voltar ao tutorial. Vamos ver o que funciona. Um oito para retomar. Então, tudo bem, primeiro de tudo, está
fazendo rotação, o que não deveria ser. Mas por que está funcionando e
vai injetar novamente. Então, o problema está aqui, passa
que o
quebra-cabeça está armazenado. Bem, agora, isso deve
ser resolvido porque
temos isso. Mas aqui, passa que está resolvido, o que não é verdade. Não temos um quebra-cabeça de matriz, então é por isso que está acontecendo. Diz que é verdade
porque
não há peças selecionadas do quebra-cabeça. É uma bolsa interessante. Então, talvez seja necessário um código
que, se for zero, não
deveria ser aberto. Vamos mover isso para o switch. Tudo bem, eu não abri. Eu me mudo para cá, mas isso ainda não acontece. Isso acionou o
pulso, então está tudo bem. Ok, primeiro de tudo, vamos
mudar a coisa da rotação. Não deveria girar. Além disso, eu esqueci disso. Não devemos definir a rotação
relativa e fazer isso no plano
errado Vou voltar
para o switch também. Portanto, excluindo a
localização relativa, mantendo a cotovia, excluindo o ângulo aberto,
defina a Conectado aqui, conectado aqui, dividido o novo local,
conectado aqui. Portanto, a
localização original da porta é próxima. Isso é um pouco complexo, então devemos
salvá-lo no início do jogo, fazer a promoção de localização relativa à variável e
conectá-la aqui. Begin salva a variável. E vamos
trazer essa variável. Vamos fazer uma pausa dividida. Vamos conectar o X aqui. Vamos conectar Y aqui porque queremos que eles
permaneçam os mesmos. E de Z, queremos que
isso seja dois -13. Digamos que 260
Rackley parece bem. Veremos no
espaço de palavras mais tarde até 60. Então, agora a porta não
deve pelo menos girar. Não sobe porque
precisa que isso seja resolvido. Mas acho que havia um bug que não
estava surgindo de qualquer maneira. Ok, um novo parêntese. Vamos criar um código para colocar esse tubo nessa
posição sempre que quisermos. Vamos copiar essa
localização do tubo. Vamos ver o esquema de
nível em que
criamos esse código
aqui e vamos escolher o teclado E vamos
clicar e criar uma referência para essa caixa
porque eu a selecionei. E eu vou definir a localização. Preciso colar isso aqui. Na verdade, vou
promover isso para uma variável e compilar
e colar aqui Agora, veja, eu poderia colar todo
esse vetor porque ele
é um vetor, basicamente. Eu posso copiá-lo daqui e simplesmente colá-lo em uma nova variável. Não consegui colar
aqui, não tem como
colar aqui. Eu posso colar no X, mas ele cola
tudo em uma caixa. Então, apenas conectando isso, vamos chamar essa localização da caixa. E vamos conectar isso aqui. Então, basicamente, agora, se eu mover essa caixa, pressionar 1, ela volta para cá. Ótimo. Agora, poderíamos criar alguns códigos para colá-los
exatamente onde quisermos. Então, vamos fazer isso para o número dois. Como fazer isso? Eu
vou colocá-lo lá. Eu vou ejetar.
Vou selecioná-lo. Vou copiar
novamente esse local porque, se eu mover essa caixa agora, ela ainda mudará de local. Ele é atualizado ao vivo. Então, vou parar de
jogar e acessar o Mapa
Tutorial e
pressionar o teclado dois. E vou criar um
novo vetor de tipo variável. Vou compilar,
colar o novo valor, chamá-lo de caixa, gatilho ,
localização e vou
duplicar esse E é uma boa oportunidade
de te mostrar outra coisa. Quando tenho um vetor como esse, posso clicar com o botão direito do mouse
no vetor e dizer, substituir a variável pela localização do gatilho da
caixa. Então, se eu tivesse outros vetores aqui
também, vamos adicionar mais, mais dois Eu poderia substituí-los por eles. Então, se for do
mesmo tipo de variável e você estiver no
mesmo esquema, você pode ter essa
opção aqui Então, a localização do gatilho a
coluna precisam conectar o alvo, porque quem
estou definindo a localização? Vamos jogar, e eu sou
incrível em empurrar caixas. Tudo bem. Eu acho que isso
é suficiente para este. Vamos depurá-lo
na próxima lição. Eu
vou te ver então. Adeus.
25. Depurando e otimizando o sistema de porta de comutação de portão: Olá, bem-vindo de volta
ao Unreal Engine five, Blueprint Mastery Door Systems
e aos portais interativos Anteriormente,
quase terminamos com nossa
porta multiinterruptora que desliza para cima. Agora, eu meio que percebo o
que aconteceu de errado. Nos switches, não foi
eu que coloquei a interface, então precisamos colocar a interface
I VidOr E na função resolvida, precisamos conectar o que está resolvido e parece que, por engano, quando clico na porta
e desfaço algumas ações, removo as peças do quebra-cabeça, então vou adicioná-las novamente O primeiro é esse
interruptor aqui, e o segundo é
o interruptor aqui. Certifique-se de ter
selecionado os interruptores e não o chão ou a parede. Então, teoricamente,
agora deveria funcionar. Então, se eu pressionar dois,
o telepe fica lá, e se eu ficar aqui, ele
sobe muito, muito rápido Então, desce muito, muito rápido. Então isso não
me dá tempo suficiente para correr. E o widget é um
pouco, como você pode ver, de trás que
ele
apenas o mostra, mesmo eu não esteja sobrepondo, o
que corrigiremos Agora,
também não diz nada enquanto a porta está fechada. Então, vamos consertar essa caixa. Vamos começar com o widget que mostra E quando estou
sobrepondo E, na verdade, vamos torná-lo
um pouco maior também. Então, como essa história
é só assim, vou
trazê-la aqui e torná-la um
pouco menor. E tudo bem. Agora, por que o
widget não diz nada? Basicamente, como o padrão
é fechado e não fechado, dizemos nada, e eu fico chateado
em abrir para dizer alguma coisa Então isso é um erro. Agora, diz E, mas não vamos nos preocupar em consertar
o E. Ambos os interruptores precisam estar ligados Então aperte dois, agora
ele deve apenas dizer E. não, não deveria
porque está fechado. Então, o que vamos
fazer é tornar a linha do tempo um pouco maior. Essa é a correta? Agora, essa não é
a correta. Porta com vários interruptores. Aqui está. Vamos até a linha do tempo. Defina esses dois. Vamos
esperar um pouco. Digamos que 5 segundos. Mas isso significaria 5 segundos para subir e 5
segundos para descer. Então essa seria uma porta lenta. Então, eu vou pressionar dois. Essa é uma porta
lenta, subindo
lentamente e descendo lentamente. Tudo bem, agora, vamos consertar a
bolsa que, quando eu me levanto, ela reproduz o som O que vamos fazer é corrigir isso, e vamos usar
um novo nó para isso. Vamos até nossa porta, porta vários interruptores aqui De perto. Não, em aberto. Então, basicamente, quando
fecharmos a porta, obteremos a linha
do tempo em si, o que não fizemos antes O cronograma também é uma variável. Podemos encontrá-lo no esboço
do componente. Podemos encontrá-la como
uma variável em si. Portanto, essa é uma referência
à linha do tempo. E se dermos um nome à nossa linha do tempo porque ela
também está disponível, podemos pressionar F dois
na linha do tempo
e dizer linha do tempo da animação Como você pode ver, isso também
muda aqui. Então, se tivéssemos
vários cronogramas, poderíamos encontrá-los aqui Então, eu vou pegar isso
como uma variável getter e vou obter a posição de
layback Então, o que a posição de
Clayback faz? Basicamente, ele obtém
a hora atual da linha do tempo
quando está sendo reproduzida, tem uma hora atual e a retorna Então, o que vamos fazer é
usar uma ramificação. Vamos fazer
uma nota igual aqui. Se for zero, então não jogue. Não toque o
som, basicamente. Vamos conectar isso aqui e false aparecerá aqui
porque já está sendo reproduzido. Quando não estiver jogando,
vamos reverter. Não há motivo. Há um
motivo para reverter porque
estamos definindo o estado fechado porque
estamos configurando como aberto aqui. Então, vamos testá-lo. Sem som. Então está funcionando. Há som. Há som. Se eu colocar isso de volta, não
haverá som. Então funciona. Agradável. Vamos trazer a caixa de texto. Vamos trazer um novo porque
eles foram modificados demais. Vamos começar com
o texto flutuante onde devemos colocar isso
e colocá-lo aqui. O que vai dizer? Em primeiro lugar, digamos que ele diga que
é uma porta deslizante Eu não selecionei isso. É uma porta deslizante. Tudo bem. Vamos
colocá-lo ali. Também vamos fazer com que seja
um turno de entrada. Talvez eu o torne um
pouco menor também. Sim, isso é bom. Vamos trazer a luz também. Eu acho que está tudo bem. E a colisão. Quando o jogador deve colidir com isso Hmm. O que você quiser. Eu vou fazer
algo assim. E eu acho que está tudo bem.
Talvez mais assim. Sim, tudo bem.
Então, vamos embora Esta é uma opção deslizante. Vemos isso quando estamos
entrando daqui, vemos isso, é
uma porta deslizante e resolvemos o quebra-cabeça Ótimo. Agora, para
resumir o que fizemos, criamos um switch Blueprint, qual adicionamos a
interface das portas de BI No gráfico de eventos,
criamos uma animação
com uma linha do tempo e acionamos os eventos na sobreposição inicial e na sobreposição final. Com base nas regras, eles enviam uma mensagem
para a porta dizendo que eu estou resolvido e tento
destrancar a porta ou não estou resolvido
e trancar Em seguida, criamos a
planta da porta, que é a porta com vários interruptores E com base na mensagem
que está enviando, ele está destrancando a porta, que está tentando
abri-la reproduzindo a animação da
porta, ou se ela está sendo trancada, inverte a animação
e está trancando Agora, vamos continuar
para a próxima sala. Vamos abrir
o pequeno olho. Portanto, provavelmente há
algo errado aqui. Então, vamos
abrir os dois olhos. Nível nove e nível dez.
Basicamente, está tudo bem. Nível nove, nível dez, realmente não
importa. Então, aqui, o que
vamos criar? Vamos criar o mesmo mecanismo, mas com duas portas que elas
vão subir e descer,
e teríamos três botões
que precisariam ser
pressionados em ordem. Além disso, teremos também um plano separado que
decide se esse quebra-cabeça
está resolvido ou não E a porta estará
se comunicando com esse gerente, e o gerente estará
se comunicando com a Portanto, os botões em si não
terão interação
com a porta em si. É outro exemplo de como fazer um mecanismo
que abre uma porta. Mas acho que antes de
continuarmos, devemos corrigir esse bug que é
ativado após o
fechamento da porta e consertar todo o
resto, porque fazer isso no
final será mais trabalhoso em
cada projeto Então, aqui, a
planta aparece. O widget é exibido. E vamos fazer isso
na próxima lição. Adeus por enquanto. Te vejo então.
26. Trabalho de base para uma porta de correr de quebra-cabeça de botões: Bem-vindo de volta ao
Unreal Engine five, Blueprint Mastery, sistemas de portas
e Anteriormente, terminamos
com nossa porta deslizante, nossa porta com vários interruptores, dissemos antes de entrarmos
na porta do botão e gerente fixar
o
widget em todas as Então, vou
fechar tudo aqui com o canto superior
direito à direita, e vou abrir cada porta em sua própria
ordem. Não importa. Só queremos
ter todos eles prontos. E eu vou economizar. Além disso, precisaremos do modo de jogo em
terceira pessoa,
que encontramos no modo de jogo Blueprints em terceira
pessoa Então, temos esse
widget de porta, no Door Widget. E a partir desse widget Door
at Door, podemos realmente encontrar referências onde quer que estejam
usando o botão direito do mouse, encontrar referências por nome
e, em seguida, usando esses dois
vernáculos Então, usando isso, uma nova pesquisa será aberta e
nos mostrará em todos os lugares onde essa função existe, esse evento existe. Então, o que podemos fazer
é criar uma entrada aqui que chamaremos. Será o componente de colisão tipo
caixa. Acho que essa colisão de caixa
seria , deixe-me ver, componente de
colisão. Agora, acho que a
colisão de caixas funcionará bem. Então, vou dar um nome a essa caixa. Collider, talvez precise de L, para ser honesto. Não tenho certeza. Vou deixar isso
como não importa. E eu vou conseguir atores
sobrepostos desse
colisor E vou
verificar com
a classe do personagem em terceira pessoa, se isso é obter comprimento, claro, apenas comprimento,
não obter comprimento. E se estiver acima de zero,
vou trazer um galho. Vou adicionar uma janela de visualização. Então, espero que isso
resolva o problema. Agora, a única coisa
que precisamos fazer é acessar cada planta e encontrar as portas de anúncios que
podemos realmente encontrar na caixa
de pesquisa, onde foi a caixa de pesquisa Eles o fecham. Talvez eu o tenha
fechado. Aqui está. Então, podemos
clicar duas vezes em cada um
deles , abrir o
colisor de caixas e clicar no
próximo, no modo de jogo Então eu vou pegar este e pegar o colisor de caixas Então, dessa forma, não
perderemos nenhum deles. Na verdade, não precisamos pesquisar manualmente. Podemos simplesmente ir a cada evento. Agora, isso não é recomendado. Pode haver
maneiras melhores de fazer isso. Mas foi uma boa maneira de adicionar
a pesquisa ou os projetos. Como se tivesse criado uma
razão para fazer isso. Bem, essa não é uma opção
muito boa, mas espero que funcione. Não é muito, mas
é uma quantidade formidável. Eu conectei
o correto? Sim. Por fim, esses dois, e não há
mais nada na lista Sim, esse é o último. Então, acho que desta vez, vamos testar o distrito
dois aqui,
outra porta com brinquedos, outra porta com brinquedos, e ela não adicionou os widgets
porque eu não estava Então, acho que
se eu estiver aqui,
sim, ele o atualizou Ótimo. Agora, pelo que vejo, enquanto
está abrindo ou fechando, ele ainda mostra o E, que é um comportamento que
não queremos que ele faça. Então, mais alguns problemas para resolver, iremos para a
porta com vários interruptores. Esse é o único. Então, quando eu estiver bem. Então, se eu estiver fechando, talvez devêssemos
adicionar isso a todos os lugares. Mas está tudo bem. O que precisamos fazer é
adicionar esse estado de interruptor aqui e dizer que se a
porta está fechando ou abrindo, na verdade, só para esta,
eu acho, não para tudo. Não precisamos mostrar
ou fechar o widget. Não importa. Vamos
continuar com a próxima porta. Agora, vamos começar a criar
os ativos para a nova porta. Então, vamos precisar de
um plano de ator que chamaremos
de botão PP Vou ligar
. Vou precisar
também de um plano de ator
que chamaremos de gerenciador
de quebra-cabeças PP E então vamos precisar
de uma nova porta. Então,
vamos até nossas portas e duplicamos a porta com vários interruptores Vou chamá-la de porta de quebra-cabeça de
botões. Agora, vamos salvar automaticamente
desde que ele apareceu. A forma como isso vai
funcionar é que
teremos primeiro lugar, a porta, que não será,
mas realmente não importa. Isso vai mudar mais tarde. Nós vamos ter
a porta,
vamos ter que salvar isso. Então, vou guardar tudo,
algo que esqueci de dizer. Esse botão diz tudo, mas também podemos controlar as mudanças E também podemos encontrar
salvamentos aqui aqui. Então, vamos precisar de três
botões. Vamos voltar. Vamos trazer três botões. Um, dois, três, na verdade, dois, três, e vamos precisar também do gerenciador de botões,
o gerenciador de quebra-cabeças. Eu vou trazer
isso aqui. Isso pode estar em
qualquer lugar neste mapa, realmente não
importa. Mas eu vou
colocá-lo aqui, então sabemos que é o gerente. Agora, do jeito que
vai funcionar, é que os botões
saberão sobre o gerente e o gerente
saberá sobre a porta. Na verdade,
é assim que vai funcionar. Vamos criar essas referências. Então, vou fechar tudo aqui e abrir os botões, o gerente e a porta. Desconecte os botões. Ok, eu
preciso trancá-los aqui. Não é uma janela separada. Tudo bem E não
a porta dos botões. Precisamos criar uma referência
de gerente. Então, uma nova variável, você
vai chamar de gerente da BP. Vou procurar o gerente da BP. Uma referência de objeto,
e vamos
chamar esse gerenciador de quebra-cabeças. Agora, a próxima coisa que precisamos é que o gerente
saiba sobre a porta. Então, no gerenciador, vamos criar
uma nova variável. Nós vamos ligar para isso. Vamos encontrar são e vamos chamar
uma referência de objeto. Vamos torná-lo uma referência de
objeto, e vamos
chamá-lo de PP. Note que aqui,
eu usei um ator, aqui, eu usei
o próprio gerente. O motivo é que
não precisamos criar novas interfaces e nada para o gerente. É
só um gerente. Se eu quisesse ter
muitos gerentes e enviar-lhes suas próprias mensagens, eu poderia ter criado isso como ator e criado uma interface para enviar
mensagens aos gerentes. Também precisamos tornar
essas variáveis editáveis. Já que precisamos obter uma
referência no editor. E vamos até o editor. E agora que os
tornamos visíveis, por que não estou vendo isso? Porque eu não compilei. Ok, agora que eu
compilei, aqui está. Então eu vou
selecionar o gerente, e aqui eu vou
selecionar o gerente, e aqui eu vou
selecionar o gerente. E o gerente
deve conhecer a porta, então eu vou selecionar a
porta e vou salvar. Agora, vamos até o fundo do poço. Vamos abrir a planta. Precisamos de duas malhas estáticas. Vou duplicar isso
e, para o primeiro, vamos encontrar nosso
botão. Aqui está. Vou selecionar
o botão inferior. Eu tenho que encontrá-lo no navegador e depois passá-lo aqui. E para o outro, eu os
fiz ao contrário.
Realmente não importa. Vou encontrá-lo no navegador
e colocá-lo aqui. Então, agora vamos até a porta. Vamos precisar de uma
segunda malha estática. Vou duplicar este. E vamos selecionar o
primeiro e ir para o nosso mapa. Encontre a porta aberta. isso, encontre
no navegador, vá até a porta
e passe por aqui. Pegue o próximo,
encontre-o no navegador, vá até o plano e
passe-o aqui. Opa Sim, esses são os materiais
corretos, certo? E eu vou
movê-los um pouco mais para a esquerda. E esse é um pouco menor. E talvez aqui e um pouco mais. Tudo bem
Vamos verificar a porta. Está tudo bem, um pouco para a esquerda.
Eu acho que está tudo bem. Talvez
um pouco mais para frente. De qualquer forma, acho que está tudo bem
lá e os botões
precisam girar. Este e este vão selecionar todos eles e
colocá-los um pouco mais alto. Talvez estejam um pouco estragados. Isso também e acho que estamos
prontos para começar a programar. Mas vamos fazer
isso na próxima lição. Então, adeus por
enquanto. Te vejo então.
27. Construindo a mecânica de quebra-cabeças de botões para portas interativas: Bem-vindo de volta aos portais
Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, terminamos
com a parte visual, a configuração de nossa cena e a configuração do visual
e da mensagem de nossas plantas para a nova porta Agora, vamos continuar com a
programação do gerente. Vamos abrir o gerente. Vamos ao gráfico de eventos. E o que precisamos aqui
é de dois eventos personalizados. E diga botão em outro botão de dobra
personalizado ativado. Agora, vamos
fazer algo complicado, mas também não muito necessário, mas é uma boa maneira de
demonstrar outro contêiner
variável Vamos usar o contêiner de variáveis do
mapa. Então, vamos
duplicar esse Gr BIP e
nomeá-lo como peças do quebra-cabeça Então, vamos até os contêineres e escolhemos o contêiner do
mapa. Agora, como você pode ver, um segundo tipo de variável
apareceu aqui, que vamos
definir como bullying O que realmente
criamos aqui? O que é esse contêiner de mapas? Bem, o contêiner do mapa segue a regra que o
contêiner definido segue. Isso significa que não pode ter o primeiro tipo de variável
duplicado. Ao dizer isso, quero dizer, o segundo tipo de variável pode ser várias vezes o
mesmo, não importa. Mas o primeiro tipo de variável deve ser sempre diferente,
não pode ser o mesmo. E, claro, essa lista corresponde à forma como
as coisas são inseridas Por exemplo, agora, criamos a edição instantânea
e a expusemos no spawn e adicionaremos três variáveis Eu tenho que fazer isso a partir daqui
porque toda vez que adiciono uma, não
posso adicionar outra porque não variável é
a primeira variável e ela a considera
algo único. Portanto, não posso adicionar um segundo nenhum. Então, adicionando o primeiro não, como você pode ver, não posso
adicionar um segundo, mas se eu escolher um
dos botões, a ordem aqui é importante. Então, o primeiro botão é esquerdo do jeito que
estamos vendo agora. Então, vou adicionar
uma segunda variável. A segunda seria a do meio e a terceira variável, a terceira
seria a correta. Agora, como temos uma
ordem de um, dois, três e temos um botão
correspondente, podemos definir um código de qual é a maneira correta como esses
botões devem funcionar. Então, vamos voltar ao
nosso gerenciador de quebra-cabeças. Vamos criar outra barra de
variáveis que
chamaremos de senha correta E não
será do tipo map, será do tipo array,
e será do tipo boolean, container array
e tipo boolean Vamos compilar e salvar. Vamos adicionar
três elementos. E digamos que a primeira e a
última devam estar ativadas e essa é a senha
correta. Poderíamos expô-lo em
um spawn e editável, torná-lo editável, para que possamos definir qualquer senha que
quisermos daqui Agora, lembre-se de que, com tantas peças de
quebra-cabeça
que temos, devemos ter muitos elementos de
matriz corretos de senha. Para esse tipo de quebra-cabeça
que estamos fazendo, do jeito que estamos fazendo. Agora, vamos voltar ao gerenciador
de quebra-cabeças. E o que precisamos fazer é adicionar um ator como entrada
nesses dois eventos. Então, vamos colocar
essa vantagem aqui. Vamos adicionar um ator e aqui vamos
adicionar também um ator. E vamos chamá-lo de quebra-cabeça e copiá-lo e
colá-lo no outro evento também. Então, o que vamos fazer é que, quando
ativarmos um botão, adicionaremos algo a esse mapa. Agora, por
que vamos adicionar? Porque os mapas têm
a propriedade exclusiva que, quando adicionamos algo
que já existe, ele apenas atualiza o valor. Então, quando estivermos
ativando um botão, adicionaremos algo. Adicionaremos aquele
ator que já existe e ativaremos
seu ouro Quando estivermos removendo quando
estivermos desligando o botão, adicionaremos o
mesmo, mas o ativaremos. Então, isso
atualizará nosso valor. Agora, a próxima etapa
seria ter uma ramificação que
conectaremos a ambas. E aqui teremos condição de criarmos
uma função, mas não vamos criá-la ainda. A próxima coisa que devemos fazer
é obter nosso modelo Dor,
digamos, mensagem de desbloqueio
ou mensagem de registro E conecte-se ao verdadeiro ou ao falso. Porque se o quebra-cabeça for
resolvido, estamos desbloqueando. Se o quebra-cabeça for falso,
estamos trancando a porta. Agora, vamos criar a condição. Para a condição,
vamos criar uma função. Vamos chamar
isso de resolução de quebra-cabeças. Na verdade, apenas um quebra-cabeça resolvido. Não precisa de um ponto de interrogação. Não gosto de ter pontos de
interrogação em variáveis ou funções. E este
terá uma saída, e será pura porque não vamos definir
algo aqui. O resultado seria, digamos que
o quebra-cabeça
também foi resolvido ,
compilar e salvar. O que faremos
aqui é bem simples Vamos pegar
nossas peças do quebra-cabeça. Agora, há duas maneiras de
obter valores e chaves. Chamamos o primeiro de beijo, o segundo de valores. Então recebemos o beijo, recebemos o beijo e temos os valores,
na verdade, apenas valores. Então, como você pode ver,
essa recebe nosso beijo, a primeira parte, e essa recebe os valores, que
é a segunda parte. Agora, vamos apenas
obter nossos valores. E obteremos
nossa senha correta e
compararemos as matrizes Como você pode ver, eu
escolhi o idêntico. Eu pressionei igual,
mas também traz isso idêntico. Isso
é o que nós queremos. Essas duas matrizes, como
essa é uma saída de matriz, queremos que sejam idênticas Se forem idênticos, significa que a
senha está correta. Se não forem idênticos, significa que a senha está errada. Vamos compilar e salvar,
e basicamente vamos trazer a função e
conectá-la aqui, basicamente, esse é
todo o código do gerenciador Seria isso. Agora, vamos continuar
com o botão. Vou compilar
e salvar este. E antes de irmos para o final, na verdade, sim, vamos continuar
com o botão primeiro. Vamos pressionar o componente
e adicionar um cubo de dois pontos que precisaremos para verificar
se o ator está na Vamos trazê-lo aqui para que
não precisemos redimensioná-lo externamente Vamos torná-lo um pouco
maior do que o botão. Sim, acho que é
uma boa distância, compilar
e salvar Vamos ao gráfico de eventos. E, na verdade,
vamos ao quebra-cabeça de DR e vamos copiar
esses eventos aqui para que eles nos mostrem o widget
e habilitem a entrada Vamos voltar ao botão e
colá-los aqui. No widget de atualização,
criaremos uma função
correspondente, confirmaremos e
entraremos nessa função, compilaremos e Tem esse problema com o
erro no modo de jogo. Precisamos do primeiro jogo
desde o início do jogo. Vamos trazer isso rapidamente. Então vamos começar a jogar. Na verdade, vou copiar todo
o botão de voltar para o botão, colocá-lo aqui e
criar essa variável, e agora ela será compilada Agora, voltando ao widget de atualização, nós meio que temos esse
código no nosso fígado Então, se eu abrir o fígado
e acessar o widget, você pode simplesmente copiar isso e
voltar para o botão E cole aqui, conecte isso aqui,
e eu resolvi, vamos usá-lo ou
se está pressionado ou não. Então, vou
criá-la como uma variável e vamos renomeá-la para EEO E vamos nos mudar para
let's Ou você sabe o que? Vamos torná-lo um
pouco mais bonito. Vamos duplicar esse texto de
atualização do Wigen
e vamos configurá-lo, se estiver ativado, ative E isso será ativado. Então, agora sabemos exatamente o que ele está fazendo quando o pressionamos
. E não vamos esquecer de conectar o
modo de jogo em terceira pessoa, compilar e salvar De volta ao gráfico par. E vamos criar nossa entrada
E. Vou colocá-la aqui. Precisamos de um pouco de espaço. Então,
vou colocá-lo aqui. Ele soltou E, aqui está. E a primeira coisa que
precisaremos é do cronograma. Então, vou adicionar um cronograma. Vou explicar para você em um segundo. Então, a razão pela qual
precisamos
primeiro da linha do tempo é porque precisamos
perguntar se ela já está sendo reproduzida Então, vou trazer o componente da
linha do tempo até aqui. Vou perguntar para jogar. Porque se já estiver tocando, não
queremos poder
apertar o botão novamente. Então eu vou colocar um galho, vou conectá-lo aqui,
vou colocá-lo aqui. E se for falso, significa que a animação
do botão terminou. Então essa é a hora
de tocar um som. Reproduza o som. E o som que
tocaremos é de botão. Agora, a próxima pergunta, a próxima pergunta seria, se um botão está ligado ou desligado. Então, eu vou me
conectar aqui. E se estiver ligado, vou
configurá-lo para que não esteja ligado. E se estiver ativo, vou
configurá-lo para que esteja ligado. E então eu vou
conectá-lo à linha
do tempo para
jogar e reverter Mas é necessária alguma
explicação para isso, porque essa linha do tempo terá
uma trilha de fluxo diferente Então, vamos deixar isso
para a próxima vez, e eu vou te ver então. Adeus.
28. Finalizando a porta de correr de quebra-cabeça de botões com planos: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente,
criamos nosso gerente e iniciamos nosso botão. Então,
nosso gerente consiste em
um mapa de peças do quebra-cabeça
que, em uma variável, temos os botões
que precisam estar em uma ordem específica e a segunda variável
que é um booleano, que ativamos e
desativamos ao adicioná-la E estamos adicionando isso
porque, como propriedade do mapa, se estamos adicionando
o mesmo elemento
, isso apenas altera o valor. Agora, o mesmo que estamos fazendo
para remover, não remover, desligando o
valor do segundo valor, o booleano,
adicionando-o novamente, mas adicionando-o Em uma função
chamada de resolução de quebra-cabeças,
obtemos os valores do mapa
e verificamos se as matrizes e verificamos se as matrizes são idênticas à matriz de senha
correta Certifique-se de ter
selecionado cada botão na ordem correta ao adicioná-los às peças do quebra-cabeça do
mapa. Agora, copiamos
alguns códigos em nosso botão,
basicamente o comportamento da caixa em que, basicamente o comportamento da quando
bloqueamos
a caixa, ativamos as
entradas e
atualizamos o widget, ativamos as
entradas e
atualizamos adicionando-o à janela de visualização e
removendo-o da janela de visualização E também alteramos o widget de
atualização para dizer, desligar e ativar Agora, vamos continuar com nosso evento urgente em que estamos verificando se a
linha do tempo está sendo reproduzida Se não estiver tocando,
estamos tocando um som e ligando e desligando o
botão. Agora, eu disse que
essa linha do tempo precisa algumas explicações sobre por que
jogamos do jogo E, para ser honesto,
mesmo que eu os tivesse dessa forma, isso realmente não importaria porque
o que faremos
dentro da linha do tempo é criar um caminhão de fluxo que
começa do zero, sobe em um e depois volta a zero Então, a primeira variável
seria zero, a segunda variável , digamos, para um botão, digamos que o total deveria ser um quarto de
segundo, é um botão. Então, 0,12 em algum lugar lá, 0,12. Digamos que 0,12, o valor é um. E então, em 0,24, o valor é zero novamente. Vamos colocá-lo na tela. Veja, eu não me
encaixei completamente
porque escolhi este. Então, para caber em
todos
eles, estou selecionando todos, depois encaixando-os e selecionando usar o último quadro Agora, já que entendemos
isso de cima para baixo, realmente não importa se
estou jogando ao contrário ou jogando desde o início. Importa se
foi o primeiro, na verdade,
isso é o que importa. Na primeira vez, não
deveria ser invertido. Deveria estar em jogo porque se a primeira
vez estivesse aqui, na
verdade gostaria de jogar. Então, sim, a primeira vez importa, a primeira vez importa
ser do jogo. Então, das quedas, estamos
ligando e jogando. Agora, para o movimento,
vamos pegar nossa malha superior e vamos trazê-la
aqui. Vou arrastá-lo e soltá-lo. Vou definir a localização
relativa. Vamos dividir isso. Vamos verificar a localização. É zero, zero, zero, então se eu mover dessa maneira, -1,6 Acho que é um pouco baixo. Não vai mostrar muita coisa. Então, talvez pelo menos
três menos três. Sim, acho que menos
três é bom. Então, de volta ao zero, vamos nos esconder
na direção larga De 02 a 0,3. E para o Alpha,
vamos conectar isso. E agora, como temos
esse slide aqui em cima, isso significa que vamos de zero
a -0,3 e voltamos a zero Agora, temos que indicar ao jogador que o
botão está ligado ou desligado. Então, obteremos a malha estática
e, no final,
trocaremos o material. Então, vamos configurar o material e
conectá-lo para finalizar. E a partir do material,
vamos selecionar e a seleção será
baseada em iso e, se for falso, será o
material que tem agora, que é este. E se estiver ligado,
devemos colocar um adereço. Então, adereços, aqui está. Então, colocamos adereços no verdadeiro
e adereços no falso. Agora, o que vamos
fazer é atualizar nosso widget. Então, ele liga. Diz, ligue ou desligue. E, novamente, com base em
si mesmo, vamos trazê-lo novamente. Vamos para a filial e
vamos chamar nosso gerente, e vamos
ligar se for verdade e desligar
se não for verdade. E para a peça do quebra-cabeça, precisamos de uma referência
a esse ator. Então, para fazer isso,
vamos simplesmente arrastar um cabo e ligar para self. E é assim que
trazemos uma referência ao ator que
está fazendo alguma coisa. Ela precisa se referenciar. Então, retrospectivamente, esses
dois podem ser o mesmo evento. exemplo, se tivéssemos um
evento e ele estivesse adicionando ou removendo e Por exemplo, se tivéssemos um
evento e ele estivesse
adicionando ou removendo e,
em vez de verificar a peça do quebra-cabeça, estivéssemos enviando um booleano, e esse booleano ativado
funcionaria da mesma forma, mas não teríamos
usado a variável map, que foi uma boa demonstração
dessa Então, todo tipo de variável também é v. Acho que podemos
testá-lo. Então, vamos jogar. Vamos fazer com
que os jogadores comecem por aqui. E pelo menos acho que
podemos apertar os botões. É desligar o widget
quando o pressionamos,
então, depois de um pouco
de reflexão, eu descubro o que está acontecendo, e o que está acontecendo é
que copiamos a porta Então, quando eu ligo para trancar
e destrancar a porta, se acessarmos o código da porta, estamos removendo o widget Então, isso será corrigido
quando consertarmos a porta. Portanto, nosso botão está
praticamente pronto. Estamos pressionando, fica verde, estamos pressionando
novamente, está girando. E não vamos perder tempo. Vamos começar pela porta. Então, vamos abrir a planta
da porta. Na verdade, não precisamos de
um widget nesta loja, então não precisamos nem mesmo de
um tubo de colisão, então todo esse código pode desaparecer Além disso, o
modo de jogo não é necessário, mas a
localização relativa não é necessária. Então, vamos
excluir isso também. Vamos criar as variáveis. Na verdade, não precisamos de
nenhuma dessas variáveis. Podemos limpar todos eles com segurança. Vamos manter o
ângulo aberto para que possamos renomeá-lo. Não precisamos disso. Não precisamos da terceira pessoa. Basicamente, precisamos apenas da
porta e do ângulo da porta, e também não precisamos
das funções. Muito bom em funções. Então, vamos remover a animação da porta e fazer com que o evento de destravamento da
porta desbloqueie porta porque copiamos e ele excluiu os eventos
e a porta da fechadura E, basicamente, também não
precisamos de todo esse código. Precisamos de um galho e mudaremos de
posição no final. Não precisamos do widget e não
precisamos da animação da
porta Então, vamos trazer
esses dois eventos e
manter a linha do tempo
e o código que vem com eles e o código que vem com Agora, nós realmente não nos importamos o estado porque é uma
mensagem direta, bloqueada ou desbloqueada. Não precisaremos desse galho. Vamos manter este que tem o código de A
linha do tempo já está sendo reproduzida Vamos trazê-lo aqui. E a razão pela qual
queremos essa ramificação é porque, se a linha do tempo
estiver em zero novamente, quando estivermos trancando a porta, não
devemos reproduzir novamente
a animação da fechadura Não devemos tocar
nem mesmo o som. Então, vamos conectar
os fortes ao som, e eu vou conectar
isso ao som, e precisamos escolher um som E o som é tubo de porta
deslizante. Então, vamos selecioná-lo. E, claro, para
o lado do bloqueio, vamos mudar
o multiplicador para Quando desbloqueamos, queremos jogar. E quando bloqueamos, queremos reverter. Há algum código
aqui que não precisamos. E vamos mover isso para
o lado porque
precisamos de algum espaço para fazer
o mesmo, quase da mesma forma ou da segunda
parte da porta. Então, eu vou trazer isso aqui. Vou copiar e colar
o conjunto relativo. Vou conectar isso
aqui, conectar isso aqui. E eu vou duplicar
o larp e conectá-lo
ao Z e também conectar ao Z e também conectar E esse ângulo aberto, vamos chamá-lo de deslocamento aberto E vamos trazê-lo
aqui e conectá-lo aqui e aqui com B. Então esse é o nosso alvo. Bem, na verdade,
um deles
precisa ser multiplicado por menos Então, vamos verificar
qual é qual. Então, a porta número um
é a parte inferior. Então, isso vai acontecer. E o deslocamento
está por aí, não, não, não. Isso também é muito. Então, vamos para menos dez porque não
começou do começo Então, sim, menos dez de 124. Então 130, se eu adicionar 130 mais 130, isso é 230 mais 130. Não, desculpe, eu fiz isso errado. Eu tenho que ir no final
disso e adicionar 130 Sim. Então 254. 130 parece ser o
truque. Então, vamos aqui. Digamos que o deslocamento que
precisamos compilar seja 130. E o segundo
é o primeiro. Sim, o primeiro é o
que precisa ser oposto. Então, multiplicamos isso por menos
um para torná-lo negativo, e conectamos isso aqui Acho que é isso e
podemos testá-lo. Vamos jogar. Vamos colocar
nosso próprio casaco primeiro. Não. Não. Eu fiz algo muito estranho Então, e para ser sincero, faz sentido porque
os valores não são zero. Não
zeramos esses valores. E isso é culpa minha. Era para
ser a porta deslizante, e eu adicionei a porta aberta para
cima e para baixo. Eu não sei como explicar isso. Então, na verdade, vou
deletar a segunda parte e
colocar a porta correta. Vou selecionar a primeira parte. E sim, porque essa
é a porta deslizante. Vou selecionar isso,
encontrá-lo no navegador e colocá-lo aqui. Corrija a balança também. Agora, estava se movendo muito
devagar porque copiamos linha
do tempo da porta
deslizante, a virada Então são 5 segundos. Podemos mudar isso para 0,5. E seria isso. E não precisamos do
segundo conjunto de portas em relação. Então, conectamos isso de volta aqui
e excluímos o segundo larp e o deslocamento
que veremos agora Isso deveria estar em Y, não em Z. Não
estamos subindo e descendo, estamos indo para a esquerda e para a
direita, então seria isso Se estiver em zero, 00, digamos que se mova aqui. Então, menos 140. Então, vamos colocar menos 140 aqui, menos 140 e compilar save Vamos jogar. Não está posicionado
corretamente Sim, acho que está
tudo bem. Vamos jogar. Tudo bem. Tudo bem,
está funcionando Agora, como você pode ver,
como esses dois botões estão muito próximos um do outro, e se eu ejetar e ocorrer
colisões, quando eu saio deste, eu já digitei este, então ele remove o Deixe-me demonstrar novamente. Se eu estou aqui e vou aqui, ele remove um widget e não podemos vê-lo Então, o que podemos fazer é mover
isso um pouco mais longe, talvez aqui, mover isso
um pouco mais longe. E isso resolveria o problema. Outra forma de corrigir
isso seria
criar um sistema que
verificasse isso. Eu realmente não ouço uma
diferença de som no desbloqueio. Talvez isso devesse ser um tubo de ponto
mais baixo. Isso é muito. Então, vamos deixar 0,7, e acho que vai ficar tudo bem. E talvez a porta devesse
ser um pouco mais lenta. Então, vamos fazer isso em 1 segundo. Acho que a quantidade de
som reproduzida deve ser a quantidade de movimento da porta. Sim, talvez 1,2, mas vamos deixar como está e estamos
prontos para a próxima sala. Que seria a porta
que se abre com um item. Não criaremos um sistema de inventário
completo. Vamos trazer isso aqui também. E, na verdade,
precisamos de um texto aqui. Vou copiar
isso aqui. E praticamente é bom. Vamos apenas
alterar o tamanho da caixa e vamos configurá-la assim. Tudo bem. E vamos
mudar o texto também para dizer que o quebra-cabeça abre
a porta. E está tudo bem do jeito que está. Talvez chute
duas vezes, mova-o um pouco mais longe. Ok, está tudo bem. Agora, ao lado, a próxima porta
usará inventário, e o que é um
inventário, basicamente? Basicamente, é uma
lista, nada mais. Então você tem nesta
lista alguns elementos. E a partir desses elementos, você
os mostra na IUI ou os manipula durante o jogo
com outras coisas Não criaremos uma interface de usuário
que represente essa lista, mas saberemos
se temos o item ou não. Então, vamos deixar essa bola na próxima vez.
Vou te ver então. Adeus.
29. Criando um sistema de inventário com itens escolhíveis: Olá, e bem-vindo de volta ao Area Engine, cinco sistemas de portas Blueprint
Mastery e portais interativos Da última vez, terminamos com nossa porta de botões que
se abre deslizando Agora, o que fizemos foi
criar três botões e um gerenciador armazenar as informações
dos botões. O gerente também tem
uma senha correta. Portanto, quando os botões estão na ordem correta
ou no estado correto, a porta pode ser destrancada. Basicamente, a porta se abre. Quando são falsos, eles
voltam a trancar a porta. Agora, vamos continuar
com nosso inventário. Como dissemos antes, um
inventário é apenas uma lista. Então,
o que vamos fazer é acessar nosso personagem em
terceira pessoa dentro de esquemas de
pastas em terceira pessoa, personagem em
terceira pessoa, e vamos criar
uma nova variável E vamos
chamá-la de inventor R. Essa variável
será do tipo string e será uma matriz Existem muitas
regras sobre o tipo
de contêiner que seria
o inventário. Mas, para nós, uma string servirá, pois forneceremos apenas
uma identificação aos nossos itens. Então, vamos continuar
criando nosso item. Vamos até Blueprints. Vamos clicar com o botão direito do mouse. Vamos criar um novo tipo de classe de
modelo ator, ator classe, e
vamos chamá-lo de item BP. Eu vou abri-lo.
Vou fechar todas essas coisas. Também não
precisamos do personagem, acabamos de criar o inventário. Não precisaremos
fazer mais nada. Esse seria nosso
inventário, essa lista. Ter uma
interface de usuário para representar essa lista seria a
parte visual do inventário. Mas, além disso, é
basicamente uma lista, e essa lista seria capaz de gerar estatísticas
sobre os itens. Mas não vamos entrar em tabelas
de dados e
tudo mais agora. Então, vamos voltar ao nosso item e
adicionar seus componentes. Então, primeiro de tudo, precisaremos de uma
malha estática para representar o item. Não vamos
configurá-lo agora. A próxima coisa que
precisaremos é de uma colisão esférica. Agora, por que uma esfera não é um cubo, uma caixa? Porque é um pouco mais fácil que os itens sejam uma
colisão esférica Por exemplo, com paredes com Al, o jogador não
detecta o padrão. Há muitas hipóteses sobre por que deveria ser uma
esfera ou não ou uma caixa. Pessoalmente, prefiro
uma esfera para itens. A terceira coisa que
precisaremos
seria um componente de
movimento rotativo Quando eu clicar nisso,
veremos que
fica um pouco
à esquerda da hierarquia Se eu fechar isso, ele não pertence à raiz padrão. Bem, isso ocorre porque esse
é um componente independente, é um comportamento que
pode ser anexado a um blueprint e podemos criar nossos próprios componentes do
blueprint Deixe-me te mostrar bem rápido. Vá para a classe Blueprint
e podemos fazer um blueprint um componente de ator Vamos chamar isso de meu componente de
ator. Eu pressionei espaço
em vez de fazer isso, e vamos editar meu
c Como você pode ver, esses componentes são
entidades separadas e
não pertencem à raiz da falha Não exclua isso porque não
precisamos disso. E aqui poderíamos
ter um
roteiro de comportamento para todos os atores Por exemplo, o comportamento do
widget poderia ter sido para que não precisássemos repetir
a colisão e
tudo mais com o ator Falando sobre isso,
repetindo esse código. Vamos abrir uma
porta com vários interruptores, realmente não importa. Uma porta que tem esse
comportamento do widget. Então, vamos copiar isso. Vamos até o item e vamos
colá-lo aqui. Vou criar
uma função correspondente para a atualização do widget, que vamos
preenchê-la agora mesmo Eu vou para a
outra função aqui. Vou copiar isso
e colar aqui. A promoção ainda está disponível porque esse é o modo de jogo em
terceira pessoa. Vou dizer aqui, escolha compilar e a caixa precisa
mudar para a esfera, hein Agora, temos um problema. Isso é uma esfera, e
isso é um colisor de caixas. Nós poderíamos simplesmente mudar isso. Mas o que vamos fazer
é simplesmente inserir essa função,
alterá-la para, em vez de box collider, para componente ator Uma referência de objeto. Vou desconectar isso. Vou confiar em
uma caixa de componentes. Acho que esse é o componente da caixa. Converta-o em um
molde puro. Vamos colocar um galho. Na verdade, não.
Vamos manter as coisas como estão. Vamos conectá-lo aqui, e então eu vou lançar
para a esfera. A esfera não se espalha assim. Converta em componente esférico. Eu vou colocá-lo embaixo dela. Então, se for isso, nós vamos fazer isso. E eu posso fazer isso também? OK. Portanto, precisamos
convertê-lo em um molde puro. Eu vou desconectar
essas coisas. Vou converter
isso em puro elenco. Vou conectar isso
também a um elenco puro. E eu vou fazer uma seleção. Vou conectar isso aqui. Então, se for verdadeiro, se for falso, fazemos essa ramificação e vou
conectá-la aqui. Então, voltando ao nosso item, podemos conectar a lança Então, o que eu acabei de fazer agora? O que eu fiz foi ir ao nosso evento
ao ar livre. Eu mudei. Vamos fazer com que a caixa
também use o colisor. O tipo do componente da caixa da colisão da caixa ao componente
geral do ator Então eu fui em frente e perguntei: Esse componente
é uma caixa? Se for uma caixa, tudo bem,
consiga atores sobrepostos. Se for uma esfera, tudo
bem, consiga atores sobrepostos. Acho que isso é um
pouco exagerado, mas vamos verificar se funciona Então, vou voltar por uma porta, onde está o começo. Vamos apertar play. Parece que não está funcionando. Tudo bem Então eu fiz um bom teste. Estava funcionando, se eu orar agora, só preciso recompilar
esses projetos Tipo, eu abri a porta do fígado
e isso não foi compilado. Recebeu um aviso
porque as coisas mudaram, mas não mudaram muito, mas também mudaram. Então, se formos para cada
projeto e compilarmos,
na verdade, podemos
salvar tudo o que eu acho Dizemos tudo, ele compila tudo? Tenha um acidente. Sim, veja, porque
isso não foi compilado. Area realmente não gosta de
fazer isso em plantas. Nem no SE plus plus
nem em qualquer linguagem de programação, você precisa realmente
compilar as coisas Mas a compilação do Blueprint
é muito mais rápida. Basta pressionar o botão de
compilação e isso acontece instantaneamente Mas é por isso que eles também dizem que não deveria haver
muitas mudanças no código. exemplo, quando você tem um código principal, você não deve alterá-lo muito. Eu acho que é isso. Acho que
compilei tudo. Ótimo. Agora, vou fechar
todos os pontos à direita. Eu só vou ficar com o item. E vamos corrigir os outros erros. Agora, o outro erro é
que estamos procurando por uma sobreposição de caixa onde
temos a sobreposição de esfera Então, vou
clicar na esfera,
ir até os eventos de sobreposição, começar a sobreposição e a sobreposição Eles são basicamente
os mesmos eventos apenas para a esfera
em vez da caixa. Então, vou controlar e
conectar esses cabos aqui. Certifique-se de
conectá-lo aos componentes corretos, outros componentes e a
nada mais. Vou trazer isso
aqui, trazer isso aqui, e talvez eu devesse ter escrito o código
desde o início, mas ainda teríamos
que mudar isso. Portanto, mudar isso para um componente de ator
geral e fundir para o componente de lança e o
componente de caixa parece ter funcionado E agora podemos ter qualquer colisor basicamente
entre esses dois, ou podemos aumentar isso ou criar um
sistema diferente aqui, basicamente, ou uma etapa anterior Então, agora que temos
o widget de atualização, na verdade
precisamos de uma última parte Precisamos obter o modo de jogo. Não, desculpe, não é esse
modo de jogo e transmita para GM. Não, para o modo de jogo em terceira pessoa, converta para puro elenco. E eu vou trazer um
setter e definir isso agora, vamos definir nossas medidas
estáticas Então, para fazer isso, vamos até o
Construction Script e vamos criar um
mini sistema de identificação de itens. Vamos chamá-lo de sistema de identificação de itens. Então, teremos uma nova variável. Teremos que seja uma string e vamos chamá-la de ID do item. Agora, vamos torná-lo editável
por instância
e exposto no Agora, obteremos
nossa malha estática. Vamos definir a malha
estática porque isso
não é essa malha estática definida, definir estática a função
definir a malha estática, isso é definir o componente. Queremos definir a função. Então, por que a função? Porque essa é uma malha estática de
componentes, e queremos definir a
malha desse componente. Vamos fazer uma
seleção, vamos trazer. Não podemos fazer uma
seleção e uma string. Então, o que faremos
é ativar a string. Vou excluir essa seleção. Vou duplicar isso e
conectar isso aqui. Vamos ter dois casos e vamos para o caso zero
aqui e o caso um aqui. Agora, para as medidas estáticas,
vamos ao nosso mapa. Vamos selecionar nosso triângulo vazio,
sem colarinho. Também vou fechar o jogo. Nós não precisamos disso. Preciso
encontrá-lo e adicioná-lo aqui. O mesmo para
o próximo triângulo. Vamos encontrá-lo
e adicioná-lo aqui. Agora, vamos fazer os casos. Então, vou fazer com
que diga ID um. Eu chego aqui selecionando
o botão na string, e o segundo
dirá ID dois. E vou remover
o pino padrão. Isso foi desconectado
porque eu mudei o nome. Portanto, nosso item correto é o ID dois. Vamos definir um ID padrão, ID um. E se eu compilar agora
e for para o Viewport, podemos ver que temos
esse triângulo
aqui e que nossa
colisão é Então, vamos aumentar a esfera de
colisão. Vamos definir um raio de
150. Talvez isso seja muito. Vamos configurá-lo para 120100. Sim, 100 parece estar bem. Vamos compilar e salvar, e vamos trazer nosso
item para o nosso mundo Temos um item aqui
e um item aqui. Agora, eu quero mudar esse
item para ser o correto. Vou até ID
aqui e selecionar ID dois. E então, tornou-se
o outro item. Eu acho que isso é
o suficiente para este. Eu vou
te ver na próxima. Adeus.
30. Trabalho básico para uma porta Sci Fi que requer itens principais: Olá, e bem-vindo de volta ao Unreal Engine, cinco portais
Blueprint Mastery, Door Systems e
Interactive Anteriormente, começamos
a criar nossos itens e iniciamos o modo de jogo
no início do jogo como uma variável, copiamos esse código para a sobreposição inicial e o final da caixa e
o transformamos em uma esfera Agora, também alteramos a
função de adicionar widget Door ao evento Em vez de ser um colisor de
caixas, seja um componente ator. E então usamos esse
componente de ator para lançar para verificar se é uma caixa ou uma esfera e obter os atores
sobrepostos Esse é o script
de construção errado. Queremos o script de
construção do item. Criamos um ID de item e trocamos com base
no ID, com base na string E no caso de ID one, definimos a malha estática do
item para o triângulo. E no caso dois,
definimos a malha estática para o triângulo que
tem alguma cor. Agora, vamos continuar com o código para
adicioná-lo a um inventário. O que vamos fazer é
exatamente a mesma coisa. Quando pressionarmos E,
estaremos interagindo com este item. Então, vamos
trazer o teclado E. Tudo bem E o que queremos fazer,
queremos que aconteça apenas uma vez. Então, o que
fazemos na imprensa é fazer uma vez. E não nos
importamos com a reinicialização porque não temos um
inventário cheio ou algo parecido. Agora precisamos de uma referência
ao jogador. E não só o jogador, deixe-me encerrar o jogo. Não precisamos disso,
não apenas do jogador, mas da instância do personagem
que está no mundo do modelo de terceira pessoa,
do personagem em
terceira pessoa. Então, vamos
obter o painel do jogador. Isso nos dá a instância
atual do que o jogador
está possuindo Em seguida, vamos
escalar um personagem em terceira pessoa. Então, basicamente, estamos pegando a pata atual
e perguntando:
você é o personagem em terceira
pessoa Como sabemos disso em nosso jogo, esse sempre será
o caso. Eu o converti em um purecast e vou receber o inventário E esse é o inventário
atual do personagem que está
correndo pelo mapa. Para adicionar algo aqui, basta
pressionar Adicionar porque essa é uma função de matriz, mas não funciona
como o anúncio de mapa. Nesse caso, se houvesse
um item que compartilhasse o ID, ele também o adicionaria como
outra entidade a essa lista. Então, se eu tivesse, tipo, dois do ID um
, essa lista seria preenchida com duas
versões do ID um Então, basicamente, seria isso. Isso seria atualizar
nosso inventário
e, quando o fazemos,
simplesmente destruímos o Actor. E isso destruiria
o ator no mapa, então o item desapareceria. E é isso. Ou seja, tenha um item, pegue um item que faremos. Então, vamos testá-lo. Vamos ao nosso mapa e fazer com que
os jogadores comecem. De volta aqui, e
podemos pegar isso e
podemos pegar isso. Agora, só para demonstrar isso, vamos ao nosso item. E a partir daqui,
antes de destruirmos, vamos fazer um loop. Para cada loop e
para o corpo do loop, vamos imprimir a string, que será o elemento da matriz, ou
seja, o ID que
acabamos de adicionar aqui. Acho que fiz isso silenciosamente, mas acho que você entendeu Então, quando eu escolher o primeiro
item, será o ID um,
quando eu escolher o segundo
, devem ser os dois. Sim. Portanto, nosso
inventário está funcionando. Vamos conectar isso aqui atrás. Vamos excluir essa depuração, compilar
e salvar. Agora, para a porta,
vamos copiar a porta com
vários interruptores Vamos até a porta multiinterruptora Blueprint
Doors e vamos duplicar E vamos chamá-lo de item D. Tudo bem. Bem, talvez Item
Door não seja um bom nome. Vamos chamá-la de porta chave
porque requer um item. Vamos considerar esse item uma chave. Então, porta chave. Vamos trazer a porta da chave também
para o nível. E vamos abri-lo. Agora, desta vez, vou
usar a porta correta, aquela que queríamos. Eu queria usar antes, que é essa parte aqui. Acho que a
parte inferior deveria ser uma. Agora, na verdade, a
parte superior deve ser uma. Então encontre isso e coloque-o aqui e eu também vou
redefinir sua localização. E vou
selecionar o próximo, encontrá-lo e duplicá-lo,
Controle C, Controle V, e também configurá-lo aqui Então, agora eu vou corrigir as
rotações também. Tudo bem Na verdade, não, as
rotações estavam corretas. Essa é a flecha aqui. Então essa é a parte da frente. Então, eu vou
trazer isso aqui. Mova-o um pouco dessa
maneira e também corrija isso. Eu acho que este, Oh, não, nós temos o comportamento
do widget Está tudo bem Compile e salve Vamos atualizar nossa linha do tempo de
animação para incluir a segunda porta Então, vou mover
isso para cá. É muito fácil. Quando você pega o
que faz o quê, o
que é onde, é mais fácil manipular o código e
adicionar as coisas removidas Então, vamos duplicar o
local definido de rotação porque
são bonecos em movimento Eles não são bonecos rotativos. E eu vou trazer a
segunda porta para cá. E precisamos desse
nó larp novamente para o eixo definido. Precisamos
conectá-lo ao Alpha. E para os valores, temos uma
localização relativa aqui. Vamos simplesmente excluí-lo. Não é necessário. Então,
vamos começar a jogar, exclua isso também e a variável e os quebra-cabeças, não
precisamos deles. E o ângulo aberto, não
precisamos dele. Acho que essa variável não
é necessária. Sim, não foi. Se fosse, diria isso, e seria
isso. Vamos definir o cenário como bloqueado e voltar
aos valores. Então, valores. Este começa com vamos
arredondá-los para 51 25. E este está, novamente,
em 51 25. Ok, eles estão um pouco
esticados. Então, vamos corrigir isso. Tudo bem Então, isso é 115. Essa é a
correta? Fará 115. Isso servirá. Ok,
então começamos 51 15. Então essa é a porta número dois. Vai y é 50, e isso é 115. E o próximo é 51 25. Novamente, Y 50 e a seriam 125. Agora, para onde eles vão, esse vai para 20. Então 20, e o de baixo vai para menos quatro menos cinco Menos cinco. Ótimo. Temos nossa animação completa. A próxima coisa que faremos
é limpar o código porque essa porta não abre nem
tranca em outro lugar. Usaremos novamente a tecla E para verificar
se o jogador tem a chave. Portanto, não precisamos dos
quebra-cabeças de verificação para obter respostas e não precisamos
dessas duas funções, desses dois eventos também Os eventos que acabei de excluir foram o evento locked Door e
o evento unlocked Door, que vêm
da interface que
copiamos e da função de verificação de
quebra-cabeças Tudo bem. Então, estamos prontos
para começar a programar. Mas acho que isso é algo
para a próxima lição. Vou
deixá-lo aqui por enquanto. Adeus.
31. Trancando e desbloqueando portas com um sistema baseado em itens: Olá, bem-vindo de volta
ao Unreal Engine five, ao
Blueprint Mastery, ao door Systems
e Anteriormente, terminamos
com nossa animação de porta. Adicionamos a nova malha estática. Definimos os números
que precisam ser definidos e também apagamos o código da porta da chave porque
o
copiamos da porta com vários interruptores Agora, vamos continuar
pressionando E.
Então, vamos para o teclado E e começaremos a programar. A primeira coisa que precisamos fazer é verificar se nossa porta está trancada. Então eu vou trazer um galho. Vou
conectá-lo aqui. Vou trazer o estado da porta e verificar se o IAM está
igual a trancado. Se não for, vamos
animar a porta. Então, estamos chamando animação de porta. Agora, se não estivermos, se estiver bloqueado, precisamos verificar
o mecanismo de bloqueio. Então, vamos criar um evento para
clientes. E chame-o de mecanismo de bloqueio
que vamos chamar aqui. E nosso E está completo. Agora, vamos programar
o mecanismo de bloqueio. O que precisamos primeiro é uma nova função que
tenha uma saída de um booleano E vamos chamar isso de encadernado à chave. Dentro dessa função,
vamos colocar a pata em
camada e, novamente, ser
lançada em terceira pessoa,
para obter nosso inventário atual Vamos receber o
inventário do nosso elenco. Agora, com matrizes, exceto o AD, temos outro
nó especial chamado ponto, que pode encontrar um item, um elemento da matriz dentro da matriz e retornar
o índice desse item Qual será o
item. promover essas duas variáveis. Vamos chamar
esse item obrigatório. Vamos
torná-lo editável por instância. Também vamos
expô-lo no span,
compilar e salvar, e
se eu trouxer uma ramificação,
precisaremos de um lingote de alguma forma. Precisamos ter um verdadeiro ou falso. Então, a questão
aqui seria se o índice
é maior
ou igual a zero? Porque se estiver
nos negativos, significa que não o encontrou Se for para menos um, significa
que o item não foi encontrado E vou conectar
essa condição aqui. Se o item for encontrado, vou removê-lo do índice
de remoção. Agora, certifique-se de escolher
o índice de remoção e não o item de remoção pois esses dois funcionam de maneira
completamente diferente. Como você pode ver, isso remove todas as instâncias do item de
um item da matriz, onde isso apenas remove
o índice que estamos chamando. Vou conectar
isso à verdade. E agora temos um nó de retorno. Como fazemos isso? Bem,
podemos ter dois nós de retorno. Essa é a mágica, e
conectamos isso aqui e
dizemos que a chave foi encontrada, e podemos conectar isso aqui
e dizer que a chave não foi encontrada. E, claro, conecte
o índice aqui. Como isso é duplicado, eu controlo copiar e colar, controlado por
C. Então, basicamente, vamos copiar e colar esses dois
aqui para o puro elenco. Portanto, não temos
muitos cabos cruzados e isso pode fazer um
pouco mais de sentido. Agora, o que fazemos? Recebemos o inventário, verificamos
se podemos encontrar o item. Se não conseguirmos,
voltamos e não encontramos a chave. Se o fizemos, estamos removendo e retornando
que encontramos uma chave. E vamos nomear essa
função, cheque ou chave. E vamos trazê-lo
aqui para o nosso mecanismo de bloqueio. Então precisamos de um galho. Se encontrássemos uma
chave e a
removêssemos, deveríamos definir o
estado da porta para fechar e não estar trancada. Devemos atualizar o Widget, mas não definimos os textos e precisamos de uma variável para dizer bloqueada e
configurá-la como falsa, na verdade, não
precisamos dessa variável Não sei por que precisamos
disso. Não há necessidade. Nós temos o estado. E falando sobre
estado e widget, vamos corrigir nossa atualização de widget E precisamos do estado da porta. Precisamos de um interruptor. E não precisamos dessa seleção. Vamos copiar isso três
vezes quando estiver bloqueado, ele dirá bloqueado. Quando estiver fechado
, dirá aberto. E quando estiver aberto
, dirá fechado. Na verdade, vamos fazer
isso pela quarta vez. Isso não diria nada. Então, na pior das hipóteses, vemos aquele E. Então, sabemos ele está grampeado durante a
abertura e o fechamento Veja, coisas
assim são apenas alguns nós,
basicamente, um nó extra. Mas quando você está
jogando e vê um bug que você
projetou para ser corrigido,
tipo, oh, ele está mostrando um
widget enquanto está aberto Por quê? E isso deixa
claro qual é a falha. Portanto, dar algumas dicas de depuração
para você é sempre bom. Agora, vamos continuar, precisamos mostrar ao jogador que
a
porta foi destrancada Vamos fazer isso
adicionando um lugar aqui. Não vamos ouvir o som desbloqueado. Eu realmente não gosto
do som desbloqueado para isso. Quero dizer, é um
tipo de som chave. Então, talvez os botões soem. Vamos usar o som do botão. Então, temos uma maneira de
dizer ao jogador que a
porta foi destrancada Ele deve tentar novamente e
desta vez ele abrirá. Agora, quando estamos caindo, devemos sacudir a porta,
mas essa porta não pode
realmente sacudir Está muito errado. O que foi isso? Pelo que vi, a parte inferior é
para 115. Tudo bem. Vamos colocar
tudo corretamente. Certo? Não parece
ser uma porta fechada. Quero dizer, talvez tenha esses
pontos de onde fotografar. Eu não sei Então,
nós o colocamos aqui. Estamos desbloqueando
com nossa chave. Devemos tocar um som
aqui, não deveria ser elevador. Deveria ser a porta da ficção científica. Aqui está. Então, porta Sci
Fi aqui, porta
Sif aqui E nas roupas,
multiplicador de 0,8 tom. Está tudo bem. Tudo bem. Agora, de volta ao chocalho. Basicamente, essa porta não
chacoalha. Essa porta deve fazer outra
coisa e outra coisa que vamos fazer é
mudar essa cor e provavelmente emitir um som. Mas vamos deixar isso
para a próxima vez. Nós vamos ver
você então. Adeus
32. Adicionando efeitos visuais para melhorar as interações de porta Sci Fi: Olá, e bem-vindo de volta ao Unreal Engine, cinco portais
Blueprint Mastery, Door Systems e
Interactive Anteriormente, concluímos com o código para verificar se nossa porta está trancada ou não usando
a chave E e uma ramificação. E se estiver trancado,
acionamos o mecanismo de trava
e, se não estiver,
acionamos a animação da porta. Agora, para nosso mecanismo de bloqueio, usamos uma verificação função
principal de que
estamos obtendo o
inventário do jogador. Estamos descobrindo se
existe o item necessário
e, se estiver, estamos removendo-o
do inventário. Se não for, retornamos
que não encontramos nenhuma chave e encontramos a chave se encontramos. Em seguida, criamos uma filial
e, com base nisso, usamos
a porta que ficou fechada. Atualizamos o widget e tocamos um som para expressar ao jogador que
a porta foi destrancada E conversamos sobre a criação de
nossa nova mecânica de chocalhos. Vamos chamá-lo de
evento personalizado e chamá-lo de chocalho, o que não será um chocalho, mas será interessante Agora, qual será a parte
interessante? A parte interessante é que
usaremos um novo nó chamado D N e é um
pouco difícil de encontrar. Acho que passei, aqui, isso do N. Como
temos o do once, esse é um nó que permite que a
execução passe várias
vezes e depois para. Isso é útil para
limitar quantas vezes uma ação pode ocorrer durante o
jogo, por exemplo Agora, para nosso chocalho, o que fazemos é quatro vezes, trocaremos
o material da porta Vou fazer com que os dois
obtenham o material, na verdade,
defina o material, configure o material e conecte os dois aqui e faça uma seleção a
partir daqui do material. O que vou usar para indexar? Bem, vou
usar um nó de flip lock e selecionar o é A. E então vou
conectar os dois aqui porque quero que a execução do
flip-flop seja a mesma Eu só quero diferenciar
entre A e B. Quando sai de A e
quando sai de B. E para o material
para as dobras, queremos o original, então será a porta
vertical, vertical E então eu acho que isso
vai ser uma porta vertical. Vermelho. Sim. Agora, se eu conectar esse
flip-flop diretamente ao D N, isso acontecerá tão rápido
que eu não conseguirei ver Então, vou
colocar um atraso aqui. Talvez um pouco mais de espaço e conecte o atraso
ao chinelo. Agora, para o atraso, 0,2
é um pouco grande, então vou transformá-lo em 0,1. Para ligar para o D N novamente, vou ligar para Rattle Então, o chocalho está sendo chamado aqui. Ele roda e se chama, e será executado um
total de quatro vezes. Agora, como um jogador
pode experimentá-lo várias vezes, precisamos reiniciá-lo. Então, vou criar um
evento personalizado e chamá-lo de reset. Faça chocalho. E
reiniciaremos toda vez o jogador tentar
abrir a porta Então, reinicie, faça chocalho. Vamos tocar um som
também depois de começarmos
a chocalhar, na verdade antes,
vamos tocá-lo aqui Toque o som para D. E o som seria negado. Sim, permissão negada. Vamos jogar. Tudo bem. Temos um problema
com os widgets, mas acho que é porque
todos eles se sobrepõem Então, vou deixar isso um
pouco mais longe, talvez aqui. Sim, está funcionando bem, recebendo o
item errado, não funcionando, obtendo o item correto Ainda não está funcionando. E isso é porque não
demos à porta um item necessário. Portanto, o ID dois é o item obrigatório. Vamos pegar o errado
. Não está funcionando. Vamos pegar o
certo. Ela se abre. Ótimo. É um pouco lento. Essa é a
porta mais lenta já criada. Eu fechei lentamente.
Então, vamos corrigir isso. Vamos ao nosso cronograma. E vamos definir isso para,
eu não sei, 1 segundo. Usando o último quadro-chave, tudo bem. E também vamos trocar o material da porta
quando a abrirmos. Vamos torná-lo verde.
Então eu vou para nossa casa
aqui, tocamos som. A porta está destrancada
e pegue a parte superior. Este único conjunto de material. Isso pode ser aberto verticalmente. Compile e salve.
O que aconteceu lá? Acho que deve ser um
sombreador carregado ou algo assim. Então, está aberto. Ele fecha. Quando termina de abrir, ele não me mostra o widget Quando estiver abrindo e tudo bem, vamos
até a porta da chave. Atualize o texto do widget,
porta quando estiver fechada. Eu sou, não estou me sobrepondo. Ok, então esse é o problema. O código está correto.
Está lá. Só que a caixa
é um pouco pequena. Na verdade, vou
mudar isso a partir daqui. Sim, acho que está tudo bem. Então, pegando a chave novamente. Tudo bem. Não, ele ainda não está mostrando
o widget quando a porta está fechada ou aberta OK. Então, vou
conectar isso aqui. E ambos adicionam
novamente o widget da porta. Eu quero ver o
negativo novamente. Ah, eu realmente gosto do negativo. Certo. Está funcionando
corretamente. Ótimo. E agora batemos em uma parede de tijolos. Então, acho que é a hora
de abrir a porta de teletransporte, na qual usaremos esse
incrível teletransportador, que também tem uma Para fazer isso, vamos
criar um novo modelo. Vamos até as portas da pasta. Vamos criar uma nova classe de ator
modelo
e vamos chamá-la de teletransportador BP. Vamos compilar e salvar, e vamos começar
adicionando os componentes
do teletransportador Obviamente,
precisaremos de uma caixa de colisão. Portanto, a colisão da caixa
seria um componente. Precisaremos de uma malha estática
para nossa malha de teletransportador e precisaremos de uma Acho que é a partícula do Niágara. Aqui está um componente do Niágara. Adicione um sistema Niagara. E também precisamos de uma flecha. Agora, vamos selecionar nossa malha que será a malha do
teletransportador. Vamos amarrá-lo e
colocá-lo aqui. E precisamos
girá-lo, certo? E para a festa do Niágara,
vamos
selecionar a partige vamos
selecionar a Vamos encontrá-lo também
e adicioná-lo aqui. Agora, vamos girar isso
Sim. Eu acho que é isso. E nossa caixa deve ser um
pouco maior e mais larga, um pouco mais na frente. Sim. Isso é bom. E vamos trazer
nosso teletransportador para o mapa Certo? E vamos tornar a
próxima sala também visível. Talvez mova um pouco para cá. E também vamos duplicá-lo aqui e girá-lo
para ficar de frente para a maneira correta Há uma razão para isso ele precisa estar voltado
da maneira correta. Mas continuaremos
com isso na próxima lição, e é aqui que
vamos deixá-la desta vez. Adeus, até
a próxima.
33. Criando um teletransportador para transições de nível: Olá, e bem-vindo de volta
aos cinco sistemas
de portas
Blueprint Mastery e portais interativos da Unreal Lensing sistemas
de portas
Blueprint Mastery Anteriormente, terminamos com
nossa chave exigindo porta e iniciamos nosso teletransportador Adicionamos alguns
componentes e malhas
e adicionamos a
partícula de Niágara e Vamos continuar com a
programação do teletransportador. Vamos usar o evento
de
sobreposição inicial da colisão e vamos lançar dois personagens em terceira pessoa
porque somente nosso
personagem deve se mover, e também queremos uma referência
ao personagem Agora, como movemos nosso
personagem daqui para cá, onde poderíamos definir a
localização do ator. Mas há uma
nota especial chamada teleporte. No Unreal Engine,
ele nos fornece duas entradas, destino e localização de
destino e rotação de
destino, que é bom porque,
quando estamos nos teletransportando, queremos girar o
personagem de uma certa maneira Portanto, ele não se teletransporta
e olha para trás,
por exemplo, em direção à porta
do teletransportador Mas antes de prosseguirmos e
descobrirmos onde isso deveria estar, vamos também tocar um som, que seria o som do
teleporte Temos esse som, mas
eu gosto muito desse, o som de teletransporte VR Agora, isso está incluído no
mecanismo, caso você não consiga
vê-lo na
gaveta de conteúdo nas configurações, você pode ativar o conteúdo do mecanismo Em algum lugar, mostre o conteúdo do motor. Eu não cliquei nele, mas isso deve
torná-lo visível Agora, vamos continuar com nossa localização de destino
e rotação de destinos. O que vamos usar para isso é
criar um sistema
aqui usando uma cena , então vamos adicionar uma
cena, o que é uma cena? Basicamente, é só um ponto. Então, estamos falando sobre esse ponto em que podemos
mover para a esquerda até lá em cima, e podemos criar uma referência
a ele, porque vamos
chamá-lo de raiz da
cápsula de teletransporte Essa será a raiz da cápsula de
teletransporte, e podemos
referenciá-la onde ela está,
onde é girada em direção a
duas e tudo Mas não vamos
fazer só isso. Vamos adicionar uma colisão de
cápsulas. Isso será criado pelos pais
no local. Então, sempre que movemos a cena, movemos a colisão também Como não foi adicionado
no local correto, vamos apenas
redefinir sua localização, transformar e ele se
encaixará na raiz Agora, também vamos
aumentar isso para o tamanho do jogador. Acho que o jogador é que não consigo
me lembrar de nada para ver. Vou abrir o
player, selecionar a cápsula. Sim, metade do tamanho dos anos 90. 90 é metade do tamanho e o raio é 35 Isso vai ser pequeno. Então, raio de 35. E agora,
sabemos exatamente onde a cápsula do jogador surgirá. E vamos também adicionar uma seta. Vou selecionar
novamente o
componente raiz porque não quero que
ele seja adicionado à cápsula. Eu quero que ele adicione
ao componente raiz seta
e também
redefina sua posição. E agora podemos ver claramente onde o jogador está e para
onde ele está olhando. Então, eu vou colocar
isso aqui. Talvez esteja aqui mais à frente. Acho que está
saindo e caindo aqui. Sim. Talvez mais pelo ar. Tudo bem Vamos continuar. Agora, não queremos a
cápsula e o componente raiz. Queremos os alvos, cápsula e o componente raiz. Então, o que vamos fazer é criar
outra variável, vamos
chamá-la de target, porta, e vamos
expô-la e torná-la exposta ao spawn, também editável em sentido, e será Vamos compilar, salvar
e ir para Teporter a partir dos detalhes, vamos selecionar
o outro teletransportador
e, para o outro teletransportador, vamos fazer Talvez esteja um
pouco longe. Então, vou selecionar a raiz. Sim, acho que é
uma boa distância. E agora, em nosso
repórter do BPA, vamos compilar. E para o destino,
vamos usar esse repórter
alvo Vou pegar uma flecha porque é
disso que precisamos. Não precisamos da cápsula
nem das manchas, para ser honesto. Arrow fará o trabalho. Certifique-se de que seja a seta
um porque a seta é usada para a planta
original Então, vamos conseguir transformar. Mas vamos transformar o
mundo porque queremos que ele esteja em uma localização e rotação mundiais. Desta vez, não estamos usando a localização
ou rotação relativa
local porque
não queremos que ela seja
relativa ao blueprint Queremos que seja
relativo ao mundo. Então, por exemplo,
se eu for aqui e selecionar esse teletransportador,
selecionar a raiz e girá-la, quero que ela seja
girada para aqui,
com base no mundo, não
para aqui, com base Agora, o que também é transformar? Bem, uma transformação é basicamente
a estrutura de elementos de
três vetores E se eu quebrá-lo, podemos ver que ele
tem uma localização, uma rotação e uma escala. Então, vou conectar
a localização
à localização de destino e a rotação à rotação de
destino. E isso concluirá
nosso tele-portal. Vamos trazer nossa
cápsula até aqui. Vamos apertar play. E
estamos nos teletransportando Tudo bem Eu acho que
é isso para este. Te vejo na próxima. Adeus
34. Projetando uma porta baseada em física com programação de Blueprint: Olá, e bem-vindo de volta
ao Unreal Engine, cinco sistemas de portas
Blueprint Mastery
e Anteriormente, terminamos
com nossa porta de teletransporte. Criamos um sistema usando uma cápsula, um componente da casca da raiz
e uma flecha. Na verdade, só
precisávamos da flecha, mas temos a cápsula
para ver a colisão do nosso jogador e o
componente raiz para movê-la o tempo todo Agora, usamos essa seta para obter a transformação
que dividimos nos três vetores e usamos
a localização e
a rotação
para usar o nó de teletransporte destino e destino de
rotação E então tocamos o som. E tudo isso foi acionado
pela sobreposição da caixa
do teletransportador.
É basicamente isso. Agora é hora de criar
a loja de física. Vamos até as portas da
nossa pasta. Vamos clicar com o botão direito do mouse.
Vamos criar uma nova
classe de blueprint do tipo actor Vou
chamá-lo de PP Physics Door. E nós vamos abri-lo. Agora, para esse projeto, precisaremos de
duas malhas estáticas E vamos selecionar a mensagem. Na verdade, é só um. Vai preencher os dois, e vamos apenas
rotacionar um deles E mexa um pouco. Essas portas
não devem se tocar. Vamos movê-los um pouco para o centro da planta Eles deveriam ter uma
lacuna entre eles ,
porque, como serão uma loja de física, será inútil se eles
se tocarem Agora, vamos compilar e salvar, e vamos trazer nosso
ator ao mundo Acho que precisa
mudar um pouco para algum lugar
aqui. Tudo bem. A próxima coisa que faremos é habilitar
a física para esses itens. Então, vou
selecionar os dois. Eu vou para a aba de física. Onde está a física
aqui e selecione
simular física Mas isso não vai nos
ajudar muito, porque
se eu for jogar agora, podemos ver eles simplesmente
pulando por aí Isso não é de todo.
Isso é só entulho. Então é isso que queremos. Felizmente, existe
algo chamado física. Restrição, que é o que
usaremos agora. A dica da ferramenta diz que essa é efetivamente uma junta que
permite conectar dois corpos
rígidos Você pode criar
diferentes tipos de juntas usando os vários
parâmetros desse componente. Ok, a palavra-chave aqui cria algo como
uma junta, como uma dobradiça Isso nos permite controlar a rotação e
os limites de
movimento, como
braços mecânicos, por exemplo, ou comportamento mais avançado de bonecas
de pano Mas, para nós, vamos usá-lo
apenas para definir os limites para
criar uma porta dinâmica. Então, vamos continuar com a forma como
usamos a restrição física? Primeiro de tudo, precisamos
nomear as portas. E então precisaremos de
duas restrições físicas. Então, vamos ter um. Vamos adicionar uma seta. Então, sabemos onde está a frente. Ok, a frente da
planta é por aqui, mas nós realmente não nos
importamos com isso Vamos apenas
girar a seta e separá-la da malha estática Basta girar
isso. Tudo bem. E chame essa porta
e essa outra de DR. Então isso seria restrito L, e isso seria restrito E compile, eles estão
em ordem oposta , mas isso não importa O que vamos fazer é selecionar a restrição da primeira
visita E vou
até as configurações
e digo o nome do componente um. Aqui, vamos usar
a porta L. Certifique-se de que essa porta L seja exatamente
igual a esta. Sem espaços extras, a capitalização
pode ser importante. Não tenho certeza porque se não for, não funcionará. Agora, como você pode ver, ela já tomou
a forma da nossa porta. Basicamente, ele nos mostra
os limites da malha, mas também nos mostra com essa linha aqui
onde está nosso pivô Então, vamos passar para
esse canto aqui, e esse é o nosso pivô A próxima coisa que vemos são os círculos redondos
ao redor do ponto de articulação. Que devemos avançar um
pouco mais aqui. OK. Agora, o que
são esses círculos? Bem, vamos abaixo e
veremos alguns limites angulares. Agora, para nós,
precisamos apenas de um movimento, então bloquearemos o segundo e bloquearemos a torção Além disso, só
queremos que seja nessa rotação, e vamos definir a
primeira rotação com um limite, e o limite seria 90
45 é um pouco pequeno. E você pode ver que isso nos mostra
os limites da rotação. Agora vamos
fazer o mesmo com Dor R. Vamos fazer uma dessas aqui. Vamos chamar R. Vamos definir isso como bloqueado, e esse é o limite e 90. Mas é o oposto. Precisamos girá-lo. Operações. OK. E vamos
girá-lo 180 Então, vamos testá-lo. Não vai funcionar perfeitamente, mas é um bom começo. Vamos trazer nossos cuidadores aqui, estamos de passagem, e a porta está
girando como Agora, há muitas
opções para corrigir isso. Vamos brincar com
algumas configurações simples. Por exemplo, primeiro,
temos que corrigir uma configuração. Por aqui, vou
selecionar os dois. Temos o motor angular, que temos o motor de acionamento
angular. Ele está usando o slurp agora, que é, como descreve, alerta entre a corrente
e a velocidade e a orientação do
alvo Mas o que queremos é
uma reviravolta, que decomponha um pouco
o caminho Então, a próxima coisa que
faremos é selecionar cada uma das portas e ir para
as configurações físicas, e habilitaremos a massa. Vamos fazer deles uma massa de 80. Você pode brincar
com os valores e também aumentaremos o amortecimento
angular Espero que isso conserte A com o balanço. Tudo bem. Agora, o único problema é que
eles ficam assim. Eles não retornam à
sua posição original. Então, isso deveria ter sido
corrigido pelo giro e torção. Mas provavelmente, sim, eu não
cliquei
na opção de giro, então ela não tem uma orientação de
alvo, porque o giro
e a torção fazem com que ela tenha uma Isso significa para onde estou
tentando voltar? Poderíamos jogar com a
velocidade-alvo e tudo mais, mas é disso que precisamos para fazê-los retornar
à mesma posição Então, vou compilar, salvar
e pressionar play. Quando ele abre e retorna
à mesma posição. Agora, você poderia jogar um
pouco, mas os valores tornam tudo mais realista. Eu não sei. Quando
há duas portas, isso também depende um pouco da velocidade do
jogador. Portos, mas acho que está tudo bem. Uma porta é muito fácil. Não, uma porta é boa, duas portas são um
pouco difíceis. Então, isso será para
a loja de física. próxima lição, veremos você
nos teletransportar
para outro nível Adeus por enquanto.
35. Programando uma porta de mudança de nível com efeitos de transição: Olá, e bem-vindo de volta
aos cinco sistemas
de portas
Blueprint Mastery e portais interativos da Unreal Lenzing sistemas
de portas
Blueprint Mastery Anteriormente, quase
terminamos nossa loja de física. Parece que esqueci de
adicionar os sons. Vamos abrir a loja de física e foi uma boa oportunidade mostrar outro evento de colisão Desta vez, porque essa porta realmente
não se sobrepõe
ao player Eu bloqueia o jogador.
Usaremos o calor do componente. Então, estou recebendo o
calor do componente desta porta, e estou recebendo o
calor do componente da outra porta, e vamos apenas
reproduzir o som. E conecte tanto para exibir
o som quanto para o som, vamos usar
o ponto de física Q. E vamos tocar
com o tom novamente Vamos fazer uma flutuação
aleatória no alcance, que
será de 0,8 a um E agora, temos um som horrível
porque bate muitas vezes. Então, meu palpite é que esse som precisa de algumas configurações de
simultaneidade O que são
configurações de simultaneidade? Eles estão aqui. É uma configuração que controla
quantas instâncias
do som podem ser reproduzidas
simultaneamente e nos
permite limitar ou
gerenciar sons sobrepostos Além disso, quando um som
pode começar
e parar, e há muitas configurações com
as quais brincar, mas nosso principal uso seria esse. Então, vou até
a pasta sons e vou criar Parece que
já os criamos. Então aqui está o physis do C que
já tem algumas configurações predefinidas para nós Contagem máxima de quantas
vezes ele deve ser jogado. Reative o tempo em
que ele deveria jogar novamente, limite ao proprietário, como
limite ao proprietário. Isso significa o plano que
está sendo executado, basicamente. Então, se você tivesse duas plantas, elas não
parecem que essa contagem máxima de um não seria a mesma Eles tocariam o
dobro dos sons. Sim, há
muitas configurações aqui. É isso que usaremos. Então, se eu adicionar isso
aqui, agora, sim. O som está muito melhor. Agora, outra coisa
que notei é que eu realmente nunca
expliquei e nunca usei o
componente de rotação dos itens. Funciona, mas se
jogarmos e mostrarmos colisões, você notará que
a colisão também está se movendo, o que, no momento, não
é um grande problema, mas
se tivéssemos muitas delas, isso criaria uma
grande falta de moldura O que faremos é inserir a planta do item, acessar o script de construção e obter esse movimento rotativo que
é, vamos explicar,
já que não o fizemos É um componente que
faz o ator girar. Ele faz a rotação com base
nas regras e nas configurações
que inserimos aqui Por padrão, ele está girando no espaço
local e em 180 graus. Agora, existe uma maneira de
fazer com que isso seja responsável por um
determinado componente e não por um ator inteiro. E esse nó seria
configurado como componente atualizado. Então, vamos
conectar os dois aqui e vamos
conectar a malha estática aqui. Na verdade, nós meio que
copiamos e colamos. Portanto, esse
movimento rotativo agora
girará apenas o componente da malha estática e não o resto do ator Então, se formos jogar e ejetar, podemos ver que não funcionou Fiz um teste ao vivo. É incrível. O que é o item? Aqui está o
componente atualizado do conjunto de itens, malha estática. Oh, eu acho que é porque eu o conectei
ao roteiro de construção. Deve estar no início do jogo. Vamos atualizar. Sim. Então você pode ver que o triângulo só se move. Sim. Portanto, o componente atualizado realmente
não funciona no script de
construção
porque precisa que o jogo seja
executado para fazer alguma coisa. Então, como no script de
construção, o jogo não está rodando, o componente de atualização realmente
não faz nada. Então é por isso que precisávamos trazê-lo
para começar a jogar em vez do script de construção,
porque ele está inativo Está no editor. Podemos ver que ele não gira. De qualquer forma, vamos continuar. Vamos duplicar a planta
do teletransportador E vamos chamar isso de trocador
de nível. E vamos trazê-lo aqui. E pelo que você está adivinhando, ele praticamente tem
a mesma configuração Precisamos da mesma configuração porque vamos
migrar para dentro e para fora, então precisamos de todas
essas funcionalidades. Agora, antes de começarmos a
programar isso, vamos também criar um
widget simples com uma animação Vamos
clicar com o botão direito do mouse na
pasta do widget e criar um blueprint de widget
e um widget Vou chamá-lo de “W you fade”. Porque quando estamos entrando
e saindo do mundo, devemos entrar e
sair para que não pareça ruim Vamos adicionar uma tela
e adicionar
uma imagem, vamos uma imagem ancorar a imagem em tela
cheia e
zerar os deslocamentos E a cor deve ser preta. Agora, como faço animações? Há uma guia aqui quando estou dentro do blueprint do
Widget Se eu não estiver, a guia não
está mais aqui, como você pode ver, mas dentro
do blueprint do Widget, uma nova guia aparece aqui
, chamada de animações Vamos adicionar uma nova animação. Vamos chamar isso de fade. Animação. Vamos
chamá-la de minha animação de fade Não deveria vir com espaços. Minha animação gorda e vamos clicar
duas vezes para inseri-la. Aqui temos a guia
com todas as animações. E aqui, quando
selecionamos uma animação, temos as configurações para usá-la. Nas configurações, vamos selecionar
o botão Adicionar e adicionar imagem porque eu tenho
a imagem selecionada. Se você não tiver
a imagem selecionada, precisará
selecioná-la basicamente e pressionar Adicionar
. Para esta imagem, aqui temos nossa
faixa de animação que usamos 0,5, então 02,5, talvez seja animação
suficiente Vamos adicionar um novo
caminhão a essa imagem, que será
de cor e opacidade Na verdade, vamos apenas
fazer a opacidade da renderização. Por que complicar as coisas. Agora, ele começa como padrão com um em
que queremos que seja zero
e, em 0,5 segundos, queremos que seja um. Então, 0-1. E isso
conclui nossa animação Vamos compilar e salvar, e vamos fechar o fade Widget, ainda não precisaremos dele. Vamos realmente fechar os
itens e a loja de física. E o personagem, a porta
chave e o teletransportador. Vamos abrir o trocador de nível. Como vamos mudar
de nível, não
precisamos mais do
teleporte. Não precisamos da localização
do outro ator, mas precisamos
criar esse widget, como fizemos no início
do jogo no modo de jogo Vamos abri-lo para mostrar
Criamos o widget
e, mais tarde,
decidimos quando
adicioná-lo ao viewpod ou quando
removê-lo do Agora, queremos apenas criá-lo nível
proprietário deve ser
o controlador Taer, e a classe deve ser paga e adicionaremos
ao Viewport O único problema é que, na verdade,
precisamos abrir isso novamente. Então, vou abrir o widget, pesquisar a opacidade
e depois a opacidade
e definir o valor padrão e definir o Porque se eu
deixasse que fosse como estava, no momento em que eu a adicionasse, mesmo que a animação
não fosse
reproduzida logo
depois, eu veria uma tela preta e depois veria o desvanecimento Portanto, não seria
o efeito desejado. Agora, vamos reproduzir a animação
de fade. Como vamos fazer isso? Vamos chamar a partir
desse widget, o fade,
pegar minha animação de fade
e, a partir daí, vamos reproduzir Agora, usando essa animação, vamos fazer get and time e vamos adicionar
alguns segundos a ela. Por exemplo, vamos adicionar 1 segundo a isso. Talvez um seja muito, talvez 0,5. E vamos fazer um anúncio
atrasado e conectar isso. Então, o que quer
que aconteça acontece após o término
da animação da falsificação. Agora, conecte o som e
abriremos o nível pelo nome. E o nome,
deve ser o nome do próximo nível
do Tutor Map two Deve ser exatamente copiado e
colado aqui ou digitado, mas deve corresponder exatamente Agora, precisamos conectar
o widget ao alvo
porque ele está reproduzindo uma animação Ok, está reproduzindo
essa animação, mas quem está tocando?
A animação. Compilando, salvando. Vamos
testar o que criamos. Na verdade, não funcionará
completamente. Vamos jogar. E como você percebeu, ok, é claro, em primeiro
lugar, não temos uma esponja, não
temos um tocador, mas
o som realmente não tocou O motivo é que estamos apenas tocando um som em dois D,
como normalmente fazemos, e isso não é suficiente
para essa situação. Porque estamos mudando de
nível, essa entidade, esse som de reprodução só
existe nesse nível. No momento em que tentamos
abrir outro, inicia-se um procedimento que está destruindo as
coisas nesse nível Como podemos tocar um
som que
persistirá durante o nível O que precisamos fazer
é gerar som em D,
que, como você pode ver, tem uma dica de ferramenta
maior aqui Esta função permite que
os usuários criem componentes de áudio com configuração especial para não
espacializados e sem distância De qualquer forma, tem
várias outras regras. Mas o que nos importa
é que, se abrirmos
isso, ela persista em todos os
níveis. Então, vou clicar
aqui e usar o som
de teletransporte Vou usar o
teleporte VR. Eu gosto muito
desse. Mas esse som não
será reproduzido instantaneamente. Acabou de ser gerado. Isso não significa
que ele vai jogar. Nós o trouxemos ao mundo, mas nada mais aconteceu. Para fazer isso, vamos
apenas partir do valor de retorno, essa é uma parte importante de
que ele tenha um valor de retorno pois reproduzir som em D não
tem um valor de retorno. Isso nos dá uma
entidade para
manipular, promover uma variável e fazer coisas com ela Mas o que queremos fazer
agora é apenas jogar. E então conectamos
o nível aberto. E agora, se tentarmos tocar,
temos um som tocando. Mas, para ser sincero, o som deve ser reproduzido
antes do atraso. E então abrimos o
nível. Tudo bem Agora, não vamos usar
esse nó, na verdade. Não usaremos apenas
um nó de nível aberto. Estaremos criando um sistema que, quando você entra
do ponto
A, o sistema sabe
que leva ao ponto B e, do ponto B, vai para o ponto C,
e talvez tenhamos um sistema para dizer ao jogo que, se eu
o
teletransportar daqui,
estou me teletransportando de volta Talvez possamos
explicar melhor
no próximo, porque acho que esse é um bom
ponto de parada para este. Adeus por enquanto.
36. Sistema dinâmico de pontos de passagem para níveis interativos: Olá, e bem-vindo de
volta ao Unreal Engine cinco sistemas de portas Blueprint
Mastery e Anteriormente, começamos com nossa porta de teletransporte,
nosso trocador de nível Agora, adicionamos um widget pago que, quando acionado com
a caixa sobreposta, criamos Nós o criamos e o
adicionamos à janela de exibição
e, em seguida, reproduzimos a animação e reproduzimos um som que geramos, e ele será persistente
em toda a transição de nível E depois de um pequeno atraso, abrimos o novo nível. E isso nos leva a discutir sobre três coisas novas
que encontraremos. A primeira coisa é
a instância do jogo, que é uma classe global, uma classe que está sendo criada
quando executamos o jogo pela primeira vez e que é destruída
quando terminamos o jogo. Quero dizer, termine o jogo
saindo do aplicativo. Então, isso é usado para armazenar
basicamente variáveis globais. É uma boa maneira de
demonstrá-lo e como acessá-lo
durante o jogo, qualquer momento
que quisermos, basicamente Há muitas maneiras de armazenar esses dados um pouco mais
complexos, como estados de jogadores, e para nós,
será um bom exemplo. A outra coisa sobre a qual eu queria
falar é sobre uma estrutura. Falamos um pouco
sobre estruturas que transformam uma estrutura, como se eu criasse uma variável de
transformação, uma estrutura de
basicamente três vetores E se o quebrarmos, podemos ver esses três vetores Bem, uma estrutura,
por definição, é um tipo de dados personalizado que nos
permite agrupar variáveis
diferentes, certo? Agora, essa estrutura tinha três variáveis diferentes
do mesmo tipo. nossa também terá duas
variáveis do mesmo tipo, mas é uma estrutura
própria, uma variável que contém as informações que
queremos conter de forma personalizada Então, primeiro de tudo, vamos para Blueprints Vamos clicar.
Vamos até a guia
Blueprint e
selecionaremos a estrutura Vou nomear essa mudança de nível
ST. E isso nos dá uma
variável por si só, e vamos criar outra, e elas
serão do tipo uma string. Na verdade, pode
ser do nome do tipo, mas vamos deixar uma string e vamos nomear
esse nível atual e o outro próximo nível. E isso é basicamente
uma estrutura. Poderíamos ter, por exemplo, outro que diz carregar a saúde
do jogador e outro que diz que o jogador tem
a habilidade de pular ou o que quisermos. É nossa estrutura,
nosso tipo de variáveis. Então, vamos salvar isso
e, em seguida, vamos
criar, ir para Diversos
e ir para a tabela E aqui, requer uma estrutura de seta de
seleção. Vamos escolher nossa mudança de
nível ST e pressionar OK. Vou nomear
essa mudança de nível de DT. E vamos abri-lo.
O que é uma tabela de dados? É uma coleção de dados
estruturados usando a estrutura que criamos e
que selecionamos para uso. Ele se organiza em linhas e colunas que
nos permitem armazenar,
gerenciar e acessar facilmente esse tipo de dados Cada linha corresponderá a uma instância
da estrutura e terá
suas próprias variáveis. Vamos criar algumas linhas. Na verdade, precisamos de mais
e, para esses nomes, vamos usar exit. A, na verdade, saia A, tutorial. Digamos que saia de um tutorial. Isso seria exit, B, tutorial e o
outro seria exit. A, transferência, e a
outra seria saída, B, transferência. Tudo bem E eu cometi um erro. Não queremos o nível atual. Queremos voltar à estrutura antes
de
fazermos muitas outras mudanças. Queremos que isso diga que dois
jogadores começam, basicamente. Início do jogador porque o que
vamos mudar é qual início de jogador
será escolhido. Por exemplo, se eu
sair do início do jogador A, vou para os próximos níveis início
do jogador B ou início do
jogador A. Quando eu sair do início do
jogador B, vou para os próximos níveis, jogo início B e vou e vem. Então, vamos criar um loop que
eu vou de uma porta, voltando para a
mesma porta
de onde vim e escolhendo uma próxima porta, voltando para ela, é melhor
mostrar, basicamente. Nós vamos
entrar por essa porta. Nós vamos
sair desta loja. Quando entrarmos nesta loja, sairemos pela última porta.
Opa,
não por essa, por essa,
por aqui Vamos preencher essas informações
em nossa tabela de dados. Vai ser o início do jogador. Quando selecionamos cada linha, podemos ver aqui embaixo
o editor de linhas, qual podemos adicionar
as informações. O próximo nível será comum. Mas para mais mapas
, será útil. Então, nosso próximo nível é o Mapa
Tutorial 2. Então, tudo
teria o mapa tutorial dois. Na verdade, nem tudo. Esses teriam apenas um tutorial sobre eles, que
é o primeiro. Tutorial. Parado.
Partindo desse nível, vamos para o tutorial dois. Vindo do mapa 2 do Tutorialm, estamos voltando
ao Agora, o que é esse player
start ao qual estou me referindo? Vamos primeiro preenchê-lo e depois
explicá-lo. Então, para a primeira linha
, será
sair de uma transferência. Vou copiar isso. A próxima será a transferência de saída B. E eu vou copiar,
na verdade, os nomes que eu crio neste tutorial de saída B neste tutorial de saída A e
neste tutorial de saída B. Tudo bem Agora, da mesma forma que usamos tags para o peão do jogador, da mesma forma que podemos usar
tags para as partidas do jogador E se examinarmos os
detalhes do início do jogador, você pode ver que tem uma tag inicial do jogador de objetos muito especial, que é diferente das tags que
já definimos. Então, essa seria a
largada inicial do jogador. Agora, vamos duplicar isso. Vamos adicionar um aqui. Vamos fazer com que se sobreponha a isso, que é a saída. Tudo bem Eu acho que está tudo bem. Então teremos mais
um aqui. E nós precisamos de um
teletransportador aqui. Então, vou
apenas duplicar isso girá-lo assim
e trazê-lo aqui Tudo bem Vamos sobrepor o início dos
jogadores com a saída Realmente não
importa a saída, para ser honesto. Tudo bem E vamos fazer o mesmo com
o mapa do tutorial também. Vou salvar os selecionados. Agora, para este mapa, também precisamos definir
a substituição do modo de jogo Então, modo de jogo em terceira pessoa, e vamos
fazer com que o jogador comece. Isso parece meio grande. Sim, estou longe de
onde eu deveria estar. Tudo bem, então precisamos nos
teletransportar aqui também. Então, vamos usar plantas,
portas, trocadores de nível,
não teletransportadores . Isso aqui. Tudo bem Vamos duplicar tudo isso e rotacioná-los. Ok. Vamos compilar e salvar e
voltar ao nosso mapa. Não, não adicionamos as
tags às unidades, então selecionamos a primeira. O primeiro seria assim. Vamos pegar a etiqueta. A
tag é transferência de saída A, e a outra seria transferência de
saída B e
cópia e colagem dos nomes, para que nenhum erro acontecesse E eu acho que isso
seria para este. E
continuaremos na próxima vez unindo tudo isso. Então, começa a fazer algum sentido. Eu vou te ver então. Adeus
37. Substituindo o modo de jogo para personalizar a funcionalidade de Spawn do jogador: Olá, e bem-vindo de volta
aos portais reais Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, terminamos com nossas tabelas de dados e
nossas estruturas. Também terminamos com a adição de
tags às partidas de nossos jogadores. Colocamos as partidas dos jogadores
onde
quiséssemos entrar e sair das portas e adicionamos as etiquetas às partidas
dos jogadores que correspondem a essa
largada, não
devo dizer que comece bem. erro inicial foi detectado, isso deveria dizer sair de um tutorial. Tudo bem. Agora, faremos com que o
jogador comece aqui mesmo. Por enquanto, também fizemos
o segundo nível, o Tutorial de dois níveis. Adicionamos o player começa aqui e as tags correspondentes. Também estou verificando se há erros. Transferência de saída B. Tudo bem. E agora vamos continuar e
criar nossa instância. Então, vou clicar com o botão direito do mouse. Eu vou para a aula de
Blueprint. Vou pesquisar,
por exemplo. E eu quero a
instância do jogo. Aqui está. Eu vou
selecioná-lo. Vou chamá-lo de GI doors Tutorial. E então precisamos ir
para as configurações do projeto. E pesquise, por exemplo. E em vez de uma instância de jogo, queremos que seja um
tutorial GI door na classe de instância de jogo. Agora, vou
fechar as configurações. Eles não precisam ser
salvos. O salvamento automático com cada alteração que fazemos E eu vou abrir a instância
do jogo. E aqui vamos criar
um evento muito simples. Vamos criar um evento
personalizado, chamá-lo transferência de
nível e
criar uma entrada para ele. Vai ser
do tipo string. Vai vir de. Vamos promover
isso para uma variável. E vamos
começar com Get Data TB. Não obtenha os nomes das linhas da tabela de dados, obtenha o plano da linha de dados. E esse é o
nó que
recupera as informações
da nossa tabela de dados Poderíamos ter uma variável aqui com as tabelas de dados que queremos, mas vamos usá-la manualmente e
selecioná-la manualmente a partir
daqui, mudança de nível de DT. Agora, o nome próprio, onde isso vem,
será o nome da nossa linha. Como você pode ver, a partir da string, ele a traduziu automaticamente em nome. A próxima coisa
que faremos é
interromper a mudança de nível. Vamos promover
isso para uma variável, e vamos chamá-la de camada ativa. Comece e, em seguida, abriremos
o nível meu nome e conectaremos o
próximo nível a aqui. Então, o que fizemos? Criamos
um evento de transferência de nível. Começamos o came from, que será o nome do início atual do
nosso player, e então encontramos a linha correspondente
na tabela de dados. Por exemplo, este
seria um tutorial de Sair A
e a próxima
partida de jogador que estamos salvando é a transferência de Sair A. Então, aqui dentro, estamos armazenando a saída de uma transferência de jogador
para o início ativo do jogador
e, em seguida, estamos
abrindo o nível que devemos abrir. Agora, quando abrimos
o próximo nível, essas informações aqui permaneceram como estão
porque, como dissemos, instância
do jogo é
um modelo global que armazena informações
por meio de transferências de nível Vamos voltar ao
nosso trocador de nível e mudar esse nível aberto Para chamar a partir da instância a nova função, o novo evento. Então, vamos
obter uma instância do jogo. E é assim que encontramos a instância do jogo, como
fizemos com o modo de jogo. Vamos transmitir
o tutorial do GI Drs. Vamos fazer
dele um elenco puro. E agora que sabemos que
essa é a instância, podemos obter algumas informações, que são o evento de transferência do
nível de transferência. Mas, como você pode ver, esse
evento precisa que isso venha. Então, vamos
promovê-la como uma variável e vamos expô-la no
spawn e criá-la no iStAnseable Precisamos pegar o plugue de
partida do player e vamos copiá-lo para que venha do
teletransportador E, na verdade, não
precisamos do teletransportador alvo, então podemos excluí-lo com segurança E, para ser sincero,
não precisamos da cápsula nem da flecha, nem da raiz. Sim, já parece melhor. E, por fim, lembre-se de
que, no início, eu disse que substituiremos
a funcionalidade em que nosso modo de jogo tem uma função predefinida de como
encontrar as partidas do Vamos sobrescrever esse comportamento e
criar um próprio para substituir um comportamento
que já está prescrito e pré-codificado em qualquer modelo . Podemos acessar as
funções, na verdade, sem pressionar o botão de adição, mas aqui, ele aparece
como um símbolo de substituição Então, pressionando isso, você pode ver as funções que podemos
substituir neste projeto Podemos selecionar o
jogador escolhido e começar aqui. Agora, a lógica de como isso funcionará será obter todas as
partidas do jogador que pudermos encontrar. Procure o início
ativo do jogador. Se você não conseguir encontrá-lo,
escolha o local de partida. Também criaremos um código para pesquisar o local de
partida. Basicamente, seria isso. Agora, como fazemos isso? Vamos voltar para a
terceira pessoa, Gao. Primeiro, vou criar uma variável local
que será do início não vinculado
do tapullan e do colli
player E quando começarmos o plano começarmos a ordem das operações, vou defini-la como verdadeira Então eu vou
pegar todos os atores do plus e a aula
pode ser o jogador inicial. Agora, esse é um nó que é um pouco pesado
porque passa por todos os atores do
nível que estão carregados. Mas como isso está acontecendo
antes do
início do nível agora, tudo bem. Agora, a partir dessa lista, vou colocar cada um. E vou verificar se
não vou verificar se
vou receber a inicial
do tag player. Acho que se chama G player
Start tag e vou compará-la se for igual ao início. Vou selecionar
uma filial aqui. E isso salvará nossa
largada da primeira partida do jogador. Então, vou promover isso para uma variável local e nomear
esse local inicial. Agora, vou promover novamente porque, se
não for o início dos jogadores, vou
ganhar instantes do jogo Eu vou escalar para GI. Vou me converter
para o Pure Cast e vou fazer com que os jogadores
ativos comecem. E agora, a partir dessa tag de início de
jogo, vou comparar se
esses dois são iguais. Se estiverem, então
esse é o nosso novo começo. Vamos dar a esse jogador o nome de Start. Portanto, se tiver a tag start, é o local de início. Se tiver a tag de início do jogador
ativo, é o início do jogador. Também precisamos fazer com que os jogadores
comecem e não caiam. E agora, no final, precisamos
verificar se encontramos
um início de jogador, se encontramos, então Sim, eu promovi isso para uma variável e até
uma variável local. Então, vou
excluir isso agora e promover novamente para o início da camada
variável local. Então, vou
conectar isso aqui. E. Vamos fazer com que o
jogador comece aqui. E se não encontramos, se isso não for verdade,
então é falso, então o início do jogador é o
início do jogador
que encontramos. Se o início do jogador não
for encontrado, isso significa que não
encontramos o início do jogador ativo, então vamos
definir o início do jogador, não chegar ao local de início. A convenção de nomenclatura
aqui não é das melhores. Vamos testar nosso
sistema. Vamos compilar Talvez eu precise
compilar isso também, é
claro, e compilar novamente
. E vamos jogar. Então, agora que estou me apressando, preciso adicionar as tags de início dos
jogadores Tudo isso diz também começar. Portanto, este é o
tutorial de saída B. Tudo bem. Os outros foram verificados no início desta lição. Então, teoricamente,
isso deve funcionar agora. Estamos aqui, podemos voltar. Nós podemos voltar, então não podemos
voltar. Não vejo nada. Então, acho que
não adicionei ao próximo
nível as etiquetas dos jogadores, as etiquetas das portas dos teletransportadores Sim. Foi isso porque,
no momento, ele estava
tentando descobrir o que
fazer, mas não conseguia. Tudo bem, vamos voltar
ao nível original. Então, indo desse jeito e
indo desse jeito, funciona. Então, se eu for por aqui, chegaremos ao último quarto. Mas há
mais algumas coisas a fazer. Ok, isso não estava correto. Vamos ver do que tudo isso veio. Mas eu acabei de colar isso. Tudo bem, funciona. E
eu vou para lugar nenhum Por que estou indo para lugar nenhum? Em primeiro lugar, diz trans.
Diz algo estranho. Transferência de saída B. Mas eu tenho o mesmo
erro em todos os lugares. Deveria estar funcionando. Ts. Vamos testá-lo novamente. OK. Então, acho que
houve algum erro de ortografia Sim. Temos um
sistema de transferência que funciona. Ótimo. Eu acho que
é isso para este. Te vejo na próxima. Adeus.
38. 7 Trabalhos básicos para salvar sistemas para preservar estados de portas: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, concluímos
nosso sistema de waypoints
dinâmicos de rede de vários portais Eu não sei como você
quer chamá-lo. Terminamos de nos
teletransportar desse nível para um novo nível que é a
representação disso Saímos daqui e
podemos ir e voltar. Desse portão para esse portão
e desse portão para esse portão, e então desse portão para esse portão e desse
portão para esse portão. Mas tudo isso está em
um nível diferente. Então, para fazer isso, criamos uma tabela de dados
cujos próprios nomes correspondem às tags
do nível de entrada, do nível de onde
estamos viajando, e ela tem os
nomes iniciais dos jogadores, também do nível para o qual
estamos indo e também
do próximo nível Agora, tudo isso é baseado em uma estrutura que é
de duas bebidas. Usamos isso em um evento. Na instância do jogo, que dissemos novamente, é um modelo global, e criamos a
transformação de nível da qual você
vem , de onde
vem do portão, e obtemos essa transformação, que corresponde ao nome da
linha da tabela de dados, e obtemos uma
saída dessa linha Através das colunas,
através da estrutura, iniciamos o próximo jogador
ativo e abrimos o próximo nível. Agora, quando um nível se abre, substituímos o início do jogador
escolhido E criamos uma
pequena função que busca todos os atores
iniciais do jogador. E então, se um deles
tem a tag start e olha para outra, se a encontra, ela tem
a tag inicial ativa do player Então, se tiver suas
etiquetas, está tudo bem. Se isso não acontecer,
receberemos um erro. Mas se as tags estiverem corretas, se encontrar um início de jogador
ativo, ele definirá esse início de jogador
como padrão. Agora, vamos continuar usando esse sistema para
demonstrar um salvamento. Então, o que vamos
fazer é
adicionar a porta aqui e
no outro nível. Vamos escolher uma porta lateral, que é muito simples,
não essa. De qualquer forma, sim, porta de sentido
único, essa. Nós vamos
trazê-lo aqui. Bem, aqui é relativo. É um pouco
maior do que deveria ser, mas vamos
torná-lo um pouco menor. Talvez um pouco maior que 0,5. Digamos, 0,7. Não, 0,6. Acho que 0,55 Sim. Tudo bem. Isso
realmente não importa. Eu o coloquei do lado oposto, mas vou
girá-lo e está tudo bem, porque estamos entrando por aqui, então a frente
deve ser assim E eu preciso consertá-lo novamente. Então, 0,57. Sim, 0,57 Isso meio que se encaixou instantaneamente. Tudo bem. Agora, vamos
para o nível de transferência, o mapa tutorial dois. Onde está o nível aqui. E vamos adicionar a porta novamente, que é aquela em que
está a porta de sentido único. Desta vez, precisamos
torná-lo maior. Seriam cinco? Cinco, é muito. Dois, três, 2,5, 2,2 parece bom. Vamos ligar por aí. Então, talvez 2,4. Sim, 2.4 parece bom. Tudo bem. Deixar como está, mesmo que tenha lacunas,
realmente não importa. Então, essa porta deve ser
capaz de salvar, por exemplo. Vamos para o Mapa. Deixe codificar os mapas por cores para
que você possa encontrá-los facilmente. Ok, o vermelho serve. Então, o que queremos fazer é
poder entrar daqui,
entrar nesta sala. Abra a porta, talvez
volte ou vá para o outro lado, e essa porta
ainda deve estar aberta. Então, vamos começar com
uma lógica inversa. Vamos começar pela porta. O que essa porta precisaria
ser carregada para carregar seu estado? Como se precisássemos definir de
alguma forma o estado da porta. E, dependendo
do estado armazenado, como estamos economizando
apenas na abertura total ou
somente no fechamento total, precisaríamos dos
graus finais de abertura ou fechamento. Portanto, precisaríamos definir
a rotação relativa. Vamos pegar o larp também. E vamos abrir
espaço para esses nós. Isso seria suficiente. Eu não precisaria de um larp aqui. Eu precisaria de uma seleção e isso seria
baseado no estado. Então, quando está aberto,
é -90 graus, -90 ou
-90 E quando está fechado ou em qualquer
outro estado, é zero. Bem, para nós, estamos apenas
carregando, abrindo e fechando, então abrir e fechar não
salvam os graus atuais. E bloqueado também seria zero. Mas como essa
porta sabe qual porta? Se eu tivesse dez desses, como ele sabe
qual é a porta? Para isso,
precisaríamos criar um ID personalizado. Eu
vou deletar. Esse texto é usado em algum lugar? Encontre referências? Não. Mas para
o D, eu não vou usar isso. Vou usar uma corda. Vamos chamar essa identificação da porta. Então essa ID de porta
no arquivo salvo diria: “Ok, ID, essa porta permaneceu
aberta ou permaneceu fechada dependendo do que ela
tem s. Para chamar essa mudança, devemos criar uma chamada na interface
do blueprint Então, vamos para
nossa interface do Blueprint. Faça a porta de carga. E essa porta de carga precisa retornar pelo menos o
estado da porta. Portanto, seria necessário ter uma variável que fosse a enumeração do estado
da porta Mas quando estamos
salvando um jogo, talvez
tenhamos mais de
uma coisa para salvar. Talvez tenhamos, se estiver trancado
como o item principal ou não, não, esse é um mau exemplo. Talvez tivéssemos cursos
de abertura. Então, talvez tivéssemos
coisas diferentes para salvar e carregar. Então, novamente, é aqui que
as estruturas entram em busca. Vamos
criar uma estrutura,
uma nova estrutura em plantas,
estrutura, e vamos
chamar isso de porta ST, salve Vamos abri-lo e, para
a primeira variável, vamos definir o estado da porta e
deixar que seja o estado da porta E. E vamos ter outra
variável que
seria a porta IE. E isso seria uma corda. E para ser honesto, se você
quiser alterar a ordem aqui, podemos ver esse ícone
aqui, ele se torna uma mão. Assim, podemos arrastá-los e
soltá-los acima e abaixo. É melhor ter a identificação
da porta primeiro. Eu vou salvar
essa estrutura. E em nossas portas de BI, vou colocar uma
entrada de estatísticas de portas, e será essa estrutura. D, porta, salve. Então, agora essa estrutura
nos fornece, quando carregamos a porta, todas as informações que salvamos para a porta. No momento, é muito simples. Ele tem apenas duas variáveis, o ID e o estado, mas poderia ficar mais
complexo conforme quiséssemos. Então, agora vamos
voltar para nossa porta. E compile. E vamos implementar o BI, as portas de
IA, a interface do
blueprint E agora temos
acesso a isso Não, não temos porque eu não
compilei a interface do
blueprint Mas agora que eu fiz, temos
acesso a essa porta de carga. Então, eu vou
trazer isso aqui. Vou conectar isso aqui. Vou quebrar a estrutura como fizemos com a transformação, e vou conectar
o estado da porta aqui. Basicamente, esse seria o
evento que carrega nossa porta. Quando a porta é
chamada para ser carregada
, falaremos sobre isso
mais tarde em outra lição. Isso é tudo o que ele
precisa para ser carregado. Agora, mais uma coisa
quando estivermos salvando a porta e explicaremos mais coisas na próxima lição. Quando estamos salvando a porta, precisamos de outra função. Vamos chamar isso de “abrir a porta”. E nessa função, teremos uma
saída do ST door save, e vamos chamá-la de door dots. Vamos compilar,
salvar e voltar para nossa porta. E clique duas vezes
em obter estatísticas da porta. Vamos dividir
a estrutura. Vamos conectar a identificação
da porta
aqui e o
estado da porta aqui. Portanto, essa função é usada para obter qualquer porta que
comece com ligações Agora, novamente, se essa estrutura
tiver mais variáveis, teríamos que conectar mais
informações ao nó de retorno. Eu acho que é isso para este. Vamos explicar a mecânica de
salvamento na próxima. Adeus.
39. Criando mecânicas de salvamento de jogos para manter o progresso nos níveis: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, começamos
com nosso Dor Save. Criamos uma nova estrutura, que contém a identificação da porta
e as estatísticas da porta. Além disso, criamos
duas novas funções na
interface do blueprint, a porta de carregamento e a porta de entrada,
a porta de carregamento tem uma
entrada de estatísticas de porta e a de getdor stats tem
uma saída de estatísticas de porta Em seguida, entramos
na porta Y Way,
criamos a porta de carregamento de eventos a
partir da interface do blueprint Nós quebramos as estatísticas da porta. Definimos o estado da porta para
o estado da porta salva e definimos a rotação relativa com base na estatística que carregamos no
estado da porta que carregamos Também
preenchemos o início da porta de entrada com uma nova variável chamada ID
da porta e estado da porta. E o ID da porta deve ser
uma instância editável e exposta no spawn para que
possamos preenchê-lo sozinhos Porque quando estamos
salvando as portas, elas precisam de um ID exclusivo. Então, quando carregamos as portas, eles sabem qual porta é
qual, então são carregadas. Agora, falando sobre
salvar o carregamento, precisaremos de um
novo tipo de blueprint,
salvar o blueprint do objeto do jogo Para criá-lo,
vamos clicar em. Vamos até Blueprints,
new Blueprint cross, e vamos
procurar por jogos salvos E está aqui. Vou selecioná-lo
e chamá-lo de So Doors. Sim, então Door. Vamos abri-lo. Agora, esse é o arquivo que está sendo gravado
em nosso computador. É um arquivo serializado. Tem essa propriedade de
ser uma classe serializável. Ele existe para garantir que os dados do jogo sejam
armazenados de forma persistente Isso pode ter qualquer
tipo de dado que quisermos. No momento, precisamos de uma estrutura, um conjunto de
estruturas, basicamente, porque pode haver
muitas portas, porta SD, exceto. E vamos fazer disso uma matriz. Vamos chamar essa porta de salvar. Começa. Estatísticas de salvamento de portas. Sim. Vamos fechar
isso. Não precisaremos mais das portas SO. Vamos
chamá-lo, mas não usá-lo. E vamos até
nossa instância de jogo para criar nossa mecânica de salvamento Agora, a primeira coisa que
faremos é criar um evento personalizado. E vamos
chamá-lo de Save Doors. E a primeira pergunta é: o jogo salvo existe? Agora, esse nó tem
nome de slot e índice de usuário. Podemos ter vários
slots para salvar. Então, vamos
promover a variável. Pode ser o nome do slot um, nome do
slot dois, o nome do slot três. Mas quando você está
carregando e salvando, o nome do slot deve ser o mesmo para que possamos demonstrar
isso melhor em ação. Então, vamos dar a ele um
nome padrão de portas, exceto uma. Vamos colocar uma ramificação aqui
porque é diferente quando não
temos um salvamento
nesse slot e diferente quando temos uma lousa no slot É como sobrescrever
o
salvamento e salvar um novo item nesse espaço Vamos começar com o
novo item neste slot. Então, em dobras, vamos
criar um jogo salvo. E o objeto de salvamento do jogo
seriam as portas SO. Vamos promover
isso para uma variável. Vamos
chamá-lo de salvar objeto do jogo. Agora, não teremos um mecanismo complexo
para detectar nossas portas. O que faremos é
reunir todos os atores da classe. Poderíamos ter uma etiqueta, mas a aula está boa. E vamos
procurar uma porta de sentido único. E de todas as portas
que encontrarmos para cada uma, vamos
começar a abrir portas. Então, agora, cada porta que existe, basicamente,
nos dá as estatísticas. E como é o primeiro salvamento, a primeira vez que salvamos, podemos simplesmente pegar nosso objeto de
salvamento do jogo, obter nossa variedade de estatísticas de salvamento de
portas e adicionar todas essas
estatísticas aqui. Então, ninguém pensaria
que terminamos de salvar, como passamos as informações
para o objeto salvo do jogo. Nós começamos e os adicionamos a essa matriz.
Bem, não exatamente. No final, ainda precisamos salvar
o jogo no slot de
cada loop. E aqui precisamos de
uma referência
do slot e do nome do slot. Então, novamente, é por isso que eu disse
que eles estão correlacionados. Eles estão convencidos de que
estamos verificando esse slot Não
devemos mudar
o nome do slot até concluirmos tudo o que
estamos fazendo com esse slot Isso seria apenas o caso de um jogo salvo não existir. E se existir um jogo salvo? Em seguida, vamos carregar o jogo no slot e o slot
precisa permanecer o mesmo. E por que estamos carregando porque precisamos dos dados de salvamento
atuais. Então, queremos
manipular esses dados. Então, o próximo passo é
lançar
SO doors em nosso jogo de salvamento , porque no jogo
que carregamos do lote, não
temos como criar apenas
um objeto de jogo seguro. Não sabemos qual é. Então, agora, nós
carregamos as portas do SO. Talvez também tivéssemos outras defesas. Tínhamos uma reserva para encadernações. Nós salvamos as estatísticas do
personagem. Tivemos uma reserva para missões. Este é para as portas. Novamente, vamos
passar por todas as nossas portas. Então, vou copiar o get all actors from class
e o loop four. Na verdade, eu também
precisava tocar nas portas. Agora vou
criar uma variável,
uma variável Bolling, e chamá-la de Nova porta Eu vou passar
por aqui. Então eu vou pegar nosso objeto de salvamento do jogo que
eu não configurei. Sim. Após o lançamento, devemos colocar nosso objeto de salvamento
em nossas portas. Salve porque esse é o salvamento que estamos
manipulando. Nós entendemos. Nós o carregamos, enquanto o
criamos antes, o salvamos instantaneamente
porque são portas SO, mas agora que estamos carregando, não
sabíamos de
que tipo era. Então, nós o lançamos nas portas do SO e o salvamos como o objeto do jogo que
estamos manipulando Agora, esse objeto tem nossa
matriz de portas. E para cada uma das portas, queremos puxar cada
laço para obter a identificação. E o que vamos fazer é
obter também a identificação que obtivemos dos quatro circuitos de portas de todas as classes de atores e
verificar se elas são iguais. Desculpe, esse igual não
tem uma string exata. E se estiverem, então acabamos de definir esse elemento de matriz. A partir daqui, defina o elemento da matriz porque
não queremos essas estatísticas. Essas são as estatísticas de salvamento. Os que queremos estão aqui. Vou criar um
nó de leitura para deixar isso mais claro. E eu leio aqui e
leio aqui e aqui. As estatísticas que estamos salvando os novos começos
vêm de todos os atores da classe, aqueles que ganham o mapa. Os inícios que
estamos comparando, se tiverem o mesmo
nome, são dessa lista. Então, se eles tiverem o mesmo nome, precisamos do índice dessa lista. E então fechamos a nova porta porque
essa porta não é nova. Eu já existo. Agora, quando esse
ciclo de quatro voltas terminar, perguntaremos se ainda
é uma porta nova ou encontramos uma
e mudamos as estatísticas Se ainda for uma nova porta, adicionaremos a essa matriz. Vamos ler isso
aqui e isso aqui. Vá um pouco para o fogo não derramado. E espere. Agora, não é novidade
se for uma nova porta, vamos adicionar à porta
a partir
do jogo de salvamento,
adicionar à matriz. E vamos
adicionar as estatísticas que
acabamos de obter das
portas do mapa. Tudo bem Agora, este seria nosso
save para comentar, pressione e eu
digitarei save game. Então, agora, isso tem um comentário. Sei que não
comentamos nada, mas devemos pelo menos
mostrar comentários Eu acho que é isso para este. Vamos continuar com o jogo de carregamento no próximo. Adeus por enquanto.
40. Programando sistemas de carregamento de jogos para progresso salvo: Olá, bem-vindo de volta ao
Andrea Engine five, Bluepin Mastery Door Systems e aos portais interativos Anteriormente, terminamos
com nosso mecanismo de salvamento. Verificamos se o
jogo já existe. Usamos um nome de slot para fazer isso. E, se existir, carregamos o jogo e lançamos para verificar se são nossos
objetos de jogo salvos que criamos. Armazenamos em uma variável. Analisamos todos os nossos atores. Recebemos suas estatísticas. Definimos uma nova variável de porta e percorremos todas as portas de
salvamento que existem. Eles são os mesmos se a
porta já existir, armazenamos os novos dados e
verificamos as novas portas. Se isso não acontecer, basta
adicioná-lo à lista. Agora, talvez eu devesse ter começado do ramo da força, como fizemos, e criar um jogo seguro. Abrimos todas as portas
e as
adicionamos à lista
de jogos seguros
e, em seguida, salvamos o
jogo de slot em slot. Algo que não fizemos
aqui e que deveríamos. Então, vou copiar esse objeto de salvamento do jogo e slot de
salvamento porque
os promovemos para variáveis aqui. E no primeiro loop, depois de
examinarmos todos os nossos
atores no mapa
, salvaremos no slot. Agora, por que fazemos isso
aqui e não aqui? Como esse é um loop
aninhado, isso significa que, para
cada um deles, faça algo para
cada um deles Então, quando isso termina,
quando isso termina, ele ainda tem que passar por
todas as portas que encontrou Então, quando ele passa por todas as portas que encontrou
, salvamos no slot. Agora, vamos continuar
com o jogo de carregamento. Então, vou criar
um evento personalizado. Vou chamar isso de carga. Vou
chamá-lo de cargas de carga. E vamos começar a programar. Então, primeiro de tudo, novamente, perguntaremos se o jogo
salvo existe? Porque se isso não acontecer,
não adianta, nem as novas portas,
o nome do slot. Não adianta
carregar nada. Só se for verdade,
vamos carregar. Se não estiver, não
há nada para carregar. Vamos carregar o
jogo do Slods. E o slot deve
ser o nome do slot. Agora, novamente, precisamos lançar até O doors e promover isso
para salvar o objeto do jogo. A próxima coisa que fazemos é
obter as estatísticas de salvamento de Save Dor. Vou promover
essas duas variáveis. Então vamos pegar
todos os atores da porta, sentido
único,
porque essa é a
porta que estamos salvando. E vamos dar cada volta e
vamos abrir a
porta. Não essa. Na mensagem, uma porque a outra era uma espécie
de chamada interna. Agora, faremos o mesmo
com as estatísticas do cofre da porta. Vamos fazer um loop.
Então, vamos criar nosso loop aninhado novamente
e vamos
comparar os nomes
das portas que
acabamos de colocar aqui com
as portas no nível Então, vamos ser iguais exatamente. Vamos nos ramificar
e se eles forem iguais, então vamos
abrir essa porta. Esta é a referência da porta,
e vamos carregar a porta. Novamente, não esta, a mensagem que definirá as estatísticas
da porta carregada. Tudo bem E isso
seria uma carga. Como nossas portas, isso encontra a porta que
somos, está no mapa e, em
seguida, executará essa função. Ele definirá o estado e definirá a
rotação relativa de acordo. E agora vem a pergunta: quando salvamos e
quando carregamos? E como o jogo sabe se é um jogo carregado
ou um jogo novo? Criaremos um sistema
muito simples. Transformaremos um lingote
em nosso modo de jogo, uma variável do tipo Bullion, e chamaremos
isso de jogo carregado ou checkpoint ou
algo parecido Quando começarmos o jogo,
queremos que isso acabe. Mas nossa primeira defesa, nosso primeiro ponto de verificação,
seria quando mudássemos de nível É por isso que mantive o
plano do trocador de nível ativado. Eu estraguei alguma coisa. Sim. Ok. Então, neste plano, quando mudarmos o nível e usarmos o
tutorial de GI para fazer isso, vamos configurar
o jogo carregado para terminar e também
vamos salvar as portas Então, quando
passamos pelo nível, configuramos que
o ponto de verificação está ligado Quando voltamos, ele ainda está
ativado porque o modo de jogo, a instância do jogo, é global. Ele contém as estatísticas
que definiu lá. E quando
voltarmos, carregaremos. Quando essa carga,
quando vamos carregar? Bem, dentro do modo de jogo, como o modo de jogo é executado
toda vez que um nível é aberto, perguntaremos: W é o modo de
jogo? Aqui está. Vamos começar a jogar. Depois de criarmos o widget,
obteremos o jogo instantâneo Vamos escalar para GI. Vamos fazer com
que seja um elenco puro e
vamos carregar esse jogo. Então, se for um jogo carregado, vamos colocar
uma ramificação aqui, vamos carregar bonecos, que é uma função que
carrega todos os bonecos Agora, a última coisa que precisamos
fazer é identificar nossas portas. Vamos dar uma identificação para a primeira
porta, essa, essa. Vamos dar um F. Não sei por que F,
mas é uma boa identificação. Digamos que isso seja F dois. Agora, como queremos que essa porta
se correlacione para corresponder, não se correlacione com a outra
porta no nível dois, elas precisam ter a mesma ID Então, esse também
seria F dois. Era uma capital? Hmm.
Vou verificar agora mesmo. Sim, use capital. Ok, então essas lojas compartilham
o mesmo arquivo salvo, então elas compartilharão
o mesmo estado. Espero que tudo
dê certo. Então, vamos testar. Vamos
verificar se está fechado. Estamos passando por aqui.
Estamos abrindo a porta. Vamos passar daqui
e a porta está aberta. Portanto, nossa carga segura funciona. E se eu começar o jogo
novamente, eles devem ser fechados. Então, sim, eles estão fechados. E no momento em que eu saio daqui, eu a deixei fechada, então
ela ficará fechada. momento, ele o salvou no estado fechado,
então está fechado, passando por aqui, abrindo a porta, saindo para o outro lado Eu realmente não consigo ver daqui de cima, mas eu posso ejetar, e ele está aberto Portanto, nossa mecânica de carga segura
funciona perfeitamente, e acho que isso
concluirá esta, e
continuaremos na próxima com nossa porta VFX. Adeus
41. Projetando uma porta com alças funcionais para interação imersiva: Olá, bem-vindo de volta
aos portais Unreal Engine five, Blueprint Mastery, Door Systems
e Interactive Anteriormente, terminávamos com
nosso mecânico de carga e segurança. Chamamos nosso jogo de carregamento em nosso modo de jogo em terceira pessoa. Quando cada nível começa,
já
que o modo de jogo está em execução, perguntamos:
é um jogo de carregamento, uma variável que salvamos na instância
do jogo, jogo carregado. Então, se for, também
carregamos o jogo por meio de
nosso evento que criamos
na instância do jogo, que carrega o jogo usando o mesmo
tipo de mecânica Mas em vez de salvar, carregamos cada porta. Em seguida, adicionamos
a alteração no trocador de nível, nas portas de salvamento e no jogo
carregado como true Então, o checkpoint, o jogo de salvamento começa quando vamos
para o próximo nível E quando voltamos, o jogo ainda está carregado e podemos ver os
efeitos de salvar e carregar. Vamos continuar com
nossa porta final,
a porta VFX que
duplicaremos a porta unidirecional Vamos até nossas portas. Vamos encontrar a porta de sentido único e vamos
adicionar uma alça a ela Então, vou duplicar isso. Vamos chamar essa
porta VFX e vamos abri-la. Agora, para torná-lo mais especial, vamos mudar
a cor para vermelho da porta. E também vamos
adicionar uma nova malha iniciada. Isso representará a alça. Então, vamos chamá-lo de identificador. E para a malha estática, usaremos o fígado. Eu acho que é um. Não,
dois. Sim, o fígado dois. Então, vamos colocá-lo no lugar. Vamos girá-lo. Vamos
trazê-lo aqui. É um pouco grande. Vou fazer com que seja metade do tamanho. Então, escala 0,5. E leve isso um pouco para frente,
e tudo bem. Agora, no início do jogo, vou armazenar sua rotação. Então, obtenha a rotação relativa, e eu vou promover
essa variável e
chamá-la de lidar com a rotação
relativa original. Vamos também adicionar os
sons da porta, para que possamos realmente
copiá-los e colá-los. Vamos trazer isso aqui. Vamos fechar todas as guias
à direita, compilar e salvar,
e vamos abrir Let's
opens double door Sim. Este tinha os sons. Então, vou copiar e
colar os sons
daqui para a porta VFX Vou fechar os dois.
Nós não precisamos deles. E eu vou fechar,
deve ser o tom mais baixo. Não, na verdade está aberto. R. Então, isso vale para jogar desde o
início e o tom inferior deve ser aberto
porque está fechando. E na verdade, você
sabe o que? Vamos apenas conectá-lo para reverter e jogar. Então a porta está mais animada. Ele abre e fecha enquanto faz a animação de abertura
ou encerramento E para tornar isso mais completo, vamos alterar a atualização do
widget para dizer fechar ao abrir e
abrir ao fechar Tudo bem E não queremos remover o widget quando ele está
abrindo ou fechando Então, isso deve reverter e o fechamento deve
continuar , porque quando
estamos fechando, estamos abrindo e quando
estamos abrindo, estamos fechando. Ok, acho que isso bastará. Agora, vamos adicionar a animação da
alça. Faremos isso antes
da primeira vez, é claro. Traremos a alça e
definiremos a rotação relativa. Vou adicioná-lo
aqui. E vamos aprender um rotador Na verdade, você sabe
o que? Não usaremos a rotação
original da alça. Vamos exatamente o que é
essa rotação estranha. Isso deve ser -90, 90 e zero. Tudo bem Sim, essa rotação
foi muito estranha. Se estivesse salvando essa rotação, seria muito difícil. Agora, por que isso acontece, há algo
chamado Gimbal ok e algo chamado
quardans E às vezes essas coisas
podem bagunçar um pouco. Então, vamos de -90 e -90. Para, digamos, 40. Não 400, 40 e -90. Eu acho que deveria ser -40 também porque é 90 se
eu girá-lo para baixo É positivo 40. Mas aqui, é menos. Mesmo que vejamos positivo
no eixo aqui embaixo. De qualquer forma, vamos compilar e salvar. E para Alpha, o que usaremos, é
claro, o caminho mais curto E vamos criar
um novo caminhão de fluxo. Então, no caminhão de fluxo, vamos chamar isso de manípulo. O primeiro drive
Alpha de uma porta. Ok. Então, eu tenho que fazer isso o mouse, se eu apenas
diminuir o zoom, o chefe
controlador
não faz nada Então, dois pontos,
na verdade três pontos. Um é zero, zero. A próxima seria: quanto
custa a primeira linha do tempo? Meio segundo. Portanto, a alça deve
ser metade disso. Então, o total seria 0,25. Isso pode ser zero novamente. E o meio
disso seria 12,5. Então 125, e seria um. Vamos compilar e salvar, e vamos conectar nossos identificadores ao
nosso alfa Então, isso significa que ele girará
para baixo e girará de volta para cima. E esse seria o nosso identificador. Então, vamos trazer nossa porta aqui. Faça um pouco bem porque
tem aquele brilho do Express Play. Temos que viajar. Tudo bem E ela se abre em frente e
a alça fica ali. Mas podemos ver que é animado. Tudo bem, então vamos mudar
para onde está aberto. Vamos definir isso para 90. E vamos fazer da maçaneta
uma filha da porta, para que ela se mova com a porta. Além disso, vamos fazer com que
nosso jogador comece
aqui para que não precisemos viajar
três vezes para vir aqui. Então, certo. Qualquer coisa aberta, feche enquanto estamos
abrindo e fechando. Vamos movê-lo um
pouco para o lado. E vamos acrescentar algo mais. Vamos adicionar um efeito
visual real para acontecer quando a
porta terminar. Mas vamos fazer isso na
próxima lição. Eu
vou te ver então. Adeus.
42. Finalizando a mecânica de porta de maçaneta com efeitos de partículas e aprimoramentos visuais: Olá, bem-vindo de volta
ao Anreal Engine five,
Blueprint Mastery, Door Systems
e Anteriormente, começamos
com nossa porta VFX. Mudamos para fazer a porta abrir e fechar enquanto
ela está fechando e abrindo com E usando o interruptor e usando as saídas de abertura
e fechamento E também adicionamos
uma maçaneta na porta que instalamos
na malha Srtic E nós o animamos usando
nossa linha do tempo, configurando a rotação relativa da
alça para um rotador estático Agora, dissemos que vamos
adicionar alguns efeitos visuais, mas vamos adicionar mais algumas coisas. Por exemplo, vamos adicionar
um som à alça
e, desta vez, vamos
usar um componente de áudio. Então, para demonstrar seu uso. Então, vamos chamar isso de som D. Então, o que é esse componente
de áudio? Como
componentes de malha estática e como outros componentes,
é uma concha. É um tipo de concha. Então, esse tipo é áudio. Está vazio, então temos que
definir o tipo de som que ele toca. E não vamos fazer
isso em detalhes, vamos fazer isso em
tempo de execução porque, como é um componente de áudio
da porta, ela não desaparece. Quando tocamos som em D, ele cria som
e desaparece Agora é um componente. Portanto, é um som que o temos como uma variável nos componentes. Na verdade, você pode encontrar o som
da porta aqui, componente de
áudio,
reutilizá-lo e alterá-lo sempre Eu vou trazê-lo aqui. E ao pressionar E, eu
vou fazer uma sequência, e eu vou parar, primeiro de tudo, qualquer som que esta porta
esteja tocando. A próxima coisa
que vou fazer é definir um novo som. Então, vou usar
o nó de som definido, conectado aqui,
talvez um pouco mais de espaço. E para o som, vou escolher
a maçaneta da porta. A próxima coisa que precisamos
fazer é tocar o som. E seria isso. Mas vamos usar o som da porta, o componente de áudio,
para um segundo uso. Vou copiar e
colar tudo isso. Eu vou até o final
do cronograma. E quando estou fechando
a porta, nem sempre, apenas quando estou fechada, a
porta está fechada, não aberta, queremos abrir espaço
para tornar isso mais visível. Vamos trazer isso aqui. E no final da
linha do tempo,
basicamente, vamos
conectar essa Vamos trazê-lo aqui. Então, agora, quando a porta
estiver realmente fechada, ela reproduzirá um som fechado. Então, vamos escolher a porta, fechar. Agora, nossa maçaneta
emite um som
e, quando a porta
está realmente fechada, ela está tocando
um som que está fechando e está fechada. Eu aqueci a animação de perto e
terminei, basicamente. Vamos testar isso.
Vamos compilar primeiro Vamos jogar. OK. Como você pode ver, quando tenta tocar o som da maçaneta, fica
evidente pelo
som da porta fechada Tudo bem. Agora, isso está acontecendo
porque estamos parando o som da porta e tocando um
novo som sobre ela. Então, como esse som
não acabou, onde está aqui, não terminou de
tocar quando estamos fechando a porta,
ele é interrompido. O que é isso? Por aqui? É interrompido. Ele
diz um novo som e reproduz um novo som. A próxima coisa que faremos
é ir ao nosso mapa e demonstrar um pouco
como obter todos os atores com tag, porque
demonstramos tag, porque
demonstramos que estamos recebendo todos os
atores do mapa, depois
filtramos a classe e descobrimos quais
atores são os que queremos. Agora vamos fazer isso com
um get all actors of tag, que não passa por
todas as classes, todos os atores
no mapa, apenas
passa por todos os atores de tag. É um nó muito mais ideal. Para fazer isso, em primeiro lugar, vamos trazer
nosso sistema de partículas NS fireworks em nosso mapa Vamos colocá-lo em algum lugar. Não vamos ativá-lo. Então, vou
entrar em seus detalhes. Como você pode ver, a
partícula, por padrão é ativada no momento em
que eu a adiciono ao mapa Agora, se eu passar por aqui
nos detalhes e pesquisar por auto ativo,
será desligado e agora
não haverá mais partículas Então, vamos também pesquisar a tag e ir até Actor tanks
e adicionar a tag P. Vou movê-la para cá, movê-la para cá, certo? Isso atrás da porta. OK. Agora, vamos ativar
essa partícula. E vamos fazer um truque. Como eu quero que isso aconteça,
novamente, somente quando
a porta estiver fechada, vamos ativar a
partícula como quando a porta se fecha completamente,
então
a partícula é ativada, não quando a porta está se não quando a porta Mas eu quero que isso seja
comum em ambas as funções. Agora, eu poderia separar
isso e realmente adicioná-lo em algum lugar aqui ou depois daqui, porque ele
atualiza o widget Mas o que podemos fazer é mostrar um
pequeno truque aqui. Vamos fazer
uma sequência novamente. E agora podemos ter isso como
uma funcionalidade separada, lógica
separada para quando
a porta está se fechando. Agora, vou
pegar todas as portas com etiqueta. E a etiqueta será P para a
partícula que acabamos de criar. Uma coisa interessante
seria ver que este está recebendo todos os atores do tag,
não todos os componentes. Temos nosso componente no player
da
cápsula que é novamente P. E aqui temos um
ator com uma etiqueta P. Um ator não é um componente. Portanto, esse nó
aqui não
procuraria a classe do jogador. Então, se eu imprimir uma sequência de caracteres aqui, para cada duas, e na verdade, não
preciso fazer isso. Não posso simplesmente imprimir uma sequência de caracteres e obter o comprimento delas. E
conecte-o com a string de impressão. O que devemos ver quando eu pressiono play e abro e
fecho a porta é um. Como você pode ver, ele
não pesquisa. Não encontra o componente do
personagem que tem o ataque P. É só procurar atores. Isso foi só uma demonstração. Não precisamos da sequência de caracteres de impressão. Mas o que precisamos fazer é obter a primeira
cópia da matriz. Esse é outro
nó de matriz do qual podemos obter um número da lista. Então, vamos escalar para o sistema
Niagara, ator do Niágara. Porque pegamos o ator, mas não sabemos que
tipo de ator é. Só temos uma etiqueta. Se fossem Gepoactors da classe, poderíamos filtrar a classe e ter acesso
direto a essa Mas agora que é
getOactOS da tag, precisamos converter nosso resultado para perguntar se essa é a
classe que queremos E a partir daqui, obteremos
o componente Niagara. Acho que está na parte inferior, sim, e defina ativar. E como você pode ver, novamente
precisei
obter o componente Niagara,
porque se eu desenhar a partir daqui,
ativar, você pode ver ele me
leva diretamente ao componente Niagara Este é um ator do Niágara, mas o que estou ativando é do Niágara Então, vou definir o reset. Além disso, isso significa tocar a
partícula desde o início e vamos tocar um som
quando isso estiver acontecendo E para fazer isso, não
vamos tocar
o som sem parar. Vamos jogar 100 vezes,
100 fogos de artifício. Não se correlacionará com a partícula, a partícula permanecerá viva após os
cem Mas 100 sons, eu acho que
é o suficiente para fazer isso. Ok, então vamos fazer N. E em vez de
encontrá-lo aqui, o que é um incômodo, pressione N e
clique. Basta trazer D N. Vou ajustar o N para 100. Vou fazer o
delay aqui, que ele não reproduza um som
após o outro instantaneamente. Vamos fazer um carro alegórico organizado
aleatoriamente. Então, damos um
pouco de randomização. Vamos fazer 0,5 para um. E vamos tocar som para D. Isso também vamos
tocar com um tom. Vamos fazer uma
flutuação aleatória ao alcance. E vai
ser de 0,9 a 1,1. Para o som,
vamos escolher fogos de artifício e depois
precisaremos chamar isso novamente. Vou criar
um evento personalizado e
chamar D e fogos de artifício Vou
conectá-lo aqui e vou fazer fogos de artifício Então, isso cria um pequeno loop
que será reproduzido 100 vezes e depois
não será mais reproduzido. Mas antes de testá-lo, vamos também adicionar um
pouco de cinematografia Vamos acrescentar algo para que
possamos ver os fogos de artifício
em nosso player Para fazer isso, vou
trazer um ator de câmera fotográfica. E vou clicar com o botão direito
na câmera e pilotá-la. Não é Pivot, piloto,
ator de câmera, aqui está. Então, agora eu estou realmente
movendo a câmera. Você pode ver aqui em cima, ator
piloto, ator de câmera. Então, agora eu sou
basicamente a câmera. Então, eu quero uma bela vista
de onde eu quero ver, talvez possa ser aqui, para ser honesto,
poderíamos ver tudo. E vou confiar em
Came Actor. E como eu possuo
essa câmera? Como faço para mudar a visualização? Bem, existe um nó muito
simples chamado Bt view Par get Blend. Mas, como você pode ver,
não posso ligar daqui. O motivo é que eu preciso primeiro obter o controle
do player,
porque ele é um controle. O controlador tem uma
câmera e um gerenciador. É quem
deveria fazer isso. Então, se eu estou apenas me arrastando de uma execução aleatória,
ele não pode me dar isso Na verdade, pode, se eu definir o alvo de
visualização com o blend
e desativar a contaity Eu posso ver isso aqui. Você
pode ver o jogador do jogo. Agora, como o jogo do jogador e gerenciador
de
câmera são filhos do controlador do jogador, eles estão incluídos aqui
em um sentido muito amplo de como as classes funcionam e
herdam umas das outras De qualquer forma, vamos
definir uma meta de visualização com o blend. E se eu desligar o conteúdo,
ainda não consigo vê-lo. Ah, aqui está. Talvez
tudo esteja errado. De qualquer forma, a partir do
controle do player, podemos obter isso. Agora, o novo alvo de visão
seriam nossas operações de ator de câmera, e o anterior
seria nosso controlador. Vou compilar e salvar, vamos definir o
tempo de mistura para 2 segundos, 2,5 e vamos testá-lo Então, vou apertar play
para abrir a porta, e quando eu a fechar, devemos
misturar a visão do alvo e
ver os fogos de artifício OK. Os fogos de artifício funcionaram, mas a câmera não funcionou
porque eu deixei o rebocador Isso foi anticlimático. Então, a segunda vez é o charme. Vamos abrir e fechar. Como você pode ver, eu
ainda consigo mover o personagem, o que não é grande coisa. Mas se quiséssemos parar com isso, poderíamos simplesmente ir até aqui, controlar p
e desativar a entrada. Mas eu gosto de poder mover
o tapete, para ser honesto. E agora não consigo
mover o tapete. Agora, veja, a
abertura permaneceu, então seria necessário
um novo código aqui para remover o widget, o
que, na verdade, podemos fazer facilmente Meio que copiar e colar isso. O widget
de remoção do modo de jogo. Vamos esclarecer
um pouco. Vamos jogar. Sim. O widget foi removido, a porta está se abrindo
e temos fogos de artifício Tudo bem. Agora, vamos fazer com que o jogador
comece do começo. O jogador começa
com uma tag start. Portanto, nosso mapa está completo. E vamos examinar isso. Vamos aqui, nos aproximamos
da porta, ela se abre. Vamos até aqui, ele fecha. Usamos o
esquema de nível para fazer isso. Criamos então uma planta de
porta que se abre com E e fecha Em seguida,
criamos uma porta que se abre, fecha e
se abre em frente à camada Fizemos dela uma porta dupla e
adicionamos um pouco de som a ela. Fizemos uma fechadura
na porta do outro lado, uma porta curta. Que o jogador precisa
estar desse lado para abrir. Fomos e fizemos uma porta de
quebra-cabeça com uma alavanca que precisa de uma
única alavanca para abrir, e o fígado abre, envia a porta, envia a porta,
a mensagem para destrancar E então criamos um sistema de duas alavancas em que a
porta verifica as alavancas Criamos um pouco
de física aqui com as caixas. Acho que foram dois,
sim, o truque, estamos pressionando dois, e temos a porta deslizante aqui
com dois pressostatos Temos um pequeno quebra-cabeça com botões que a porta abre e fecha se
o quebra-cabeça estiver correto Também temos uma porta de itens. Se você escolher o errado primeiro. E então temos o telepot. Para outro local do mapa. Temos nossa loja de física. Temos um teletransporte para outro
mapa que demonstra a capacidade de salvamento que podemos
ver que a porta está aberta aqui E se eu passar de novo, fechamos e vamos até aqui. Vou ejetar, e
podemos vê-lo fechado, e estamos mudando os níveis
durante todo esse procedimento, e então temos nossa loja de efeitos visuais Essa alça cria alguns fogos de artifício
e muda nossa câmera E acho que seria isso. Parabéns por chegar
até aqui no tutorial da série Door. Você domina o essencial e está pronto para enfrentar os
desafios futuros Obrigado por acompanhar. Sua jornada não termina aqui, então fique curioso e continue explorando até a próxima
vez, ganhando com prazer.