Há muito mais na realidade do que uma mente humana consegue imaginar
Hallow, pessoal! Aqui, quem tá falando é o InterPlay. Hoje eu estava olhando as pastas do meu PC de maneira aleatória e, dentro da pasta de arquivos de texto, encontrei esse tutorial que fiz numa época em que estava tentando aprender a fazer jogo no Unity 3D. Claro que já desisti disso faz tempo, mas o tutorial ainda parece ser funcional. Então pensei em publicá-lo, pois deixá-lo assim para mofar no meu PC não seria uma boa ideia. Então... Fique aí com o tutorial!
Sistema de Movimentação
(JavaScript para Unity 3D)
(JavaScript para Unity 3D)
Esse tutorial é destinado a alguém que, pelo menos saiba, como adicionar um script aos objetos dentro do Unity. Para fazer um sistema de movimentação para jogos, usando o Javascript e o Unity 3D, basta seguir os passos abaixo:
1º Passo: Raciocínio
Dizer quais serão as teclas usadas para a movimentação. Nesse caso usaremos as letras (W, A, S, D) para mover para frente, para trás, para a direita e para a esquerda. Se você quiser, também é possível adicionar um movimento de rotação, como veremos mais abaixo. E também até mesmo um movimento de rotação com o mouse.
2º Passo: Lógica da Programação
Abra seu script e crie uma variável para receber a velocidade da movimentação. Nesse caso, a variável declarada será:
var VelMov : int;
Depois, na função Update, digite qual será o valor que essa variável receberá durante todo o jogo:
VelMov = 10*Time.deltaTime;
É necessário que seja multiplicado por Time.deltaTime para que a velocidade seja em metros por segundo. Caso contrário, ela será em metros por ciclo do processador o que pode causar bugs. Depois disso, ainda na função Update, escreva as estruturas de decisão:
if (Input.GetKey(w)) {
transform.Translate(0, 0, VelMov);
}
if (Input.GetKey(s)) {
transform.Translate(0, 0, -VelMov);
}
if (Input.GetKey(d)) {
transform.Translate(VelMov, 0, 0);
}
if (Input.GetKey(a)) {
transform.Translate(-VelMov, 0, 0);
}
Repare que no lugar do número foi colocada a variável VelMov. Isso ocorre, pois não é possível declarar o Time.deltaTime dentro dos parênteses. Se você declarar apenas um valor fixo dentro dos parênteses, ele será calculado de acordo com o giro do seu processador. Agora, abaixo, veja o que essas funções estão dizendo:
Se (Enquanto estiverem Apertando a tecla (w)) {
Faça o objeto que carrega este script mover-se de acordo com o valor de VelMov, no eixo z;
}
E nas demais linhas o script também está dizendo as mesmas coisas. Nas vezes em que VelMov aparece em negativo com o sinal de - antes significa que é para ir em direção oposta a que deveria ir. Se com o valor VelMov ele vai para frente, com o valor -VelMov ele vai para trás. Simples, não?
3º Passo: Movimento com rotação.
Para adicionar um movimento de rotação ao script de movimentação basta declarar uma nova variável para receber a velocidade de rotação:
var VelMov : int;
var VelRot : int;
Em seguida, na função Update, basta declarar qual será o valor dessa velocidade:
VelMov = 10*Time.deltaTime;
VelRot = 22*Time.deltaTime;
Nesse caso, vale a pena dizer que, quando se trata de rotação, estamos trabalhando com graus e não com metros. No caso acima, 22 graus por segundo. Após isso, basta declarar quais teclas que realizarão essa rotação:
if (Input.GetKey(l)) {
transform.Rotate(0, VelRot, 0);
}
if (Input.GetKey(j)) {
transform.Rotate(0, -VelRot, 0);
}
Não esqueça que a rotação deve ser aplicada ao eixo y, como vemos no exemplo acima. Outra coisa que vale apena dizer é que essas linhas acima podem ser adicionadas logo abaixo das linhas da movimentação, dentro da função Update. Tudo que essas linhas acima estão dizendo é:
Se (Enquanto estiverem Apertando a tecla (l)) {
Então faça o objeto que carrega este script realizar um movimento de rotação de acordo com o valor de VelRot, no eixo y;
}
No fim, seu script deverá ficar assim:
#pragma strict
var VelMov : int;
var VelRot : int;
function Start () {
}
function Update () {
VelMov = 10*Time.deltaTime;
VelRot = 22*Time.deltaTime;
if (Input.GetKey(w)) {
transform.Translate(0, 0, VelMov);
}
if (Input.GetKey(s)) {
transform.Translate(0, 0, -VelMov);
}
if (Input.GetKey(d)) {
transform.Translate(VelMov, 0, 0);
}
if (Input.GetKey(a)) {
transform.Translate(-VelMov, 0, 0);
}
if (Input.GetKey(l)) {
transform.Rotate(0, VelRot, 0);
}
if (Input.GetKey(j)) {
transform.Rotate(0, -VelRot, 0);
}
}
4º Passo: Utilização do mouse.
Agora vem a parte um pouco mais complicada, que é o movimento com o mouse. A primeira coisa que é necessário saber é que a movimentação realizada no eixo y será com o corpo, enquanto no eixo x será com a câmera. Ou seja: Quando você mexer o mouse para os lados, deve ser o corpo do objeto ou personagem que deve girar para os lados, mas se você mexer o mouse para cima ou para baixo deverá ser a câmera que deve realizar a rotação. Compreende? Então vamos aos passos. Primeiramente, devemos declarar uma variável que represente a câmera:
var CamRot : Camera;
Veja que essa é uma variável do tipo Camera. É necessário que esse seja o tipo da variável para que nós possamos identificar qual será a câmera que receberá a rotação. Depois disso, devemos declarar outra variável para definirmos qual será a velocidade de rotação do corpo do objeto ou do personagem:
var CamRot : Camera;
var VelCorpoRot : float;
E, por fim, devemos declarar uma variável para guardar a velocidade da rotação da câmera e outra variável para guardar a rotação atual da câmera:
var CamRot : Camera;
var VelCorpoRot : float;
var VelCamRot : float;
var CamRotAtual : float;
Depois de declaradas todas essas variáveis, devemos declarar quais serão as velocidades de rotação da câmera e do corpo:
VelCorpoRot = 45;
VelCamRot = 50;
Os valores colocados são apenas para exemplo. Você pode colocar os valores que desejar. Agora, abaixo dessas linhas, devemos declarar como será calculado o valor atual da rotação da câmera:
CamRotAtual = CamRot.transform.eulerAngles.x;
Repare que, dessa vez, foi utilizado o transform.eulerAngles. Essa função recebe a rotação atual da câmera, independentemente de qualquer coisa. Se você for até a aba Transform da câmera, no Unity 3D, você verá o valor do eixo x mudando. Esse valor é o que essa propriedade recebe. Ele não é afetado por nenhum outro valor. Então, depois de termos declarado tudo isso, devemos dizer como e quando essa rotação deverá ser realizada:
VelCorpoRot = Input.GetAxis(Mouse X)*VelCorpoRot*Time.deltaTime;
Veja que a velocidade de rotação do corpo recebe a função Input.GetAxis. Essa função pode ser usada para outros fins também, mas, nesse caso, estamos dizendo para ela mapear a movimentação do mouse no eixo x. Essa é uma função interessante, pois, além de pegar a posição do mouse, ela também capta a velocidade do movimento do mouse. Ou seja: Quanto mais rápido for o movimento realizado pelo mouse, essa função dará valores mais próximos de 1 ou de -1. Caso o mouse esteja parado, essa função retornará 0. Agora veja o que essa linha acima está dizendo:
VelCorpoRot recebe a velocidade de movimentação do mouse no eixo x juntamente com a posição do mouse no eixo x multiplicado pelo valor de VelCorpoRot e multiplicado por Time.deltaTime.
Lembre-se que o Time.deltaTime é utilizado para que a rotação seja realizada em graus por segundo. Lembre-se também que, nessa linha, o script está apenas calculando para, somente depois, aplicar o resultado dos cálculos ao corpo do personagem. Depois de declarar aquela linha, vamos declarar a da câmera:
VelCamRot = Input.GetAxis(Mouse Y)*VelCamRot*Time.deltaTime;
Pronto. Depois, logo abaixo dessas linhas, coloque a seguinte linha para o corpo:
transform.Rotate(0, VelCorpoRot, 0);
Agora, abaixo, veja o que essas linhas estão fazendo:
Faça com que a rotação do corpo no eixo y seja correspondente à movimentação do mouse no eixo x, de acordo com a velocidade de movimento do mouse no eixo x.
Faça com que a rotação da câmera no eixo x seja correspondente à movimentação do mouse do eixo y, de acordo com a velocidade de movimento do mouse no eixo y.
E agora, para finalizar, é preciso fazer alguns testes para que a câmera tenha um limite de rotação. Para isso, será necessário declarar:
if (CamRotAtual >= 200) {
CamRotAtual = CamRotAtual 360;
}
Essas linhas estão dizendo o seguinte:
Se (A rotação atual somente da câmera no eixo x for maior ou igual a 200) {
Então transforme esse valor em um valor negativo.
}
Essas linhas acima são necessárias para que não seja necessário trabalharmos com valores grandes e sim com os valores desejados. Tudo bem, mas porque o valor digitado ali é 200? Simples... Vejamos pela lógica do Unity 3D:
Se a câmera está apontada para frente, então esse valor é 0 ou 360. Quando a pessoa mexer o mouse para baixo os valores começam a aumentar, ou seja, são positivos. Mas quando a pessoa olhar para cima, os valores começam a diminuir, ou seja, continuam positivos! Pensou que eles seriam negativos, não é? Errado. Quando a pessoa olha para cima, os números começam do 360 e vão diminuindo. Por isso, devemos fazer esta conta para que os números se tornem negativos e não precisemos trabalhar com números grandes. Entendeu?
Agora, depois de escrever aquelas linhas, você deve declarar qual será o limite que a câmera poderá girar para baixo e para cima:
if (CamRotAtual<20 && CamRotAtual>-30) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
Repare que a variável utilizada aqui é aquela variável com o tipo Camera juntamente com o transform.Rotate. Esse modo de utilização só é possível, pois a variável do tipo Camera é como se fosse a própria câmera. Mas não se esqueça de declarar pelo Unity 3D qual será a câmera que receberá essas configurações da variável CamRot. Outra coisa que é necessário destacar aqui é que é exatamente nessas linhas acima que você decide qual vai ser o limite de rotação da câmera, tanto para baixo, quanto para cima. Nesse caso, o limite mínimo está como sendo 20 e o limite máximo está sendo -30. Essas linhas acima estão dizendo o seguinte:
Se (O valor da variável CamRotAtual for menor que 20 e maior que -30) {
Então permita que a câmera realize rotações no eixo x, de acordo com o valor da variável VelCamRot em seu modo negativo;
}
Repare que a variável VelCamRot deve realizar seu movimento em seu modo negativo para que o movimento da câmera seja correspondente ao do mouse. Caso contrário, a câmera fará o movimento contrário ao do mouse. Agora, logo abaixo dessas linhas, adicione uma exceção:
else {
if (CamRotAtual>20) {
if (-VelCamRot<0) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
}
if (CamRotAtual<-30) {
if (-VelCamRot>0) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
}
}
Acima dessa exceção está o que deve acontecer se aquelas condições forem cumpridas, mas se elas não forem cumpridas, essa exceção está dizendo o seguinte:
Ou então {
Se (A câmera tiver feito um movimento maior que 20) {
E se (o movimento do mouse for para baixo) {
Então permita que a câmera realize rotações no eixo x, de acordo com o valor da
variável VelCamRot em seu modo negativo;
}
}
E se (A câmera tiver feito um movimento menor que -30) {
E se (o movimento do mouse for para cima) {
Então permita que a câmera realize rotações no eixo x, de acordo com o valor da
variável VelCamRot em seu modo negativo;
}
}
}
A palavra else significa se não, mas aqui fica mais bem traduzida assim. E, depois disso tudo, seu script deve ficar assim:
#pragma strict
var VelMov : int;
var VelRot : int;
var CamRot : Camera;
var VelCorpoRot : float;
var VelCamRot : float;
var CamRotAtual : float;
function Start () {
}
function Update () {
CamRotAtual = CamRot.transform.eulerAngles.x;
VelMov = 10*Time.deltaTime;
VelRot = 22*Time.deltaTime;
VelCorpoRot = 45;
VelCamRot = 50;
VelCamRot = Input.GetAxis(Mouse Y)*VelCamRot*Time.deltaTime;
VelCamRot = Input.GetAxis(Mouse Y)*VelCamRot*Time.deltaTime;
if (CamRotAtual >= 200) {
CamRotAtual = CamRotAtual 360;
}
if (CamRotAtual<20 && CamRotAtual>-30) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
else {
if (CamRotAtual>20) {
if (-VelCamRot<0) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
}
if (CamRotAtual<-30) {
if (-VelCamRot>0) {
CamRot.transform.Rotate(-VelCamRot, 0, 0);
}
}
}
if (Input.GetKey(w)) {
transform.Translate(0, 0, VelMov);
}
if (Input.GetKey(s)) {
transform.Translate(0, 0, -VelMov);
}
if (Input.GetKey(d)) {
transform.Translate(VelMov, 0, 0);
}
if (Input.GetKey(a)) {
transform.Translate(-VelMov, 0, 0);
}
if (Input.GetKey(l)) {
transform.Rotate(0, VelRot, 0);
}
if (Input.GetKey(j)) {
transform.Rotate(0, -VelRot, 0);
}
}
Ok... Aí está um belo sistema de movimentação em um tutorial limpo e fácil de compreender. Tente ler esse tutorial e fazer os passos no Unity 3D ao mesmo tempo, pois, assim, ficará mais fácil para você entender e mais fácil para fazer o script. Então, boa sorte e obrigado por ter sido paciente ao seguir os passos. Os programadores mais experiêntes poderão também informar aqui algo que poderia ser feito para melhorar o script.
Até a próxima!