Bem-vindo de volta, meus colegas desenvolvedores de jogos.
Neste vídeo, na verdade, vamos colocar as entradas que criamos para
usar e veremos como as variáveis são importantes.
Então, agora, quando tivermos nosso ganho,
você notará que não ficamos parados lá.
Você não tem nada no console.
Quando pressionamos a tecla WASD,
podemos ver que nosso jogador se move para a esquerda, para a direita,
para a esquerda, para cima, para baixo.
E não só isso, se eu aumentar a velocidade de movimento,
lá vamos nós, somos muito mais rápidos.
Então, não só movemos o jogador com as teclas,
também podemos controlar a rapidez com que ele se moveu.
Então, bem, dito isso
não vamos perder mais tempo e vamos começar.
Ok, então agora que temos as entradas prontas,
vemos como elas funcionam.
É hora de realmente começar a mover o jogador.
Como prometemos.
Vamos abrir o script aqui.
E vamos prosseguir e remover esse log de pontos de depuração.
Estes estavam aqui também.
Faça-nos acreditar que isso está realmente funcionando.
Ok, então a primeira coisa que precisamos fazer é que precisamos
acessar a posição transformada do jogador.
Então, vamos seguir em frente e clicar em Transformar.
E você pode ver aqui como o visual Studio já é útil.
Está nos dizendo qual é a transformação.
Portanto, a transformação que vai escrever agora é o transporte anexado a este objeto do jogo.
Qual objeto de jogo?
É o objeto do jogo que tem o script do controlador do jogador nele.
E se olharmos para trás aqui,
clicamos na camada.
A qualquer momento, clicamos no jogador.
Podemos ver que o controlador do jogador está ligado ao jogador e
a transformação que está no GameObject não joga como esta.
Então, estamos acessando essa transformação específica.
Então, de volta aqui,
vamos escrever transformada novamente,
pressione Tab para completar a posição do ponto da palavra.
Você pode ver que pode acessar a posição, a escala,
a rotação, tudo o que está disponível na transformação.
E nós escrevemos posição.
Agora, isso será igual a um novo vetor três.
E vai ser, digamos,
por enquanto, apenas 0,1 f.
E também podemos escrever o ponto 1 f. Isso significa 0,
e vamos manter o eixo z no mesmo lugar. Vamos salvar isso.
Agora, você pode estar pensando por que Vector3
não dizemos que não queremos modificar isso?
Bem, se passarmos o mouse sobre a posição,
você pode ver que a posição do espaço mundial da transformação como um vetor três,
que também pode passar pelas documentações e ver que é
realmente a posição transformada de qualquer objeto,
independentemente de estarmos usando 3D,
2D 1D, Isso é impossível,
mas você obtém o vetor de imagem três posições.
Sempre acessamos a posição do vetor C,
mas a mantemos como 0 f.
Agora o escopo não está completo,
mas vou usá-lo apenas para aprendermos à medida que cometemos erros,
vou salvar isso.
Vou voltar aqui.
E vamos apenas obter alguns valores reais aqui para que saibamos,
então menos cinco e digamos que isso seja menos 1 salvará isso.
Vamos executar nosso jogo e vamos dar uma olhada. Lá vamos nós.
Então 0.10.1.
Agora, qual parece ser o problema?
Não estamos chamando isso de cada quadro?
Bem, o problema aqui é que estamos simplesmente atribuindo esse valor aqui,
o novo vetor, 30.10.10 f para a posição.
Em cada quadro, não estamos aumentando a posição de transformação.
Então, como vamos começar a aumentar?
Deixe-me parar o dramaturgo aqui.
Vamos escrever que tomamos a posição de ponto de transformação do objeto do jogo
e, em seguida, adicionamos a ele o 0.10.1 vector 3, cada quadro.
Então, vamos salvar isso.
E vamos voltar e olhar para o nosso jogo,
como ele parece agora.
Nós executamos o jogo e lá vai você. Muito objetivos.
O jogador acabou de sair do prédio,
como você pode ver, como você pode ver agora o que acontece aqui.
Tomamos a posição transform.py.
Atribuímos na transformação já disponível,
mas posicionamos mais o vetor 3,
e fazemos isso a cada quadro.
Então, digamos que comecemos em 0, 0.
Levamos 000 aqui,
adicionamos a este vetor,
o próximo quadro temos 0,21.
Nós pegamos, adicionamos a ele, ele se torna 0,2.
Nós pegamos, adicionamos a ele se torna 0,3.
Então, cada quadro aumentamos isso.
Agora, como você pode ver, há código redundante aqui.
Redundante significa que estamos usando isso várias vezes.
Para evitar isso, podemos simplesmente remover isso aqui
e, em vez disso, adicionar uma vantagem por trás dos iguais.
E essa é exatamente a mesma sintaxe de antes.
Então, se escrevermos isso de novo,
deixe-me duplicar isso.
Vou simplesmente adicionar duas barras.
Isso se torna um comentário.
E, como já dissemos,
um comum não executa o código,
e simplesmente removeremos isso.
Então, como um pequeno lembrete do que essa vantagem é igual a isso.
Então, vamos salvar isso.
Vamos voltar ao nosso jogo e vamos deixar isso um pouco menor,
então adicionaremos outro 0 e aqui,
salvaremos isso de volta em nosso jogo.
Nós executamos o código, o jogo.
E lá vamos nós,
podemos vê-lo lentamente flutuando para longe e de novo, ótimo.
Então agora temos nosso jogador se movendo.
Mas não queremos que esses valores sejam apenas arbitrários.
Não queremos ter 0,1 ou 0,01.
Na verdade, queremos que a entrada que recebemos aqui mova o jogador.
Então, esse será o seu desafio.
Seu desafio é mover a posição do jogador com a entrada.
Então você acessará a posição da transformação do jogador.
Você vai tornar a posição um novo vetor 3.
E você vai usar o movimento input.txt e ponto
y, pois o x e y deste novo vetor
3 também manterá o eixo z em 0 F. E alguns apenas um pouco de ajuda extra.
Eu recomendo que você analise a documentação do Unity e veja o exemplo.
Eles foram tão legais na empresa Unity em algum lugar
para nos dar um exemplo exatamente do que estamos procurando.
Então, pause o vídeo agora mesmo e faça o desafio.
Certo, bem-vindo de volta.
Então, se rolarmos para baixo aqui,
você pode ver que obtemos a entrada horizontal,
obtemos a entrada vertical e,
em seguida, colocamos todas elas dentro da posição transformada.
Este é o exemplo exato de que precisamos e nosso ganho.
Então, se voltarmos aqui, em vez de 0,01,
vou escrever o ponto de entrada do movimento x. Vou escrever a entrada do movimento ponto y.
E vou salvar tudo isso.
Agora, de volta ao nosso jogo,
executamos o jogo e agora nosso jogador não se move.
Se quisermos movê-lo para a direita,
tivemos o Dickey que ele se move para a direita,
a esquerda, e ele desapareceu.
Então, como você pode ver, nosso jogador é extremamente, extremamente rápido.
Por que isso? Bem, é porque as atualizações são chamadas de cada quadro.
Então, se tentarmos jogar de novo,
deixe-me mostrar o que quero dizer.
Se procurarmos aqui as estatísticas,
podemos ver quantos quadros por segundo temos.
Então você sabe o que são quadros por segundo?
Se você já jogou um jogo e pode ver agora
, são quase mil quadros por segundo.
Estamos chamando isso mil vezes, 1000 vezes.
Estamos adicionando um,
então estamos adicionando um 1000 cada vez ou a cada segundo, se você quiser.
Então, como vamos controlar isso?
Bem, há uma maneira muito simples,
e isso é multiplicando isso pelo tempo.DeltaTime.
E o que acontece agora,
time.DeltaTime, se passarmos o mouse sobre ele,
é o intervalo e segundos do último quadro para o atual.
Então, o que isso faz é que leva o tempo entre cada quadro,
nós o multiplicamos por este e agora nos tornaremos a taxa de quadros e dependente.
Deixe-me mostrar o que isso significa.
Isso significa que quando executamos o jogo,
o tempo que leva do primeiro quadro ao segundo é adicionado ao movimento.
E agora, quando apertamos a tecla D, lá vamos nós.
Somos muito mais lentos.
E se tivéssemos o W, movemos para cima, SVMs para baixo, a,
nos movemos para a esquerda, movemos para a direita,
e assim por diante e assim por diante.
Quão legal é isso?
O que temos em outro plural,
quem somos extremamente baixos.
Isso não é maneira de jogar um jogo,
especialmente quando temos inimigos assustadores nos seguindo.
Então é por isso que tínhamos essa variável de velocidade de movimento o tempo todo.
Isso nos permitirá controlar nossa velocidade.
Então agora também vamos multiplicar isso pela velocidade de movimento.
Vamos salvar isso.
Então, de volta ao nosso ganho,
podemos ver que a velocidade de movimento é 20.
Vamos defini-lo para cinco.
Salve isso, execute o jogo.
E agora podemos mover para cima, para baixo,
para a esquerda, para a direita, como quisermos.
Quão legal é que finalmente temos um personagem,
um jogador que está se movendo em um mundo que criamos usando código simples.
Vamos fazer isso 50.
Vamos dar uma olhada nisso. Bem, lá vamos nós.
Podemos até controlar o quão rápido ele vai.
Quero dizer, sério, quão animado você está?
Talvez seja só eu.
Vamos mantê-lo às cinco. Acho que cinco.
Nenhuma fibra realmente lenta. Vamos fazer então.
Sim, lá vamos nós.
Então 10 parece muito, muito bom.
E com isso feito,
espero que você goste.
Antes de apresentar o próximo vídeo,
você notará que ainda podemos caminhar pelas
paredes e ir embora, o que não é bom.
É por isso que no próximo vídeo,
estaremos aplicando física ao nosso player e
o faremos interagir com vários objetos em nosso mundo.
Com isso dito, quatro,
eu vou me certificar de confirmar suas alterações.
Eu não vou fazer com todos os vídeos porque
é algo que você precisa se tornar automático.
E toda vez que você fizer algo importante em seu jogo,
certifique-se de preparar todo o trabalho,
comprometer todo o seu trabalho,
e eu te vejo no próximo vídeo.