Transcrições
1. Introdução: Bem-vindo ao meu curso
introdutório sobre três D Game
Development e Gada. Neste curso,
abordaremos tudo o que você precisa saber sobre como usar
o motor Gudo para construir um controlador de
personagem em terceira pessoa desde o básico
de trabalhar em espaço
tridimensional
até controle de um personagem e uma
câmera em uma cena tridimensional Exploraremos como
usar matemática, física e vetores para alcançar
a
jogabilidade em terceira pessoa que você espera da
maioria dos jogos 3D modernos, com o controle esquerdo
movendo e girando o personagem e
o controle direito girando a câmera ao redor dele Quando terminar, você
terá uma boa compreensão do controle de
personagens em terceira pessoa e uma
implementação totalmente funcional que é altamente personalizável para
qualquer projeto tridimensional,
seja uma plataforma, ação
ou PG,
ou até mesmo um aconchegante simulador de fazenda Você pode levar o projeto
em qualquer direção que desejar. Você também aprenderá habilidades úteis para trabalhar no motor de
jogo Gada, organizando e projetando seus projetos para
serem mais escaláveis Você
aprenderá a codificar no script
GD com tudo
explicado em detalhes Nossos scripts serão escritos para
serem altamente personalizáveis
e reutilizáveis Todos os arquivos do projeto também
estarão disponíveis no GT Hub se você precisar
revisar o projeto concluído. Esses vídeos foram gravados
usando a versão 4.2 do Gada. Ativos baixados do
HO feitos por Kusberg.
2. 0-1 Introdução à programação: Olá amigos. você precisará baixar
o GDOGameEngine em gdongine.org Se
ainda não tiver feito isso,
você precisará baixar
o GDOGameEngine em gdongine.org
. O motor é gratuito, mas você pode doar para apoiar o
projeto, se quiser Não há processo
de instalação. Você pode simplesmente extrair o arquivo
compactado e abri-lo. Certifique-se de realocar o
executável para um local melhor. A janela de lançamento inicial é uma lista dos seus projetos atuais. Mas se você ainda não tiver
nenhum projeto, você será solicitado a
explorar projetos de demonstração Podemos ignorar isso
e simplesmente criar nosso próprio novo projeto
clicando nesse botão na lista de projetos ou no botão Criar
na parte superior da janela. Aqui podemos dar um nome ao
nosso projeto, que normalmente seria
o nome do seu jogo. Vou apenas introduzir
a programação. O projeto precisa ser armazenado no disco rígido do nosso computador e criaremos uma nova pasta com o mesmo nome
do projeto. Por padrão, ele deseja armazenar tudo
na pasta de documentos, mas seria melhor criar uma nova subpasta para projetos
Godot O renderizador altera a
forma como certos dois objetos D e três D
são renderizados, mas não vamos
desenhar nada, então podemos ignorar essas opções O renderizador também pode
ser alterado posteriormente. E a
compatibilidade do controle de versão com o Github está incluída por padrão se você quiser usá-la para fazer backup do seu projeto ou
compartilhá-lo com outras pessoas. Quando estiver pronto para começar,
clique em Criar e editar. A janela do GdoEditor
abrirá nosso projeto
vazio recém-criado O editor está
dividido em cinco docks principais. Uma prévia do nosso jogo
está no centro. O dock inferior esquerdo
contém um navegador de arquivos mostra o conteúdo da pasta
do projeto
que acabamos de criar. Atualmente, ele
contém apenas o ícone Gadot. O encaixe superior esquerdo
contém a árvore de cenas, uma lista de tudo o que
está em nossa cena atual, que está vazia no momento, então ele quer que criemos uma
raiz para a árvore de cenas. Não vamos desenhar nada, então não precisamos
especificar se essa cena tem dois D ou três D ou
uma interface de usuário. Então, podemos simplesmente
selecionar outro nó. Podemos criar muitos
nós diferentes, mas só estamos interessados em aprender
a escrever scripts, então usaremos apenas
um nó padrão. Podemos renomear nosso novo nó clicando nele
depois selecionado ou clicando com o
botão direito do mouse para abrir
o menu de contexto e
selecionando renomear Vamos chamar esse nó de Lição 1. Selecionar qualquer nó
na árvore da cena revelará suas propriedades
no inspetor, que está encaixado no lado
direito da janela Podemos ver o nome do
nó selecionado e suas propriedades organizadas
em categorias expansíveis, mas nenhuma dessas propriedades aplicável ao
que estamos fazendo Antes de fazermos qualquer outra coisa, devemos salvar nossa nova cena, selecionando
Salvar cena no menu da cena ou usando
o
atalho Control S ou Command S. Isso abre uma caixa de
diálogo onde
podemos especificar um nome para nossa
cena com o TSCNetension e uma pasta devemos salvar nossa nova cena,
selecionando
Salvar cena no menu da cena ou usando
o
atalho Control S ou Command
S. Isso abre uma caixa de
diálogo onde
podemos especificar um nome para nossa
cena com o TSCNetension e uma pasta de destino. Vamos criar uma nova
pasta para a Lição 1 e depois salvar a cena
nessa pasta. Agora podemos ver na guia do sistema de
arquivos que nossa nova pasta foi
criada para a Lição 1 e contém a cena da
Lição 1, marcada com
o ícone Clapperboard Em seguida, anexaremos um script ao nó raiz da nossa cena, selecionando o nó
raiz e clicando no do script anexado ou clicando com o botão direito nele e
selecionando o script anexado. A linguagem é GD Script, que é a linguagem de
programação que
vamos aprender Cada script herdará do tipo de nó
ao qual está
anexado por padrão Como o nó raiz é
um tipo de nó padrão, nosso script herda do nó Não estamos usando um modelo
nem um script incorporado, e podemos especificar onde esse script será armazenado
no projeto. Vamos colocar isso
na mesma pasta. Lição um. Ao nomear scripts, é importante
não ser arbitrário, mas descrever
o tipo de objeto ou comportamento que estamos criando
por meio do Então, vamos chamar isso de Olá. Os scripts têm a
extensão de arquivo dot gD. Em seguida, clique em Criar
para criar o script. Isso mudará nossa
visualização para visualização de script, exibindo nosso script de saudação
recém-criado. Também podemos ver nosso script na guia
do sistema de arquivos
indicada com um ícone de engrenagem, e o nó raiz da Lesson one tem o ícone do script para
nos mostrar que ele tem um
script anexado
que, quando passarmos o mouse sobre ele , nos
dirá o nome do Clicar nesse ícone também abrirá o script, caso ele ainda
não esteja aberto. Nosso script tem apenas uma linha, que descreve sua
herança do tipo de nó básico usando
a palavra-chave extends Isso significa apenas que nosso
script pode fazer tudo o um nó pode fazer, além de
tudo o que escrevemos aqui. Também nos permite
substituir os comportamentos
do nó que já existem por novos comportamentos próprios Por exemplo, os nós têm
uma função chamada ready, mas ela não faz nada. Então, se quisermos que nosso script
substitua esse comportamento
de não fazer nada, podemos declarar nossa
própria função o mesmo nome usando
a palavra-chave Funk é então seguido pelo nome
da função,
normalmente escrito em
minúsculas, o que significa todas as letras
minúsculas
separando palavras com sublinhados que significa todas as letras
minúsculas separando Muitas das funções definidas pelos nós são precedidas
por um sublinhado, e o nome deve
ser uma correspondência exata para substituir o comportamento O nome da função deve ser seguido por parênteses
e Examinaremos o porquê mais tarde. Pressionando Enter após essa linha, a próxima linha é automaticamente
recuada em um nível É assim que o GD Script
sabe quais linhas estão contidas na
função e onde ela termina A linha é destacada em vermelho porque as funções
não podem ficar vazias. Portanto, é uma boa ideia
escrever a palavra pass para dar às novas funções um
corpo que não faz nada. Agora que o erro desapareceu, podemos ver esse ícone de seta azul aparecer na frente da declaração da
função, que é o símbolo de substituição, indicando que
esse script agora está substituindo o
comportamento pronto do nosso Em vez de não fazer nada, queremos que nosso nó diga olá, o que podemos fazer com
uma declaração de impressão, substituindo a linha que dizia passar
anteriormente. A instrução print é semelhante a uma
declaração de função com um nome seguido por parênteses porque está chamando
uma função incorporada Essa função
requer um argumento, que é o que está
dentro dos parênteses E esse argumento é
o que será impresso. Usando aspas,
podemos escrever o que quisermos, e isso será impresso pelo nosso script quando
o nó estiver pronto Como o script se chama hello, o comportamento que queremos criar é que o nó diga hello. Com nosso script pronto, podemos executar nosso jogo usando o botão executar cena atual
no canto superior direito ou usando
o atalho F six Isso exibirá
uma janela vazia, já que nosso jogo não
desenha nada, mas também
abre o quinto dock, exibindo o painel de saída. E em nossa saída,
podemos ver que nosso nó
imprimiu as palavras hello
world quando estava pronto. Podemos finalizar essa simulação
fechando a janela, clicando no botão parar ou usando o atalho F oito Podemos alterar o texto
impresso para dizer o que quisermos e executá-lo novamente para ver se
nosso nó pode imprimir
tudo o que pedimos. Agora sabemos como anexar
scripts aos nós e executá-los. Na próxima lição, aprenderemos sobre constantes e variáveis Te vejo na próxima aula.
3. 0-2 Constantes e variáveis: Olá, amigos. Começaremos cada lição
criando primeiro uma nova pasta
para a lição. Em seguida, criando uma nova cena nessa pasta com o mesmo nome. Clique duas vezes em uma cena na guia
do sistema de arquivos para abri-la. Com várias cenas abertas, podemos alternar entre elas
clicando em suas guias
no documento de visualização Hoje, discutiremos
as diferenças entre constantes e variáveis usando dias como nosso quadro de referência Então, vamos anexar um novo script
ao nó raiz da
cena e nomear seus dias. Vamos começar com
constantes e declarar uma na parte superior do script
usando a palavra-chave const,
seguida pelo nome
da nossa nova constante, seguida pelo nome
da nossa nova constante, que é convencionalmente
escrita Uma constante é como um contêiner onde podemos armazenar informações, mas essas informações
nunca podem ser alteradas. Algo que
consideraríamos constante pode ser o
número de dias na semana. Como não pode ser alterado, ele deve receber um
valor imediatamente, é por isso que temos um erro. Devemos seguir o nome
com um sinal de igual, o operador de atribuição para
dar um valor à constante O número de dias
na semana é sete. É razoável supor
que sempre
serão sete e que seja o
mesmo para todos. Portanto, ele nunca deve
precisar alterar seu valor. Por outro lado, temos variáveis, que também são contêineres
para armazenar informações, mas
projetadas para serem alteradas Podemos declarar uma variável
da mesma forma usando
a palavra-chave VR e, em seguida, atribuindo a ela um nome convencionalmente escrito
em minúsculas Isso facilita a
visualização da diferença entre constantes e
variáveis em nossos scripts Algo que
muda com frequência pode ser o valor de hoje. Ao contrário das constantes,
as variáveis podem estar vazias. Vamos substituir a função
ready do nosso nó base e imprimir os valores
do número de dias
da semana e de hoje Podemos ver que o número de
dias na semana é sete, mas o valor de hoje
é impresso como nulo, o que significa vazio ou nenhum valor Vamos corrigir isso inicializando
hoje como quinta-feira. E podemos tornar nossa saída mais legível adicionando algum contexto, começando com algo
como hoje, deixando
um espaço depois de um
sinal de adição e, em seguida, nossa variável Nesse caso, o sinal de
mais está sendo usado para acrescentar duas partes
da frase se tentarmos fazer a mesma coisa No entanto, se tentarmos fazer a mesma coisa
com nossa constante, isso causará um erro porque nossa constante é um
número, não uma palavra. Quando declaramos nossa constante, atribuímos a ela um valor de sete, que é um número sem
nenhum ponto decimal, que em matemática é
chamado de inteiro Portanto, nossa constante tem
um tipo de número inteiro. Hoje, por outro lado, foi atribuído um valor de alguns caracteres
entre aspas Em programação,
chamamos isso de string. Portanto, nossa variável tem
um tipo de string. O operador plus só
pode ser usado quando os tipos de ambos os
operandos são compatíveis Podemos contornar isso
usando uma função embutida para alterar o tipo que está
sendo usado aqui para uma string, passando a constante como
argumento para a função. Isso não mudará o tipo
da constante original, apenas como ela está sendo usada aqui no contexto da operação de
acréscimo. E também podemos continuar adicionando mais contexto com outra string
anexada, lembrando de adicionar um espaço
extra na frente Então, agora podemos
imprimir nossa constante e variável usando-as em frases
fáceis de entender. Depois dessas linhas, vamos
fingir que um dia passa. Podemos adicionar contexto extra aos nossos scripts que
nunca serão vistos pelos jogadores, mas que existem apenas para nos ajudar, como desenvolvedores, a entender
nosso próprio código ou código escrito por outras pessoas. Eles são chamados de
comentários e são criados usando o sinal ou hashtag OctathorpPound Qualquer texto escrito após esse
símbolo será colorido em cinza e não afetará de forma alguma
a forma como o script é executado. Eles podem estar em suas próprias linhas ou no final de uma linha de código. Então, vamos usar um comentário para explicar que estamos
fingindo que passou
um dia
entre o código acima dessa linha e
o código abaixo Mudaremos o
valor de hoje para sexta-feira e imprimiremos
outra frase. Hoje é mais Hoje, que agora tem um valor
diferente. Podemos ver que o valor de
hoje foi impresso primeiro como quinta-feira e depois alterado e impresso como
sexta-feira na próxima linha. O comentário não teve efeito
na execução do script. Se tentarmos alterar o valor
da nossa constante, obviamente, isso causará um erro porque as
constantes não
podem ser alteradas Se não quisermos mais
usar algumas linhas de
código em nosso script, podemos
alterá-las facilmente para comentários
destacando-as e pressionando
Control K ou Command K, adicionando o símbolo de comentário
na frente de cada linha
destacada Pressionar novamente
removerá os comentários. Podemos especificar o
tipo de variável ou constante adicionando
dois pontos após o nome Seguido pelo nome do tipo, também
queremos restringir essa
constante ou variável. Vamos restringir nossa
constante para ser do tipo int e hoje
do tipo string. Além de strings e números inteiros, existem dois outros tipos
primitivos que podemos usar para armazenar Se um número tiver pontos decimais, ele não será mais um número inteiro e em vez disso, um tipo diferente chamado
número de ponto flutuante, que usa o nome de tipo Vamos adicionar outra variável
para a data de hoje e atribuir a ela um tipo de
número de ponto flutuante com um valor de 12,05, que é a
data de hoje, 5 de dezembro E o último tipo é chamado Boolean usando o nome
abreviado Boole, que pode
ser verdadeiro ou Então, adicionaremos outra
variável para determinar se
hoje é feriado ou não. Vou restringir isso
para ser um booleano, mas não vou dar a ele
um valor inicial Vamos adicionar mais duas
instruções de impressão para imprimir os valores dessas
variáveis com contexto. A data de hoje é mais uma data e hoje é feriado. Colon plus é feriado. Quando executamos isso agora, podemos
ver nossa data impressa,
mas se um feriado diz falso, apesar de não lhe dar um valor. Isso ocorre porque todos os
tipos primitivos têm um valor padrão, mas o
valor padrão só pode ser atribuído se especificarmos
o tipo de variável Como especificamos que
um feriado é um booleano, ele foi atribuído
ao valor
padrão um booleano, que é falso O valor padrão
para um número inteiro e um
número de ponto flutuante são zero, e o valor padrão para uma string é apenas
uma string vazia, que não é o mesmo que null, mas é uma string
sem caracteres Se não especificarmos o
tipo de uma variável, seu valor padrão será nulo, mas ela poderá receber
um valor de qualquer tipo, e seu tipo poderá
mudar a qualquer momento Vamos remover o tipo da data. Em seguida, atribua um novo valor de 13
de dezembro e
imprima-o pela segunda vez. A variável começa recebendo um valor de um número de ponto
flutuante, é usada pela instrução
print e, em
seguida, recebe um valor de string antes de ser impressa novamente. Isso é permitido
porque o GD Script é uma linguagem de digitação livre Isso oferece maior flexibilidade
ao escrever nossos scripts, mas também maior
responsabilidade de evitar erros
de compatibilidade de tipos, como vimos com o operador plus. É recomendável que você sempre forneça um tipo às
variáveis, não apenas para evitar erros, mas também para melhorar a eficiência da execução de
seus scripts. Se o mecanismo souber o
tipo de suas variáveis
, ele também saberá exatamente quanta memória
precisa ocupar. Isso também se aplica ao uso constantes no lugar de variáveis Se o motor souber que o
valor não pode mudar, ele
poderá ser usado com
mais eficiência. Na próxima lição,
aprenderemos sobre como controlar o
fluxo de nossos scripts. Te vejo na próxima aula.
4. 0-3 Declarações e condições de If: Olá, amigos. Eu
já criei uma nova cena em uma
nova pasta para esta lição. Hoje, aprenderemos como
controlar o fluxo de nossos scripts para executar
diferentes linhas de código, fazendo escolhas sobre
se podemos ou não ver. Então, vamos anexar um novo script
ao nó raiz da nossa
cena e chamá-lo de visão. Começaremos nosso
script substituindo a definição dos nós básicos
da função pronta O método mais básico
de controlar o fluxo de nossos scripts
é a instrução I, que começa com
a palavra-chave I. I é seguida por uma declaração
condicional que deve
ser verdadeira ou falsa Por enquanto, vamos colocar verdadeiro, que é
seguido por dois pontos Semelhante aos dois pontos
no final de nossa declaração de
função, isso marca o final
da declaração
e, continuando até a próxima linha, ela é automaticamente
recuada em outro nível Qualquer linha de código após
essa instrução if, que esteja indentada, só
será executada se a condição da instrução
if for verdadeira Então, vamos imprimir algo
como se a condição fosse verdadeira e, em seguida, executar a cena atual para ver nossa declaração
impressa funcionando. Se alterarmos verdadeiro para falso, podemos ver que a declaração de impressão é
ignorada dessa vez Podemos adicionar outra
linha após o corpo recuado das declarações
if
no mesmo nível de recuo instrução I simplesmente com
a palavra-chave se
seguida por dois pontos Isso cria outro
corpo condicional que será executado somente se a condição
da instrução I original não for atendida Vamos duplicar a declaração
impressa e alterá-la para dizer
algo diferente Como a condição era falsa, o bloco se foi executado
em vez do bloco I. E se mudarmos a condição para verdadeira, o inverso
acontecerá. Isso não é muito útil
se sempre soubermos que o resultado da
declaração condicional é verdadeiro ou falso, mas podemos
substituí-lo por uma variável Vamos declarar uma variável
booleana, que é se a
luz está acesa ou não na sala Os booleanos são
convencionalmente nomeados tal forma que implicam
seu uso Nesse caso, a luz acesa está implícita como verdadeira ou falsa
com base na forma como é nomeada Agora, nossa declaração if pode definir
sua condição para ser se o valor de nossa
variável é igual
ou não a verdadeiro. Ao comparar dois valores
para ver se eles são iguais, usamos um sinal de igual duplo, conhecido como operador de igual, que é diferente de
um único sinal de igual, como usamos anteriormente como operador de
atribuição. Em seguida, imprimiremos se consigo ver ou não consigo ver, como resultado de a luz estar acesa ou não
ser igual à verdadeira. Como o valor padrão
de um booleano é falso, podemos ver a saída
como eu não consigo ver Mas se definirmos a
variável como verdadeira, ela muda para Eu posso ver. Como a variável em si é um booleano, verdadeiro ou falso, podemos remover completamente a
operação de comparação e apenas usar o booleano como condição e obter exatamente
o Podemos reverter o
valor de qualquer booleano, ou
seja, se for verdadeiro, ele se torna falso
ou, se for falso, ele se tornará verdadeiro
usando a palavra-chave not Assim como a função STR que
usamos na lição anterior, isso só muda a forma como
ela está sendo usada
no contexto local e,
na verdade, não altera o valor
armazenado na variável Então, se não, a luz está acesa, então não podemos ver,
e então podemos ver. Nada também pode ser representado
por um ponto de exclamação. Vamos alterar o valor das
luzes acesas e executá-las novamente. Em seguida, reverterei essas mudanças para o que eram antes Podemos tornar nossas condições
muito mais complexas
combinando várias condições usando operadores lógicos. Vamos criar outra variável
chamada Has dark vision. Essa variável implica
que devemos ser capazes ver mesmo que a
luz não esteja acesa. Portanto, podemos adicionar às nossas
declarações if a condição que a luz esteja acesa
ou que tenhamos uma visão escura. E se alguma
dessas condições for verdadeira, então podemos ver. Somente se ambas
as condições forem falsas, isso
resultará na
impossibilidade de enxergarmos? E se, em vez
de ter visão escura, usássemos óculos de
visão noturna, pois eles só nos permitem
ver no escuro, mas
não na luz Alterando o nome da variável, a condição da nossa
declaração I precisa mudar. Uma vez que, se ambas
as condições forem verdadeiras, não deveríamos
ser capazes de ver. Somente se os valores dessas
duas condições forem diferentes, devemos considerar a
condição a ser atendida? Podemos usar o operador não
é igual para verificar se os dois valores não
são iguais entre si Se você estiver familiarizado
com operações lógicas, isso é conhecido em outras
linguagens como exclusivo ou. Agora, somente se a luz
estiver acesa ou se estivermos usando óculos de visão
noturna e não ambos,
poderemos ver Em seguida, vamos considerar que nossa
pessoa hipotética pode não ser humana e adicionar uma variável para o número de
Is que ela tem,
que deve ser
representada como um Por enquanto, daremos a
ele um valor de dois Is. Ignorando as outras variáveis, qual seria a
condição que
definimos para poder ver
com base nessa variável Se o número de olhos
que temos for
maior que zero, então devemos ser capazes de ver. Também podemos expressar isso
usando outro operador, maior ou igual a, e mudar o
lado direito para um. Portanto, eles devem ter olhos
maiores ou iguais a um. Esses são
operadores de comparação que retornarão um resultado booleano comparando o valor dos números nos
lados esquerdo e direito Podemos concluir logicamente que deveria ser impossível para qualquer criatura humana
ou não ter um número
negativo de olhos O valor da nossa
variável deve
ser apenas zero ou algo
maior que zero. E a condição
para poder ver realmente se resume a
essas duas opções Temos olhos zero
ou olhos diferentes de zero? Assim como a variável booleana pode ser usada implicitamente
como uma condição, um inteiro também pode ser usado dessa
forma, com zero sendo considerado uma condição falsa e qualquer coisa diferente de zero
sendo A mesma lógica também é aplicada
aos números de ponto flutuante. Podemos declarar uma variável flutuante, vamos chamá-la de alcance
de visão e atribuir ela um
valor arbitrário de Podemos usar nossos
operadores de comparação para determinar se esse número é maior que menor ou igual
a um determinado valor, ou podemos usá-lo implicitamente
em sua própria condição com zero sendo considerado falso e qualquer outra coisa
sendo considerada verdadeira E quanto às cordas? Vamos mudar um pouco
as coisas e declarar uma variável de string para o que
ouvimos e atribuir a ela o valor
de solavancos durante a noite Então, podemos logicamente usar
isso como uma declaração if como se o que eu ouvi
não fosse uma string vazia, então podemos dizer, eu
ouvi alguma coisa Caso contrário, não ouvi nada. E, assim como os
outros tipos de variáveis, podemos descartar a
comparação e usar a própria variável
como condição. Com todas as variáveis, seus valores padrão são
considerados falsos, e qualquer outra coisa é sempre considerada verdadeira
quando usada como condição. Se declararmos uma variável
sem um tipo, vamos chamá-la do que
estou vendo, mas não atribuirmos um valor a ela, então já sabemos que seu valor
padrão será nulo Mesmo sem um tipo ou valor, qualquer variável pode ser usada
como condição de bullying Qualquer variável vazia,
o que significa que seu valor é nulo,
é considerada falsa Se preenchêssemos essa
variável com um objeto
, seu valor como condição
seria considerado verdadeiro No momento, não temos
outros objetos com os quais brincar, mas sempre podemos nos usar. Então, vamos definir o
valor do que eu estou vendo como
a palavra-chave self. E isso resulta em
ser capaz de ver. Na próxima lição, usaremos loops para repetir linhas
de código várias vezes. Te vejo na próxima aula.
5. 0-4 Loops e operadores: Olá, amigos. Hoje, aprenderemos a repetir
linhas de código várias vezes com loops,
imaginando uma senhora que se apaixonou
pela primeira vez segurando uma flor Então, vamos escrever um novo
roteiro e chamá-lo de flor. Em seguida, substitua a definição
dos nós básicos da função pronta Nossa senhora imaginada está segurando uma flor com
várias pétalas, que armazenaremos
em uma variável e restringiremos seu
tipo a um Em seguida, atribua um valor de algum número arbitrário,
digamos cinco Também declararemos outra
variável chamada He Loves Me, como booleana, na qual
acreditamos ter seu valor
padrão de false Podemos começar nosso
roteiro imprimindo uma história sobre a
mulher apaixonada segurando sua Ela remove cada
pétala da flor, uma por uma, afirmando que ele
me ama ou não me ama Primeiro, precisamos reduzir o número de pétalas
na flor em uma Então, começaremos com a variável
número de pétalas e, em
seguida, usaremos o operador de atribuição para atribuir um novo
valor à variável O valor que queremos
atribuir é o número que ele já
tem menos um Em seguida, queremos alterar o
valor da variável de booling. Ele adora que eu seja o oposto. Então, ele me ama, não dá
para nada. Ele me ama, invertendo o valor da
falsa verdade ou vice-versa Em seguida, podemos imprimir
os resultados. Ele me ama. Talvez queiramos encapsular
essa parte entre aspas, mas se tentarmos colocar uma aspa dentro de nossa string,
ela
marcará o final da Alguns caracteres especiais,
como aspas, podem ser criados dentro de uma
string usando uma barra invertida Se escrevermos
aspas de barra invertida, isso agora representa um caractere de
aspa, não o final da string E podemos incluir outro
após a declaração das senhoras. Vamos duplicar essa
linha e mudar a declaração para
dizer: Ele não me ama Outro exemplo de caractere
especial que podemos escrever usando a barra invertida
é a própria barra invertida Também podemos combinar
as duas linhas acima e
separá-las com a barra invertida N, que representa uma nova Portanto, eles são impressos
em duas linhas de saída a partir de uma única declaração de impressão. Agora temos duas possibilidades
que queremos
imprimir com base no valor
da nossa variável booleana Portanto, parece que devemos envolvê-los em uma declaração if. Se ele me ama, então imprima isso. Se ele não me ama,
então imprima isso. Mas nos casos em que
as declarações
dependem de uma única variável booleana
para fazer uma pequena alteração, existe um método mais eficiente Então, vamos voltar
ao formato original. Nossa declaração
será que ele me ama, se ele me ama, contrário, ele não me ama. Isso não é o mesmo que uma instrução if, apesar de
usar as mesmas palavras-chave, mas é chamado de operação
ternária Como ele não cria um novo bloco de código
com um recuo, ele é executado com
mais eficiência e é recomendado para ser usado em casos simples
como este Na verdade, podemos
reduzir ainda mais
o tamanho da variação
alterando-a apenas para um ponto de
exclamação
ou um espaço seguido
pela palavra não e
depois pelo ponto de exclamação Isso funciona no
caso de ele me amar, mas se alterarmos o
valor para verdadeiro por padrão
, só veremos o que não acontece
no outro caso. Assim como na matemática, há uma ordem específica de operações na qual nossos scripts
executarão várias operações
na mesma linha. Como tanto a string append quanto o ternário I são
operadores, um deve ser executado
antes do outro
e, nesse caso, será o string append E, assim como na matemática, os colchetes são sempre os
primeiros a serem executados Assim, podemos colocar qualquer
operação entre colchetes para garantir que ela seja executada primeiro na ordem
das operações Colocando nossa
declaração ternária entre colchetes, ela agora será executada antes
da sequência ser anexada
e nos dará o resultado e Agora temos nosso bloco
de código que precisa ser repetido enquanto a
flor ainda tiver pétalas. Usando a palavra-chave WW, assim como uma instrução if, podemos repetir um bloco de
código
indentado , desde que a
condição permaneça verdadeira A condição
neste caso é que o número de
pétalas na flor não seja zero Qualquer que seja o número de
pétalas na flor, ele será
reduzido em uma a cada vez Depois da instrução de impressão, o fluxo lógico desse
script retornará ao início
do WWLoop
para verificar a condição novamente. Quando o número de
pétalas chega a zero, a condição não é mais
atendida e o loop é interrompido, continuando com o restante do script, se houver Então, vamos escrever uma
breve conclusão para nossa história com
base nos resultados. Ela se levanta com
lágrimas nos olhos. Mas com base no
valor final de Ele me ama, ela está feliz ou triste, e imprimiremos a frase final
diferente. Executando essa cena, podemos ver nossa história impressa
no painel de saída
e, com cinco pétalas,
a senhora está feliz Se mudarmos o número
de pétalas para seis, obteremos um resultado
diferente, pois o loop se repetiu seis
vezes em vez de cinco Mas o que acontece se mudarmos o número de
pétalas da flor para zero O ciclo não funciona de jeito e o amor estava condenado
desde o Não recomendo
seguir este exemplo, mas observe o que
acontece se dermos
à flor um
número negativo de pétalas. Embora isso seja
realisticamente impossível, em nosso código, é
muito Como a condição de nosso laço de
parede nunca será atendido, ele nunca se quebrará e o script ficará preso
dentro dele, nunca terminando Esse é um loop infinito e deve ser evitado a todo custo. Nesse caso, podemos evitar o loop infinito alterando nossa condição para ser se o número de pétalas
for maior que zero, pois um número negativo ainda
quebrará o loop Podemos usar outro operador ao reduzir o número de
pétalas como atalho Eliminando a necessidade de escrever o nome de nossa variável duas vezes, podemos realizar operações
matemáticas simples em nosso número de variáveis usando um operador de
atribuição especial Nesse caso, o operador menos
igual a um pode alterar essa linha de código para
número de pétalas
menos igual a número de pétalas Esses atalhos existem para todas as
operações aritméticas básicas mais multiplicar
é igual
ou dividir é igual
e podem ser usados com qualquer número ou variável como e podem ser todas as
operações aritméticas básicas mais iguais, multiplicar
é igual
ou dividir é igual
e podem ser usados com qualquer número ou variável como o outro operando. Também
existe mais um operador para
aritmética básica,
o operador de módulo, representado
pelo Modulus executa uma operação de
divisão, mas não retorna
o quociente como resultado, como faz
o operador de
divisão Em vez disso, ele retorna o
restante da divisão. Todo esse roteiro,
além da história que está sendo contada, está apenas determinando
se o número de pétalas na flor é
um número par ou ímpar, mas está fazendo isso da maneira mais
ineficiente possível, contando cada Então, vamos comentar todo
o loop da parede e, em vez disso, usar o módulo
para acelerar o processo Sabendo que todos os números pares
são divisíveis por dois, podemos usar o módulo número de
pétalas O único resultado possível como restante dessa
divisão será
zero se o número de pétalas for
par ou um se o número de pétalas for ímpar Nosso script pode ser
simplificado para que, se o número de pétalas do módulo
dois for igual a um, a dama Caso contrário, ela está triste. Como entendemos como números inteiros são interpretados
como condições, nem
precisamos realizar
a operação de comparação aqui e podemos simplesmente encurtá-la para I, número de
pétalas O resultado da operação do
módulo pode ser atribuído diretamente à variável booleana para obter o mesmo resultado sem a
necessidade de uma instrução if, e o zero ou um será automaticamente convertido em
falso ou verdadeiro de acordo Poderíamos ir mais longe removendo a variável e usando apenas a operação de módulo diretamente dentro da instrução turny Na próxima lição,
aprenderemos sobre coleções de variáveis
relacionadas. Te vejo na próxima aula.
6. Matrizes de 0 a 5 e para loops: Olá, amigos. Hoje, consideraremos como podemos organizar
grandes quantidades de variáveis, especialmente quando elas contêm informações
relacionadas. Eu já criei um script chamado censo e substituí definição de nós básicos
da função pronta Para nosso
cenário hipotético nesta lição, estamos imaginando um
funcionário do censo que precisa registrar quantas pessoas moram em
cada casa em uma única
estrada em Podemos declarar uma única variável para conter todas essas informações, vamos chamá-la de Main Street E o tipo dessa
variável será uma matriz. Uma matriz pode conter uma lista de variáveis de qualquer um
dos outros tipos. Nesse caso, o tipo de variável que
procuramos são números inteiros, representando o número de
pessoas que moram em cada casa Podemos especificar o
tipo de conteúdo de uma matriz usando
colchetes após a matriz do nome do tipo e colocando o tipo do conteúdo
dentro dos colchetes Agora, essa matriz só pode conter
números inteiros como seu conteúdo. Antes de podermos acessar o
conteúdo de uma matriz, ela precisa ter um tamanho, o número de variáveis
contidas nela. Ao contrário de outras
variáveis, as matrizes são mais complexas e têm
suas próprias funções Podemos acessar essas funções
seguindo o nome da
variável com um ponto e, em
seguida, o nome da função. Nesse caso, a função de
redimensionamento, que define o número de
endereços dentro dessa matriz, representando o número
de casas na Main Street, que diremos que é seis Nossa cidade imaginária é
um pouco incomum, pois os números das casas na
Main Street começam em zero Então, nosso funcionário do censo
começa na casa, no zero da Main Street, e
bate na porta para perguntar ao morador
da casa quantas pessoas
moram na Podemos armazenar um valor em uma
matriz começando com seu nome e, em
seguida, usando
colchetes para marcar o endereço do inteiro
específico, nesse caso, endereço zero e,
em
seguida, usando o operador de
atribuição Podemos atribuir um número inteiro
a esse endereço. Então, digamos que a
casa número zero na Main Street tenha cinco
pessoas morando nela. Passando para a próxima casa no endereço número um da
Main Street, alguém atende a batida
na porta e diz ao funcionário do censo que
há duas pessoas morando
naquela Na próxima casa,
endereço número dois, a casa está em construção
e tem uma placa de venda, que significa que esta casa
está claramente desocupada, e nosso funcionário do censo registra o número de
residentes como zero No número três da rua principal, ninguém abre a porta, apesar do fato de
haver um carro
na garagem e
sinais de ocupação O que podemos considerar o funcionário do censo deve registrar como o número
de residentes Podemos pensar que
pode ser zero. Mas como
diferenciaríamos entre um número desconhecido de ocupantes
e uma casa desocupada Se considerarmos que o
número de ocupantes de uma casa nunca deve ser
considerado um número negativo, poderíamos usar o número
menos um para significar que o número de ocupantes da
casa é um valor desconhecido E no número quatro da Main Street, novamente, não há
resposta na porta. Mas a casa também
parece estar abandonada
e, provavelmente, ninguém mora
lá há algum Podemos assumir que o
número de ocupantes é zero talvez usar o mesmo valor de menos um para
um número desconhecido de ocupantes ou criar mais códigos de valor
negativos para situações
diferentes,
como usar menos dois para significar provavelmente
desocupado, mas O endereço número cinco na Main Street
nem tem uma casa, mas é apenas um terreno baldio Então, novamente, isso pode ser
representado com um zero ou outro valor negativo para
codificar algum tipo de reunião Vamos imprimir os resultados
do censo e ver como eles
se parecem Podemos ver nossa matriz
representada como uma lista separada por vírgulas de números encapsulados Isso representa um
trabalho decente
ao representar o número de pessoas que moram
em cada casa na Main Street. Mas e se quiséssemos usar esses dados para obter
um número total de ocupantes de todas as casas
na Main Street ou em média Se calculássemos a soma
de todos esses números,
os números desconhecidos
representados como negativos
distorceriam os resultados Um dos melhores benefícios
de usar matrizes para armazenar informações
relacionadas dessa forma é a facilidade de
percorrê-las Usando a palavra-chave quatro, escrevemos em seguida o nome
de uma nova variável, que representará cada elemento individual
dentro da matriz, seguida pela palavra-chave in e, em
seguida, pelo nome da matriz. Assim como as funções, se as
instruções forem loops wa, isso será seguido por dois pontos e
um bloco de código recuado
que será repetido Essas linhas de código
serão repetidas uma vez para cada uma de nossas seis
casas na Main Street, e podemos nomear a
variável house, pois ela será usada para acessar cada casa individual
dentro do loop. Digamos que primeiro queremos encontrar o número médio de ocupantes que moram em uma casa ocupada Isso significaria somar
todos os números positivos e depois dividir pelo
número de casas ocupadas Então, precisaremos de três
novas variáveis, uma para o
número total de ocupantes, outra para o número
de casas ocupadas, ambas como números inteiros, e um número de ponto flutuante
para a média Para cada casa na Main Street, podemos verificar se a
casa está ocupada, se
o número armazenado na matriz desse endereço agora armazenado na variável casa é algo maior que zero. Se isso for verdade,
o número total de ocupantes em casas ocupadas
pode ser aumentado por casa e o número de
casas ocupadas incrementado Depois que todas as seis casas na Main
Street foram verificadas, o circuito é interrompido e temos
nossos dois números inteiros Assim, podemos calcular a
média dividindo o número total de ocupantes pelo número de casas
ocupadas Em seguida, imprima os resultados. Há mais casas ocupadas,
mais casas ocupadas
na Main Street, com uma média de mais
ocupantes médios mais ocupantes Mas se executarmos esse código, a média é representada
como um número inteiro, três, que sabemos que não
está correto Como há um total de sete ocupantes em
duas casas ocupadas, a média deve ser 3,5 Isso aconteceu
porque realizamos uma operação de divisão
com dois números inteiros, e o resultado da operação também
será um número inteiro, mesmo que o estejamos atribuindo a uma variável de número de ponto
flutuante Godot também fornece um aviso contra o uso de números inteiros
em operações de divisão Para resolver isso, podemos alterar nossas variáveis inteiras para números de ponto
flutuante
em suas declarações ou podemos alterar seu tipo localmente antes de
realizar a divisão Da mesma forma que transformamos números inteiros em strings
antes de anexá-los, podemos transformar um inteiro em um número de ponto flutuante
antes de realizar
uma Alterando também o resultado
da divisão para um
número de ponto flutuante. Alterar o tipo de uma variável dessa
maneira é chamado de conversão. Estamos convertendo um
número inteiro em um flutuador. Agora podemos ver os resultados que esperávamos com uma média de 3,5 ocupantes
por casa ocupada Uma vantagem do GD Script, por ser uma
linguagem de tipos vagos, é que
não precisamos especificar os
tipos de nossas variáveis, incluindo os tipos
contidos em Se permitirmos que nossa matriz
contenha qualquer tipo de variável, podemos alterar a forma como nosso
funcionário do censo registra as informações Vamos supor que o endereço zero permaneça o mesmo
com cinco ocupantes Mas o endereço um também forneceu os nomes dos dois
residentes que moram lá. Em vez de registrar os
ocupantes como número dois, poderíamos gravar seus
nomes em uma string Portanto, o
endereço número um da Main Street é ocupado por Jordan
e Ashley Smith A casa número dois estava desocupada, o que poderíamos
representar como zero Mas também podemos considerar registrá-la como um
booleano
e atribuir a ela um valor falso
para significar que a casa está em construção e não
pode ter ocupantes No número três,
ninguém estava em casa, mas definitivamente há
pessoas morando lá. Nós simplesmente não sabemos quantos. Também podemos armazenar
esse valor como um booleano e atribuir a ele
um valor verdadeiro No número quatro, realmente
parece que ninguém mora lá. Talvez queiramos
marcá-lo como zero ocupantes. No endereço número cinco, como não há nem
mesmo uma casa lá, podemos realmente
considerar o uso de nulo como valor, já que nulo representa
a ausência de qualquer Podemos usar a palavra-chave null para atribuir isso à
matriz no endereço cinco Agora, nossa matriz impressa
parece bem diferente, contendo variáveis
de todos os tipos diferentes em vez de apenas números inteiros E podemos discernir mais
informações a partir disso. As matrizes podem até conter outras
matrizes como seu conteúdo. Então, vamos mudar nossa
lista de nomes de uma única string para
uma matriz de strings. Podemos criar essa
matriz ao mesmo tempo em que ela está sendo atribuída
usando colchetes e, em
seguida, preenchendo-a com uma lista de
strings separada por vírgulas Então, se quiséssemos saber quantas pessoas estão morando no
endereço um na Main Street, poderíamos imprimir isso como
Mainstreet one dot Na próxima lição,
aprenderemos mais usos de matrizes para criar coleções de dados mais
dinâmicas Te vejo na próxima aula.
7. 0-6 Pilhas e funções: Olá, amigos. Hoje,
continuaremos trabalhando com matrizes de maneiras diferentes configurando um
jogo antigo Eu já criei um script chamado Old Made e substituí a definição de nós básicos
da função ready Para jogar antiquado, precisamos de um baralho de cartas, que é uma coleção de variáveis que podemos
manter dentro de uma matriz. Como o jogo
Old Made
realmente não se importa com os
naipes das cartas, podemos ignorar essa informação, e cada elemento da
matriz só precisa conter as cartas classificadas do ás
ao rei como um número inteiro Para gerar nosso deck,
podemos usar quatro loops. Mas, em vez de
usar o loop de quatro para percorrer uma matriz, ele pode ser usado apenas para contar a classificação
de nossas cartas Começando com quatro,
podemos declarar uma variável para representar a classificação de
uma carta, seguida pela palavra-chave in e, em
seguida, especificar um número Se considerássemos
King um número, seria o 13º posto Por enquanto, vamos apenas imprimir a classificação para que possamos ver o que acontece. O quatro loop começa com um valor de classificação em zero
e conta até 12, repetindo esse loop e
imprimindo a declaração 13 vezes Por uma questão de sanidade, pode ser uma boa
ideia considerar que a carta número dois seja
representada pelo nível dois
e, portanto, Ás seria um e rei seria 13 Embora iniciar um loop de quatro em
zero seja realmente útil para iterar por meio de matrizes, já que primeiro
número de índice é zero, não é muito útil
nesse caso Podemos mudar a forma como
um loop de quatro é contabilizado substituindo o 13 por uma chamada de
função, range. As chamadas de função são seguidas por parênteses contendo argumentos. Os argumentos para
essa função são os
limites inferior e superior do intervalo. O limite inferior será
incluído no intervalo, mas o limite superior não
será incluído. intervalo 114 conterá
todos os números de 1 a 13, podemos ver que
estão impressos na saída Outra forma de
adicionar informações a uma matriz em vez de usar os colchetes e número do
índice é usar uma
função chamada append Essa função de acréscimo aceita um argumento do valor que
está sendo adicionado à matriz Isso posicionará o
valor que está sendo adicionado
ao final da matriz,
onde quer que esteja. E como há quatro de
cada valor em um baralho de cartas, um para cada naipe, devemos repetir essa linha de código
quatro vezes para cada valor. Podemos fazer isso com
mais quatro voltas, desta vez começando em
zero e contando até, mas sem incluir quatro. Imprimindo o baralho, podemos
ver que nossa matriz tem quatro de cada número de 1 a 13, totalizando 52 cartas Mas para jogar antiquado, queremos remover
três das rainhas, ou neste caso, 12 Então, em nossos quatro ciclos que percorrem
os naipes das cartas, vamos verificar se a classificação é 12 E nesse caso específico, queremos permitir que apenas
112 seja adicionado, usando a palavra-chave break para
sair instantaneamente desse loop. quebra encerrará apenas o loop mais recuado em
que se encontra atualmente Então, terminaremos o
naipe por loop, mas não o rank por loop. Isso aumentará
a classificação para 13 e prosseguirá com a adição de
quatro treze ao baralho E testando isso, podemos
ver que há apenas 112. A primeira coisa que acontece em nosso jogo é embaralhar
o baralho de cartas, que no script GD é uma simples de rayse Só precisamos chamar
essa função e
podemos ver que as cartas
são embaralhadas em nosso baralho Também precisaremos de
outra variável, uma série de mãos de cartas
para representar nossos jogadores. Cada mão dentro da matriz de mãos precisa conter várias cartas, então elas também são matrizes, que precisaremos inicializar
antes de podermos usá-las Portanto, contando de zero
a quatro, mas não incluindo quatro, podemos acrescentar uma nova
mão à matriz Nossa mão começa como uma matriz vazia representada
por colchetes. Se imaginarmos nosso baralho de cartas, a frente das cartas sendo o lado com o anel e o naipe, o verso da
carta em branco, então também podemos imaginar
o baralho virado para baixo A frente da matriz é
a parte inferior da plataforma e a parte de trás da matriz
é a parte superior da plataforma. O processo de
distribuição das cartas pode ser feito
iterando nosso baralho, mas na verdade não precisamos
referenciar cartas específicas,
pois na verdade não importa
o que sejam, apenas que a carta seja retirada do topo
do baralho e
entregue a um jogador Então, para remover uma carta
do topo do baralho, podemos chamar outra função. Esse é chamado de pop back. Ele não apenas retorna o
último elemento na matriz, mas também o
remove da matriz. Em seguida, queremos adicionar essa carta à mão
do jogador e
começaremos com o jogador um, supondo que o jogador
zero seja o dealer Assim como podemos usar o
pop-back para remover um cartão, também
podemos adicionar um
cartão com pushback A carta que estamos
colocando na parte de trás da mão
do jogador é a mesma carta que estamos tirando
da parte de trás do baralho Podemos simplesmente colocar
essa chamada de função dentro dos colchetes
da chamada de função e usar seu valor de retorno como
argumento para a função push Usar pushback é
exatamente o mesmo que anexar. A função append é
um legado de strings, já que elas geralmente são armazenadas
como matrizes de caracteres, enquanto push e pop vêm do
uso de pilhas ou cues Para distribuir nossa próxima carta, precisaremos incrementar a
mão que está sendo distribuída. Vamos armazenar isso
em uma variável como
um número inteiro e atribuir a ela o
valor inicial de um Substituindo aquele em nosso
índice de matriz por nossa variável, precisaremos incrementá-lo um após cada carta ser distribuída Mas, obviamente, isso contará
apenas até 51, e não há muitas mãos. Então, precisaremos que esse
número retorne
a zero toda vez
que chegar a quatro. Isso pode ser feito usando nosso operador de módulo fiduciário,
atribuindo mão como módulo igual a quatro Mas se quisermos permitir que nosso código funcione com qualquer
número de jogadores, seria melhor substituir quatro pelo tamanho da nossa matriz
de mãos. Para ver onde estamos até agora, vamos imprimir nossas mãos
iterando a matriz de mãos e
imprimindo cada uma Em seguida, imprima o baralho. Podemos ver nossas quatro matrizes
e o baralho está vazio. Podemos até mudar o
número de jogadores e as cartas serão distribuídas para
o número correto de mãos. Nossa função pronta está
ficando bem grande. Podemos organizar
melhor nosso código declarando
nossas próprias funções Separando nossa lógica
em pequenos pedaços, temos uma seção que cria
nosso baralho inicial de cartas, uma que cria as mãos
do jogador e outra que distribui as cartas. Usando a palavra-chave funk, podemos dar a cada um
desses blocos de código um nome seguido por
parênteses Inicializou o baralho,
inicializou as mãos e negociou. Então, a função ready pode chamar cada uma dessas
funções em sequência. Nossas funções também podem
aceitar argumentos, como o número de
mãos que queremos ter. Vamos passar quatro como argumento. Para escrever nossa função
para aceitar o argumento, precisamos adicionar um parâmetro
correspondente dentro dos parênteses da declaração
da Assim como declarar uma variável, ela tem um nome e,
opcionalmente, também um Como estamos usando isso
para redimensionar uma matriz, é uma boa ideia
restringi-la a um número inteiro Podemos então usar o
parâmetro dentro da função da mesma forma que usaríamos
qualquer outra variável. A última coisa que precisamos
fazer para começar a jogar
seria remover todos os pares
da mão de cada jogador. Então, iterando cada
mão na matriz de mãos, podemos chamar outra função para remover os pares
dessa mão, passando a mão como argumento Dando
uma definição a essa função, podemos então aceitar uma mão
como um parâmetro de matriz. Precisaremos iterar com
a mão com uma variável. Vamos chamá-lo de cartão um. Mas podemos parar antes de
chegarmos à última carta. Então, vamos apenas de zero
até o tamanho da
mão menos um Podemos então iterar
uma segunda vez da mesma
forma, mas desta vez, começar com a carta após a
primeira carta e ir até
o final do tamanho da mão Dentro desses 24 loops, carta um e a carta dois agora contêm cada par
de cartas exclusivo em nossa mão, então podemos comparar facilmente as duas cartas para ver
se elas combinam Se estiverem, eles podem ser removidos da mão,
começando com a carta dois. Se removêssemos a carta um primeiro
, o índice da carta dois realmente
mudaria como resultado, já que todas as cartas se
moveriam em uma posição. Se encontrarmos uma correspondência, não
queremos continuar
esse loop ou qualquer um deles, mas queremos reiniciar todo
o processo novamente. Uma maneira simples de fazer isso
seria com um loop while, uma variável booleana
para determinar se
encontramos ou não um par com um valor
padrão verdadeiro Embora um par tenha sido encontrado, podemos
defini-lo imediatamente como falso. Isso nos permite
entrar no loop, mas não ficar aqui, a menos que
um par seja encontrado. Em outras linguagens, você pode fazer isso com um loop do
Wile em vez disso Se encontrarmos um par, podemos definir a variável como verdadeira e, em
seguida, sair dos dois loops, redefinindo
o loop while Se os quatro loops concluídos sem encontrar
um par correspondente, par
encontrado será falso e
o loop while será interrompido Podemos executar nossa
simulação repetidamente e ver que nenhuma das mãos de nossos jogadores jamais
conterá pares
iguais, e os jogadores estão prontos para
começar a jogar Old Maid Na próxima lição,
usaremos outra forma
de controle de fluxo. Te vejo na próxima aula.
8. 0-7 partida e volta: Olá, amigos. Hoje, usaremos outra forma de controle de fluxo para simplificar condições complexas. Eu já criei um script chamado
months e substituí a definição dos nós básicos
da função ready Vamos começar
declarando uma variável para manter o mês atual
e defini-la janeiro e uma segunda variável para manter o número de
dias no mês, que será deixado
como zero por padrão Podemos imprimir uma
frase simples informando que o número de dias
em janeiro é 31 Mas primeiro, queremos
preencher nossa variável com o número de dias com
base no valor do mês Então, vamos escrever uma função
que pode fazer exatamente isso. Atribua o número de
dias do mês a serem retornados de uma
função que escreveremos, que aceitará o
mês como argumento. Dando
uma definição a essa função, aceitando o mês como um
parâmetro do tipo string, ela também precisa de mais uma informação, um tipo de retorno. O tipo de valor retornado por
uma função é definido após os parênteses com um hífen
e uma letra maior em uma seta,
seguido os parênteses com um hífen
e uma letra maior em uma seta,
seguido pelo nome do tipo. Nesse caso, é um número inteiro, representando o número
de dias no mês Se não especificarmos
um tipo de retorno,
o tipo de retorno para qualquer função que escrevermos será nulo por padrão Dentro de nossa função,
precisamos retornar um número inteiro, o que significa que devemos declarar um inteiro no topo dela, e ele precisará conter o
número de dias do mês Em seguida, na
parte inferior da função, retornaremos o valor
mantido nessa variável. Entre essas duas linhas, precisamos preencher
nossa variável com o número correto de
dias com base no mês Se o mês for janeiro, o número de dias será 31. Aprendemos anteriormente
que podemos fornecer uma alternativa
com a palavra-chave se, mas isso só nos fornece duas opções
das 12 de que precisamos. Podemos usar outra palavra-chave, if, abreviação de se if, para fornecer outra condição que será verificada se a
condição original for falsa. Caso contrário, se o
mês for fevereiro, o número de dias será 28. E podemos repetir isso
quantas vezes precisarmos, fornecendo um caso para
cada possibilidade. Mas muitas dessas opções
têm o mesmo resultado, 30 dias ou 31 dias. Poderíamos melhorar consideravelmente
a eficiência dessa
declaração if combinando
o resultado mais comum, 31 dias para ser o caso padrão, e substituindo todos eles uma única
palavra-chave else no final Portanto, se o mês não for fevereiro ou qualquer mês com 30 dias
, o número de
dias deverá ser 31. Todos os casos resultantes
em 30 dias também podem ser combinados em uma única declaração
usando o operador or. Se o mês for setembro ou se o mês for abril ou
se o mês for junho, ou se o mês for novembro, o número de dias será 30. Mas a declaração é bem
longa, com mais casos, ela pode sair da tela. Para
declarações simples, caso a caso, como essa, há uma
palavra-chave mais limpa
e fácil de usar do que a
instrução I chamada match. A correspondência é seguida
pelo nome de uma variável, dois pontos e depois por um bloco de
código recuado Dentro de um bloco de correspondência, podemos especificar qualquer número de casos
específicos para o
valor da variável. Vamos começar com fevereiro. O caso também é seguido por dois pontos e outro bloco de código
recuado Esse código só será executado se o valor do
mês for fevereiro. Podemos agrupar casos
em uma lista separada por vírgulas. Portanto, nossa
condição de declarações I pode ser reduzida para apenas uma
lista de quatro meses Se o valor do mês for
setembro, abril, junho ou novembro, o número
de dias será definido como 30, e nosso bloco poderá
ser substituído por uma caixa curinga representada
por um sublinhado, definindo o número
de dias como 31 se o valor do mês não for
especificado acima Isso é o mesmo que usar o
padrão em outros idiomas. Cada um desses blocos de
código é chamado de ramificações. E no script GD, uma
instrução de correspondência só
executará a ramificação
superior
cuja condição foi atendida cuja condição foi atendida Em outras linguagens, isso é semelhante a uma instrução
switch, mas difere porque as instruções
switch podem executar mais de uma ramificação se várias condições forem atendidas. Por causa dessa restrição, não
há necessidade de incluir
quebras nas ramificações da partida Se quiséssemos imprimir o número de dias
em cada mês, provavelmente
usaríamos um loop, mas não podemos simplesmente
contar ou incrementar uma sequência de caracteres como janeiro para, de
alguma forma, virar fevereiro Portanto, é comum no código, ao representar coisas
que existem em uma ordem sequencial,
colocá-las em uma lista numerada chamada Uma enumeração no script GD é apenas um grupo Podemos ter uma constante para
janeiro com um valor de um, outra para fevereiro com
um valor de dois, etc Mas usando a palavra-chave Enum, podemos nomear o
grupo de constantes, vamos nomeá-lo em meses
seguidos por Dentro das chaves, podemos
agrupar as constantes
e
cada uma receberá um número automaticamente com base em sua
posição nessa lista Qualquer coisa
contida nas chaves não precisa
ficar em uma linha e pode ser dividida em qualquer formato que você preferir
para torná-la mais legível recuo não importa aqui, mas geralmente ao escrever
algo entre colchetes, a
maioria dos codificadores recua no conteúdo,
então parece
semelhante a então Embora eu prefira que as chaves
sejam alinhadas verticalmente, muitos codificadores preferem colocar a chave de abertura
na linha de
declaração Assim como Constance, as entradas de
enumeração são convencionalmente nomeadas em maiúsculas e minúsculas. Agora que temos uma enumeração, o mês pode ser restrito ao tipo dessa Também podemos atribuir a ele um
valor a partir da enumeração, começando pelo nome,
seguido por um ponto e, em
seguida, pela entrada na lista O mês que está sendo anexado à saída
da string não é mais uma string em si e deve ser convertido em uma string antes
que possa ser anexado O argumento que está sendo passado para o número de dias não é mais uma string e agora é um mês, e podemos alterar nossa função para aceitar um mês como
parâmetro também. Como mês agora é um
mês, não uma string, precisaremos alterar
nossas condições para que correspondam usando o nome da enumeração
seguido por um ponto e, em
seguida, as entradas na lista Mas quando imprimimos
os resultados, vemos que, em vez de janeiro, nosso mês é escrito
como o número zero. Embora o tipo de nossa
variável seja um mês, que é uma enumeração, o valor real é
tratado como um número inteiro, sua posição na Como janeiro é
a primeira entrada, seu valor como número inteiro é zero Fevereiro seria
um, etc. Isso nos permite modificar o valor do mês com aritmética
simples, então janeiro mais um Se envolvermos esse código em um
loop que se repete 12 vezes, podemos iterar
todos os 12 meses com facilidade Mas que tal escrever o
nome do mês como uma string? Poderíamos fazer isso de
duas maneiras diferentes. Nosso tipo de enumeração tem
uma propriedade chamada keys,
que consiste em todas as nossas entradas
como uma matriz de Se indexarmos essa matriz
usando nossa variável inteira, ela nos dará o nome da entrada como uma string correspondente a
esse número Mas seguindo a convenção de nomenclatura de
maiúsculas e minúsculas de Upper Snake, talvez não
queiramos
imprimir o nome dessa poderíamos renomear todas as
nossas chaves de Em vez disso, poderíamos renomear todas as
nossas chaves de enumeração no caso
Pascal ou declarar uma constante contendo
a matriz de strings,
mantendo todos os nomes dos nossos meses ou declarar uma
constante contendo
a matriz de strings,
mantendo todos os nomes dos nossos meses em um formato mais apresentável. Em seguida, use o mês como um
índice nessa matriz. Outra coisa que podemos fazer
com as enumerações é definir
manualmente os valores das entradas usando
o
operador de entradas usando
o
operador Digamos que queremos que janeiro
seja um em vez de zero. O restante das entradas
atualizará automaticamente seus valores para
incrementar a partir de um, então fevereiro agora é dois Mas isso não corresponde mais
aos índices constantes da matriz. Então, se quisermos usar isso para escrever o
nome dos meses, precisaríamos adicionar uma entrada vazia para o índice zero ou subtrair uma do mês conforme ela está sendo usada
para indexar a matriz Na próxima lição,
aprenderemos mais sobre como o mecanismo usa e
executa nossos scripts Te vejo na próxima aula.
9. Árvore de cenas e herança: Olá, amigos. Hoje,
aprenderemos sobre como o mecanismo usa a
árvore de cenas para executar nossos scripts. Ainda não anexei um script ao
nó raiz da árvore de cena,
mas, em vez disso, começaremos esta
lição adicionando mais nós. Clicando com o botão direito do mouse no nó raiz e selecionando adicionar nó filho, ainda apenas um nó normal, podemos renomeá-lo para
presidente e fingir que nossa árvore de cenas é
a estrutura de uma empresa O nó presidente é indentado porque é filho
do nó raiz da cena Com um nó selecionado, também
podemos usar o atalho Controle
A ou Comando A para adicionar outro nó filho Vamos nomear esse gerente de
operações, e ele é recuado outro nível porque é
filho do presidente Agora vamos anexar um novo script ao nó
do presidente
e nomeá-lo funcionário. Substituindo a
definição dos nós básicos da função
ready, podemos simplesmente imprimir o nome
desse nó e anexar está pronto. Esse script pode ser anexado
a mais de um nó. Então, vamos anexar o mesmo script
ao
nó do gerenciador de operações arrastando-o da guia
do sistema de arquivos
para a árvore da cena Em seguida, execute a cena
para ver o que acontece. Podemos ver que o gerente de
operações está pronto, então o presidente está pronto. Os dois nós que têm o script
anexado executam o script
e, como eles têm nomes
diferentes, a saída foi diferente. Também podemos ver que
o gerente de operações estava pronto antes que o
presidente estivesse pronto. Para entender por que
precisaremos adicionar mais funcionários. O gerente de operações
supervisionará vários operadores Vou adicionar outro nó filho
ao gerente de operações
e chamá-lo de operador 1. Em seguida, anexe o script do funcionário. Podemos clicar com o botão direito
do mouse em qualquer nó, exceto no nó raiz, e selecionar duplicado para criar
uma cópia dele O nome das duplicatas incluirá automaticamente
um número crescente, para que possamos ter o operador dois, três e quatro, etc Como o nó que duplicamos
tinha um script anexado, as cópias criadas também têm
o mesmo script anexado Como os operadores têm o mesmo
nível de indentação e são todos filhos do gerente de
operações, eles são chamados de irmãos,
e os irmãos não podem Nossa empresa deve ter
mais de um departamento, então vamos duplicar
todo o departamento de operações duplicando o gerente de
operações Todos os nós secundários também
são duplicados. Como os operadores
não são irmãos diretos, eles podem manter
seus nomes originais Vamos renomear o gerente
para gerente de marketing, e eles terão apenas dois profissionais de marketing
trabalhando em sua equipe Os nódulos parentais
também podem ser reduzidos para esconder seus filhos ou
expandidos para mostrá-los. Todos os funcionários
dessa empresa têm o mesmo
script de funcionário anexado a eles. Então, vamos rodar a cena e ter uma ideia melhor da ordem em que os scripts
serão executados. Podemos ver que o primeiro operador é
o primeiro a ficar pronto, seguido por cada
operador em sequência
e, finalmente, pelo gerente de
operações. O mesmo acontece com o departamento
de marketing. Então, finalmente, o presidente
da empresa é o
último a estar pronto. Como Gadot está decidindo
essa ordem de execução? O motor começa no topo
da árvore de cena e
desce, mas não
considera que nenhum nó esteja pronto até que todos os seus
filhos estejam prontos. Portanto, o presidente
não está pronto porque o
gerente de operações não está pronto. O gerente de operações não está pronto porque os
operadores não estão prontos. Os operadores estão
prontos em sequência, pois não têm filhos. Quando todos os
operadores estiverem prontos, o
gerente de operações estará pronto. Mas o presidente ainda
não está pronto porque o presidente tem outro
filho que não está pronto. O gerente de marketing não estava pronto até que todos os profissionais de
marketing estivessem prontos
e, finalmente, o presidente
é o último a estar pronto Como o nó raiz não
tem um script anexado, sua função pronta é a de um nó padrão, que está vazio. Além de prontas, existem
outras funções do nó que
podemos substituir para serem executadas
posteriormente, depois que um nó estiver pronto O mais comum é o processo, também precedido por
um sublinhado O mecanismo fará o
possível para executar
a função
de processo de cada nó na árvore
da cena 60 vezes por segundo usando a taxa de quadros padrão do
projeto. Portanto, o processo usa um
parâmetro chamado Delta, que é um
número de ponto flutuante para representar o número de segundos que
passaram desde o quadro anterior. Então, na maioria das vezes,
será um 60º, mas nem sempre. Não precisamos usar esse
parâmetro para nada hoje, então podemos continuar com o nome
desse parâmetro com
um sublinhado, para que Gudo saiba que não
precisamos usá-lo e não
devemos nos preocupar Mas, para substituir a função
do processo, ela deve ter o mesmo número
e tipos de parâmetros Vamos pedir aos nossos funcionários
que trabalhem em cada quadro,
imprimindo uma declaração dizendo que seu nome anexado
a funciona Nessa cena, vemos que todos os nossos funcionários
estão trabalhando muito, escrevendo suas declarações impressas
60 vezes por segundo. Isso não é o mesmo que um loop
infinito, pois o trabalho está realmente sendo feito da maneira pretendida e
nada está quebrado. Vamos tornar isso um
pouco mais fácil de
entender ,
permitindo que cada funcionário
faça apenas uma unidade de trabalho usando uma variável Bolan que tenha feito um trabalho com um valor
padrão de false Na função de processo, se o funcionário
não tiver feito nenhum trabalho
, ele trabalhará e
alterará o valor para verdadeiro. Um 60º de segundo depois, como a variável é verdadeira, eles não funcionarão mais. Mas se declararmos essa variável dentro da função de processo
, ela existirá somente dentro da função de processo e somente para uma única
iteração No próximo quadro, quando a função do processo é
executada pela segunda vez, a variável é declarada novamente e ainda assume o
padrão false. Então isso não terá efeito. Para que nossa variável persista, ela precisa existir fora
do contexto da função do
processo Então, vamos declará-lo fora
da função sem
qualquer recuo As variáveis declaradas aqui podem ser acessadas em qualquer lugar em todo
o script. Esse conceito é chamado de
escopo e é um
dos principais motivos pelos quais usamos
recuo em nossos scripts Assim, podemos ver quais variáveis
existem dentro de qual escopo. Comandando a cena agora,
podemos ver cada um de nossos funcionários declarar
que está pronto para trabalhar Então, somente quando
todos estiverem prontos, cada um fará uma unidade de trabalho, mas agora em uma ordem diferente. A ordem na qual os nós
e a árvore de cena
executam suas funções de processo segue a ordem exata da
árvore de cena de cima para baixo. Os pais não precisam esperar por seus filhos como se
estivessem prontos. Talvez queiramos que todos os funcionários da nossa
empresa sejam parecidos, mas não
exatamente iguais. O trabalho de um gerente não é realmente o mesmo
que o de um trabalhador. Podemos usar a herança para criar comportamentos
diferentes
para objetos semelhantes Da mesma forma, estamos escrevendo
scripts que estendem o node, mas mudando a forma como eles se
preparam e como são processados. Primeiro, precisamos
dar a esse script um nome que possamos
usar como referência, usando a palavra-chave nome da classe, seguido por um nome que descreva o comportamento
do script, geralmente igual ao nome
do script, mas escrito em
maiúsculas em Pascal Agora que o motor sabe que se
trata de um funcionário, vamos criar um novo script
e nomear esse gerente. Mas em vez de
herdar do nó, desta vez podemos
herdar do funcionário Como nosso
script de gerente estende os funcionários, tudo
o que está escrito no script
de funcionário ainda se aplica a este, mas podemos adicionar mais
ou fazer alterações. Um gerente ainda é um funcionário, mas a forma como ele
trabalha é diferente. Devemos substituir o
script anexado aos nossos nós gerenciadores
pelo novo script gerenciador. Vamos substituir a
definição do funcionário sobre a função
pronta Então, quando um gerente estiver pronto, ele não apenas dirá
que está pronto, mas dirá que
todo o departamento está pronto. Para que nossos dois
gerentes
possam gerar o nome
de seus departamentos, eles precisarão de uma
variável para manter o nome do
departamento como uma string. Mas como podemos
preencher essa variável para manter valores diferentes
para departamentos diferentes Se prosseguirmos com nossa declaração de
variável com a tag na exportação, essa variável se tornará acessível por outras partes
do mecanismo Gadot,
ou seja, o painel do inspetor Para que uma variável
seja exportada, ela deve ser declarada no nível
do escopo do script Selecionando o
gerente de operações e o cenário, agora
há um campo no painel
do inspetor em que podemos atribuir à
variável do departamento um valor de string Dessa forma, o gerente de operações e o gerente de marketing podem ter seu
próprio valor para essa variável que
podemos controlar facilmente. Executando a cena, podemos ver
que os nós que têm o script do gerente anexado agora declaram que seu
departamento está pronto, enquanto todos os outros
funcionários usam a definição anterior
no script do funcionário A função de processo no script do
funcionário também é herdada pelos gerentes e
é executada da mesma forma que antes Então, vamos mudar a função de processo do nosso
gerente. Os gerentes dirão
algo diferente. O Name plus gerencia os trabalhadores
para fazerem seu trabalho. A variável has done work
do script do funcionário também
foi herdada e
não precisa ser declarada
aqui para ser usada Na verdade, não podemos declarar uma
variável com esse nome, pois isso causaria um conflito com a variável
herdada com o mesmo Vamos examinar a cena
novamente e ver como nossos gerentes agora fazem seu trabalho
de forma diferente dos outros funcionários. Na próxima lição, aprenderemos
mais sobre o uso de nós na árvore de cenas e
os princípios de design
orientado a objetos. Te vejo na próxima aula.
10. 0-9 Abstração e encapsulamento: Olá, amigos.
Hoje, exploraremos como escrever aulas que sejam mais fáceis de usar e entender. Imaginando um carro como nosso
quadro de referência. Vamos criar dois
nós em nossa cena, um motorista e um carro como
filho do motorista. Em seguida, anexe um novo script
a cada um com o mesmo nome. Os carros são máquinas muito
complexas, e a maioria das pessoas que os dirigem não
tem ideia de como
eles realmente funcionam. Eles só sabem como
operar o carro. Vamos começar no script do carro e dar a ele o nome de classe car e, em
seguida, adicionar uma variável para o ano do
carro como um número inteiro Outra para a
marca do carro
como corda e outra para
o modelo também como corda. Exportando tudo isso, configurarei meu carro para ser
um Honda Civic 2007 Ao criar uma nova classe, não
se esqueça de salvar o script
antes de tentar usá-lo. No script do motorista, o motorista precisará de uma
referência ao carro, que podemos armazenar em uma
variável do tipo carro. Os nós podem acessar outros
nós na árvore de cena, maioria das vezes seus filhos usando outra tag semelhante à
exportação chamada de ready. Usando a tag on ready, podemos atribuir o
valor da variável depois que o nó estiver pronto, que significa que todos os seus
filhos também estão prontos, mas antes de chamar a
função ready desse nó. Podemos atribuí-lo
ao valor de retorno de um nó G embutido na função, que aceita um
caminho de nó como parâmetro. Se especificarmos o nome
do nó filho
entre aspas, agora
temos uma referência
ao nó filho armazenado
em uma variável e podemos acessar suas
propriedades e funções, incluindo aquelas
no script anexado Substituindo a definição
da função pronta, podemos acessar o nó do carro e imprimir seu
ano, marca e modelo A função ready é executada
após as tags on ready. Existe um atalho para a função get node
para facilitar isso, o cifrão, seguido
pelo mesmo caminho do nó Vamos voltar para o script do carro e
adicionar outra variável. Este especificando se o motor está
funcionando ou não como um booleano Como motorista, sabemos se
o motor está funcionando e temos controle sobre se o
motor está funcionando ou não, pois podemos optar por ligar ou parar o motor usando a chave. Portanto, consideraríamos essa
variável pública. Outra propriedade do nosso
carro pode ser o número de cilindros no
motor como um número inteiro, e vou atribuir a
ele um valor de quatro Isso é algo que o
motorista não precisa saber, não
pode acessar facilmente e nunca
deve ser
autorizado a mudar. Portanto, ao contrário da variável pública, essa seria
considerada privada, e podemos marcá-la como privada fazendo seu
nome continue
com um sublinhado No script do motorista, podemos
definir o valor do motor
ligado como verdadeiro colocando a chave na ignição
e girando-a Mas primeiro, devemos
apertar o pedal do freio. Vamos usar uma função para definir a pressão aplicada
ao pedal do freio, que assumiremos que seja
de até 20
kg de Então, para ligar nosso carro, provavelmente
deveríamos ajustar a pressão do freio para
algo em torno de 10 kg De volta ao script do carro, precisaremos definir essa função que define
a pressão do freio Como o mecanismo está em
uma variável, isso seria chamado de função pública, já que está sendo usado
por outro script. Essa função aceitará
um número de ponto flutuante como parâmetro
que representa a quantidade de pressão
aplicada ao pedal Mas o que o
carro realmente faz quando aplicamos pressão
no pedal do freio Do ponto
de vista do motorista, o motorista escolhe
aplicar uma certa quantidade de pressão no pedal sem nunca saber a posição exata Do ponto de vista do carro, a posição do
pedal é o que está sendo medido e
usado para parar o carro O carro usa a posição do pedal
do freio para ajustar
a quantidade de pressão aplicada às pinças que prendem as pastilhas de freio contra as rodas
do carro, sem
mencionar a complexidade
dos freios antibloqueio Então, se estivéssemos realmente
programando um carro real, precisaríamos escrever
várias funções complexas aqui que convertam
a simples ação
do motorista aplicando
pressão no pedal
do freio na complexa mecânica
de apertar Isso faz parte das funções
internas
do carro e nada
que seja controlado
ou acessível
ao motorista por
qualquer meio que não ou acessível
ao motorista por
qualquer meio seja
aplicar pressão no pedal do freio Portanto, consideraríamos
que essas funções são privadas, uma vez que devem
ser usadas apenas pelo próprio carro. E podemos marcar nossas funções
privadas
usando um sublinhado em seus nomes Observe como isso é o mesmo que o processo e as funções prontas. A forma como o GDScript usa variáveis e
funções
privadas é mais parecida com a forma como outras linguagens
usam as
protegidas pois são
acessíveis aos GD Script não aplica essas
regras de privacidade No entanto, o GD Script não aplica essas
regras de privacidade e os scripts
ainda podem acessar membros privados Essas convenções
existem apenas para
facilitar uma melhor
estrutura e design de classes Outra forma de usar
comentários no GD Script é criar regiões de nossos
scripts que estejam relacionadas, usando a palavra-chave region seguida pelo
nome da região Podemos finalizar uma região usando
a palavra-chave e a região. Então, vamos criar uma região
pública e uma região privada
em nosso roteiro de carro, separando o que deve ser acessível ao motorista
e o que não deve Para simplificar, digamos que o
motorista só
precise ligar ou desligar
o motor, aplicar pressão no acelerador, aplicar pressão no pedal
do freio
ou girar o volante O que realmente acontece
dentro de qualquer dessas funções públicas é a mecânica interna
do próprio carro. O motorista não precisa saber como nada disso funciona
para operar o carro. Por exemplo, ao
pressionar o acelerador, o que realmente
acontece é que o carro abre uma
válvula de entrada de ar no motor, deixando mais ar e
oxigênio entrarem no Portanto, o carro precisa usar um
sensor para medir a quantidade de
fluxo de ar e a quantidade de oxigênio que agora está
fluindo para o motor Em seguida, use isso para
ajustar a quantidade de combustível que está sendo injetada nos cilindros
do motor Todas essas funções
são privadas, pois não precisamos
saber o que elas realmente fazem
para dirigir o carro. forma como nosso carro se move estaria
na função de processo, e precisaremos de outra
variável privada chamada fase para representar em qual
das quatro fases cada cilindro está atualmente. Na função de processo do carro, se o motor estiver funcionando, podemos passar por cada um dos
cilindros do Somando o
cilindro e a fase, depois o módulo quatro, obtemos uma fase diferente
para cada cilindro Combinando esse número,
podemos dizer a cada cilindro que execute uma
fase diferente, o curso de admissão, o curso compressão, o curso de
combustão
ou o curso de escape, cada um aceitando o
cilindro como argumento Em seguida, aumente
a fase e volte para zero
quando atingir quatro. Cada uma dessas funções pode então controlar as válvulas de admissão, válvulas de
escape, injetores de combustível e velas de ignição de cada A quantidade de força
produzida pelos cursos de
combustão de cada cilindro moveria
o carro
para frente enquanto as pastilhas de freio tentavam parar o carro,
e a posição
do volante mudaria de direção A posição do carro
seria então movida pela direção, velocidade e tempo Delta. Não se preocupe se nada
disso fizer sentido para você porque esse é exatamente
o objetivo desta lição. Você não precisa
entender isso. Como tudo isso está na região
privada do roteiro, o motorista não precisa saber como isso funciona
para dirigir o carro. Eles só precisam saber como
usar a região pública
do script. A separação entre público
e privado impõe dois princípios importantes da programação orientada a
objetos encapsulamento é
a região pública, fornecendo acesso a variáveis ou
funções
públicas que são fáceis de
usar e simples de entender,
e a abstração é
a região privada, ocultando os detalhes de sistemas ou
mecânicos
complexos que
não precisam ser
entendidos para serem entendidos para Você saberá se suas
aulas seguem esses princípios se
puder ocultar todo o conteúdo privado e ainda entender
facilmente como
ele deve ser usado. Assim, nosso motorista agora pode
simular a condução do carro acessando apenas as
regiões públicas do script do carro, desde pressionar o
freio e ligar o motor até
soltar o freio,
pressionar o acelerador, girar
o volante, acessando apenas as
regiões públicas do script do carro,
desde pressionar o
freio e ligar
o motor até
soltar o freio,
pressionar o acelerador, girar
o volante, etc. Esses princípios não são
importantes apenas para nossos próprios scripts, mas também nos permitem
usar scripts escritos por outros desenvolvedores sem
entender completamente como
eles funcionam internamente Eles também tornam os
scripts R mais flexíveis. Imagine se trocássemos
nosso carro a gasolina por um carro
elétrico Alguma coisa no
script do motorista precisaria ser alterada? Somente o script do carro
precisaria ser alterado para um script de carro
elétrico, já que todas as variáveis e
funções
públicas ainda existiriam
no script dos carros elétricos. Da mesma forma, também podemos alterar o script do motorista para
um script de piloto automático, que só precisa receber um destino e será capaz de
operar o carro
automaticamente Na próxima lição,
aprenderemos ainda mais sobre os princípios de
design orientado a objetos. Te vejo na próxima aula.
11. Polimorfismo 0-10: Olá, amigos. Hoje
abordaremos o último dos princípios de programação orientada
a objetos, o polimorfismo Estendendo os conceitos de
herança e abstração, podemos escrever classes que representam um conceito mais
abstrato, uma coleção de
classes mais específicas relacionadas Vamos usar animais como exemplo criando
um script chamado animal
que estende o nó, mas não precisamos anexar esse script a nenhum nó
na árvore da cena. Aqui podemos dar ao
script um nome de classe e, em
seguida, definir propriedades e comportamentos que são
comuns a todos os animais, como uma variável para manter o plural do
animal como uma string e outra para o nome de
um agrupamento desse E também vamos definir uma
função para o animal se mover, comer ou falar. Embora possamos definir facilmente o plural de animal como animais, não
há uma palavra para
um grupo de animais Também não podemos definir
como um animal se move ou come sem saber
que tipo de animal ele é Portanto, os corpos dessas
funções podem permanecer em branco. Mas podemos considerar que alguns
comportamentos são comuns
o suficiente para que tenham
um padrão, como falar. Embora existam muitos mamíferos
diferentes que fazem uma grande
variedade de ruídos, a maioria dos animais não o faz, incluindo peixes A maioria das pessoas não os
descreveria como falando. Portanto, ao dizer a qualquer animal
aleatório que fale, podemos considerar que o
comportamento padrão é o silêncio. Então, vamos adicionar alguns animais
diferentes à nossa árvore de cenas,
começando com um gato. Agora podemos usar a herança, como fizemos antes,
para criar vários scripts de animais
diferentes que herdam de animais Em seguida, substituiremos
a função ready para dar às variáveis herdadas do animal um valor
apropriado para um gato O plural seria gatos, e um grupo de gatos
é chamado de Clouder As funções de comportamento também
podem ser substituídas para mudar o comportamento de
falar em silêncio para miar Os gatos andam sobre quatro
patas para se movimentar, e eu direi que comem peixe. O conteúdo real
dessas variáveis e
funções não é relevante, mas o foco está em como
elas são herdadas
do conceito abstrato
de animal para uma
instância mais específica de gato Podemos repetir esse processo para criar muitos outros tipos
diferentes de animais para adicionar à nossa
árvore de cena, como um pássaro ou um peixe. E dando a cada um novo script
herdado do animal, cada um pode fornecer seus
próprios valores exclusivos para as variáveis e
implementações das funções que O plural de pássaro é pássaros. Um grupo de pássaros
é chamado de rebanho. Eles voam para se movimentar, comem minhocas e
cantam para falar. Vou começar
meu script fish copiando o conteúdo
do script cat. E o plural de peixe é peixe Um grupo de peixes é
chamado de cardume. Eles nadam para se movimentar, comem algas, mas não
falam Ao omitir a função de fala, peixes usarão a definição
herdada da
escrita animal Até agora, tudo o que fizemos foi usar os princípios orientados a objetos que já conhecemos para herdar, abstrair e encapsular
as propriedades e comportamentos Mas tudo isso nos permite
usar o polimorfismo
tratando todos os animais como se fossem iguais e
intercambiáveis iguais e
intercambiáveis Primeiro, vamos adicionar um script
ao nó raiz da nossa cena e chamá-lo de Zoo,
herdando do nó Nosso zoológico está cheio de animais
diferentes, mas não importa o que
esses animais realmente sejam. Substituindo a definição
da função pronta para nosso zoológico, podemos facilmente
percorrer nossa lista de animais e tratar todos eles como se fossem apenas
animais Uma
maneira rápida e fácil
de armazenar todos os nossos animais em
uma única variável. Vamos chamá-lo de animais é usar uma função de nodo
chamada Get children. Isso retorna uma matriz de nós, todos os nós filhos
desse nó convenientemente organizados em uma matriz na
mesma ordem da árvore de cena Como isso
depende das crianças, devemos usar a etiqueta em on ready Como sabemos que
todos os animais têm as mesmas propriedades
e comportamentos, podemos analisar
cada animal em nossa variedade de animais e fazer com que cada
um fale E apesar de tratar todos
eles como animais, cada um falará de uma maneira
única, conforme definido por seus próprios
scripts específicos, ou usará a definição herdada de animal se não
tiver a sua própria Podemos criar quantos níveis de herança quisermos Então, vamos criar outro script
abstrato para mamíferos, herdado mamíferos são uma
subcategoria de animais,
incluindo todos os animais que têm glândulas
mamárias e
as usam para Essas são propriedades
e comportamentos únicos dos mamíferos que não
se aplicam a outros Assim, podemos adicionar uma nova variável ao script
dos mamíferos
para o número de glândulas
mamárias que esse animal tem e escrever uma nova
função chamada Novamente, o conteúdo
das funções não é
relevante para esta lição. Esse script também
precisará de um nome
de classe para ser herdado Passando para
o script do gato, já que gatos são mamíferos, podemos atribuir ao
número de glândulas mamárias um valor para gatos,
que deve ser oito E também podemos adicionar novos
mamíferos ao nosso zoológico, como um Os macacos também são mamíferos, mas só têm
dois Mais uma vez,
copiarei o conteúdo de outro script para
tornar as coisas mais rápidas. O plural de macaco é macacos. Um grupo de macacos
é chamado de tropa. Eles se movem subindo em árvores. Eles comem bananas, e eu vou
dizer que eles dizem oh. Nosso script Zoo agora pode
aproveitar essa nova estrutura de
herança para
aplicar condições exclusivas
especificamente
para aplicar condições exclusivas
especificamente animais que são Podemos usar diretamente nomes de
classes em
declarações condicionais para dizer que, se o
animal atual for um mamífero, executaremos algum código extra
exclusivamente para Vou imprimir
algumas linhas extras descrevendo nossos mamíferos E podemos ver que nossa produção é consistente para todos os animais, mas também tem algo único específico para
os dois mamíferos Você pode imaginar como poderíamos
mudar nossa lista de animais em nosso zoológico para qualquer tipo
diferente de animal, e poderíamos alterar nossa
estrutura de herança para categorizá-los com a
precisão necessária Na próxima lição,
aprenderemos sobre outra coleta de dados que podemos usar para agrupar
informações relacionadas. Te vejo na próxima aula.
12. Dicionários 0-11: Olá, amigos. Hoje, usaremos uma alternativa
à matriz que
às vezes é usada
como uma classe sem nenhuma função
chamada dicionário. Imagine uma fileira de
armários como você encontraria em uma
escola secundária ou em um ginásio Se declararmos uma
matriz de variáveis, podemos considerar que o índice
da matriz de cada uma é o número dos
armários Digamos que haja dez armários e possamos acessar cada armário
individual para colocar algo dentro,
começando no armário zero, começando no armário zero, um e O que colocamos dentro de cada
armário não importa. Pode ser um número inteiro,
flutuante, string,
booleano, nulo ou uma
instância de uma classe E podemos
imprimir o conteúdo dos armários para vê-los. Agora imagine que, quando
colocamos algo em
um dos armários, não apenas
fechamos a
porta do armário, mas também colocamos uma trava nela Esse cadeado requer uma
combinação de números de três dígitos para Anteriormente, se quiséssemos recuperar o conteúdo
do armário, precisávamos apenas saber
o número dos armários, ir até ele e
retirar o Agora podemos ignorar o número dos
armários e, em vez disso, precisamos saber a combinação
para abrir o cadeado Digamos que a
combinação seja 149. Como uma matriz, atribuir
algo ao número 149
significaria que a matriz teria que
ter 150 Se mudássemos o tipo de nossa matriz para um dicionário, isso ainda funcionaria,
exceto que não precisamos definir um tamanho para o dicionário antes de podermos acessar
seu conteúdo. Observe como a
saída mudou. dicionários são representados por chaves em vez de
colchetes, e cada entrada é um número
representando uma chave seguida
por um valor do que está contido no armário
trancado por essa Também não há entradas
no dicionário para nenhuma chave à qual
não tenha sido atribuído um valor. Como dicionário, esse número não
é um índice ou endereço. É uma chave que
usamos para abrir uma fechadura. E assim como o conteúdo
do armário pode ser de qualquer tipo de dados, as chaves que usamos para
bloqueá-lo também podem ser qualquer tipo de dados Cada chave deve ser exclusiva. Caso contrário, não conseguiremos
encontrar o armário que
corresponda à chave Então, vamos tentar trancar um armário com um tipo
diferente de fechadura, que usa letras
em vez de números Portanto, a chave dessa
entrada do dicionário é uma string, mas seu valor é um número. O oposto completo
desse armário, cuja chave é um número
e o valor é uma string Vamos trancar o próximo
armário com uma trava giratória, que requer três
números para desbloqueá-lo, que poderíamos
armazenar em uma matriz Portanto, nossa chave de entradas do dicionário
é uma matriz representada por colchetes contendo uma lista separada por vírgula
de três Talvez esse número de bloqueio
inclua um ponto decimal, então a chave é um flutuador E, de alguma forma, esse
armário está trancado pela fotossensibilidade e só pode ser aberto se as luzes estiverem apagadas Portanto, sua chave é um booleano. Podemos até usar classes
personalizadas como nossas chaves ou
valores nos dicionários Vamos escrever uma nova classe para chave, que não
precisará ser herdada de nada, pois não
será anexada a um nó nem herdada Nossa classe chave precisa um nome de classe e terá uma variável que
descreva seus dentes. A implementação dessa
classe não é relevante, mas podemos fingir que é uma chave De volta ao script do locker, podemos armazenar uma instância
da nossa chave em uma variável Vamos chamá-la de key
one do tipo key atribuindo-a ao nome
da classe da chave Nunu cria uma nova chave, que é atribuída
à nossa variável Agora podemos usar essa chave para criar uma entrada
no dicionário. Também podemos criar mais chaves
para criar mais entradas. Como cada chave que criamos
é considerada única. A saída agora exibe as teclas como contagem de recifes seguida
por um número longo Os nomes que usamos em outras classes foram
herdados do node Mas como a chave não herda do node, ela
não tem um nome Ref count é a abreviação de objeto contado por
referência e é a
classe base para o script GD Se escrevermos qualquer classe que não
herde de nada, ela herdará da
contagem de recifes e receberá
um número longo aleatório Podemos ignorar isso
e entender
que nossas chaves são objetos com contagem de
referência, o que significa que Gadot acompanha
automaticamente cada instância única
de cada objeto que criamos Mas o que queremos
guardar nos armários? Assim como as matrizes podem
conter outras matrizes, os dicionários também
podem conter outros dicionários Combinando a forma como os dicionários
são impressos, podemos criar nossos
próprios dicionários rapidamente usando chaves Cada entrada começa com
uma chave seguida por dois pontos e, em seguida, o valor
que corresponde a essa chave uso comum de
dicionários não é
criar nada parecido com
esse cenário de armário, mas sim criar
algo mais parecido com uma classe, embora sem nenhuma
função, apenas variáveis Digamos que esse armário
contenha um brinquedo de pelúcia, que representaremos
com um E este brinquedo de pelúcia
pertence a um conjunto de brinquedos de pelúcia
colecionáveis que são semelhantes, mas variados à sua
maneira Cada um dos brinquedos de pelúcia é um tipo diferente de animal
com uma cor e um nome Cada uma delas pode ser uma
chave no dicionário. Digamos que esse armário
contenha Bruno, o urso pardo. E o próximo armário contém
Arthur, o Bode Branco. Podemos ver nosso
dicionário de brinquedos de pelúcia dentro do dicionário
de armários Acontece que a cor
também é uma
classe já definida em Gadot Então, em vez de armazenar
nossas cores como strings, elas podem ser armazenadas como cores
usando a cor do nome da classe Como você pode ver,
há muitas cores
predefinidas para usarmos, e podemos dizer pela forma como elas são nomeadas em maiúsculas e minúsculas, que essas são constantes
da classe de Poderíamos até mesmo dizer isso e fingir que os brinquedos de pelúcia contêm uma etiqueta NFC ou de comunicação de
campo próximo, tornando-os a chave
para acessar o armário E podemos colocar o que
quisermos dentro do armário como
antes, incluindo
outro pelúcia Vamos fazer outro brinquedo de pelúcia
para guardar dentro do armário, que é destrancado
usando Arthur como Desta vez, é fofa,
o elefante cinza. Então, imaginando esse cenário, há um leitor NFC
perto dos armários e seguramos um pelúcia com uma etiqueta NFC dentro,
algo parecido
com o que você pode
encontrar em uma algo parecido
com o que você pode Se segurarmos o
brinquedo de pelúcia contra o leitor, precisamos verificar qual armário combina com o
brinquedo de pelúcia e desbloqueá-lo, se houver algum armário Mas se tentarmos acessar uma chave em um dicionário à qual não
foi atribuído um valor, causaremos um erro. Da mesma forma que
faríamos se tentássemos
acessar um
índice de matriz fora do intervalo. Podemos verificar se um dicionário
contém uma entrada correspondente a uma chave específica
usando a função has e,
em seguida, passando a
chave como parâmetro. Isso nos permite verificar
se
existe uma entrada no dicionário antes de tentar acessar seu valor,
evitando o erro. Se o dicionário
não tiver a chave, imprimirei uma mensagem
diferente. Em vez de definir o
mesmo dicionário duas vezes, seria melhor armazenar em uma variável e usar
a variável duas vezes. Na próxima lição,
exploraremos algumas técnicas diferentes
que você pode usar quando tiver dificuldades ou
precisar de mais informações. Te vejo na próxima aula.
13. Depuração 0-12: Olá, amigos.
Hoje, abordaremos algumas estratégias diferentes
que você pode usar para ajudá-lo quando você
inevitavelmente ficar preso Eu já
anexei um script
ao nó raiz da cena chamado debug Você provavelmente já percebeu o recurso de
preenchimento automático que está disponível se você especificar
o tipo de suas variáveis Isso não só permite que
você veja todas as propriedades e
funções da classe, mas depois de selecionar uma função, você também pode ver os tipos de todos os parâmetros da função para que você possa fornecer argumentos
correspondentes. , quando você conhece os tipos
de todas as suas variáveis, isso torna os
erros de incompatibilidade claramente aparentes, e você será avisado
do erro sem
precisar executá-lo Sem tipos rígidos,
o motor não sabe o que é incompatível até
tentar executar a linha Se você quiser navegar por uma classe
embutida, como a cor, podemos acessar facilmente as
informações clicando em qualquer um dos botões
no canto superior direito do painel. Online Docs abre uma guia em
seu navegador padrão para a API GADO correspondente à versão do editor
que você está usando Aqui você encontrará
informações básicas sobre Gdo, dicas para começar, tutoriais
detalhados
sobre o básico, links da
comunidade onde você pode
encontrar recursos adicionais e uma Como você pode ver,
há muitas aulas. E selecionando qualquer um deles, podemos ver do que
eles herdam e por quais outras classes
eles são herdados Cada um tem uma descrição
do que faz. Links para tutoriais
sobre como usá-lo, uma lista de propriedades
e métodos Quando falamos sobre classes, tendemos a nos referir às variáveis como propriedades e às
funções como métodos. Também existem sinais, algo que Gadot usa para comunicação
automática
entre nós, enumerações e constantes,
como usamos antes Todos eles têm
suas próprias subseções e descrições de
como usá-los. De volta ao Editor do GDA, a
pesquisa Ajuda abre uma janela no GDA onde você pode ver
uma lista de todas as classes Ao selecionar uma turma,
podemos ver todas
as mesmas informações
que estão disponíveis no site
do GDA em nosso editor, para que possamos acessá-las offline Voltando ao nosso script, podemos até acessar
essas informações mais facilidade mantendo pressionada a tecla de controle ou comando
do que clicando no nome de uma classe, levando-nos diretamente
às
informações de referência dessa classe. O mesmo pode ser feito para funções
e variáveis
específicas. Clicar neles não apenas abre a
página de referência da classe, mas também nos leva
à função ou variável em que clicamos Também existem funções globais
que podemos usar principalmente para realizar operações matemáticas,
como clamp, por exemplo Se usarmos essa função, podemos ver os parâmetros
que ela espera e podemos usá-la para fixar
nossa variável em 0-1 Segurar a
tecla de controle ou comando e clicar no nome da função global nos
permitirá acessar
a referência
dessa função, completa com uma descrição
e como usá-la. Todos eles estão contidos
na classe de escopo global. Vou adicionar outra variável e
outra linha ao meu script. Se executarmos nossa cena,
podemos ver a árvore de cenas
da simulação em execução por meio do painel de cena clicando
no botão remoto Essa não é a mesma
árvore de cena na guia local que criamos para definir a
cena como uma planta Essa árvore de cena é
aquela que foi construída pelo
motor para executar a cena. Selecionando qualquer nó, podemos ver suas propriedades
no inspetor e podemos ver que a
função ready já foi executada, pois as cores
têm valores diferentes Também podemos alterar os valores de
qualquer uma dessas propriedades. Também podemos usar
a impressão para imprimir sempre que quisermos ver o que nossas
variáveis contêm a qualquer momento. E ajuda ser o descritivo possível
com suas declarações impressas, para que não haja confusão sobre a
origem delas Mas se mudarmos as coisas
e usarmos a função de processo, mudarei a cor
gradualmente ao longo do tempo adicionarei uma declaração impressa aqui. Como essa função de processo é executada 60 vezes por segundo, o valor das instruções de impressão como ferramenta de depuração é
bastante reduzido, pois o registro de saída simplesmente repetirá
a mesma mensagem mais rápido do que podemos
lê-la ou reagir a Podemos pausar a simulação
enquanto ela está em execução, usando o botão de pausa
ou pressionando F sete Isso nos permite ver a árvore da cena
remota como ela está
neste momento e revisar
o conteúdo do painel de saída com
a simulação pausada Mas isso ainda
não é muito útil, pois vários quadros
serão concluídos entre o momento em que a simulação começa e quando podemos pausá-la Se clicarmos à esquerda
de qualquer linha de código, podemos adicionar um ponto de interrupção
automático indicado com um círculo vermelho Quando executamos a cena atual, a simulação será
pausada quando atingir
essa linha antes de executá-la . Isso é muito mais
útil se quisermos
ver nossa simulação ser executada
um quadro por vez. Agora podemos ver como
a cor de cada quadro muda gradualmente de
um quadro para o outro. Vamos fazer com que nossa função de processo chame outra função para
realizar uma tarefa simples. Vou mudar
a cor gradualmente reduzindo seu valor de vermelho. Então, agora devemos ver
a cor
mudar gradualmente a cada quadro, ficando
menos vermelho e mais azul. Com o ponto de interrupção ainda
na primeira linha da função de
processo, vou executar a cena Ele pára aqui e podemos ver
que a próxima linha de código a ser executada é indicada
com um triângulo amarelo. Enquanto a simulação
é pausada dessa forma, podemos pedir que ela execute apenas uma única linha
de código por vez, em
vez de um
quadro inteiro, selecionando passar por cima no menu Depurar ou
usando o atalho F ten Isso executará
apenas a linha de código apontada
pelo triângulo amarelo e, em
seguida, fará uma pausa novamente. Assim, podemos ver as alterações feitas apenas por essa
única linha de código e podemos ver o triângulo
amarelo apontar para a próxima linha
esperando para ser executada. Podemos continuar executando nosso script linha por
linha se continuarmos
avançando até que
a função do processo termine e o quadro seja concluído, retornando ao topo da função
do processo
para ser executado pela segunda vez Agora podemos observar cada
alteração individual na cor à medida seu valor de azul aumenta separadamente de quando o valor de
vermelho diminui, mesmo que elas ocorram
durante o mesmo quadro. No caso de chamadas de função, há outra opção para
entrar na função. Se selecionarmos essa opção
ou usarmos o atalho F 11, a seta amarela
entrará na função que está sendo chamada e executará essa linha por
vez até sua conclusão Quando a função estiver concluída, a seta amarela retornará
à função original para
continuar executando aquela Usando essas ferramentas, temos uma visão muito focada do que nossas aulas
estão fazendo e quando, como elas estão se comportando, e
podemos observá-las em
câmera lenta o quanto precisarmos para descobrir o que está errado em qual momento
específico Se você não consegue resolver
um problema sozinho, a comunidade GDA é muito prestativa e está sempre
disposta a Existem servidores Discord
para desenvolvedores do GDA,
incluindo meu servidor, onde
meus alunos se ajudam mutuamente O link para participar
está no meu perfil. Também existem fóruns on-line em sites como o Redit, onde
você também pode fazer perguntas. Agora você tem uma
compreensão básica da maior parte da sintaxe do GDScript e das ferramentas necessárias para explorar mais esses
conceitos Quando estiver pronto, peça
um código de desconto para
qualquer um dos meus
cursos de projetos de jogos e boa sorte.
14. Noções básicas: Olá, amigos. Nosso objetivo para a primeira seção
deste curso é criar um
personagem de três D que o jogador possa controlar na perspectiva de terceira
pessoa. Nossa primeira lição
será configurar uma cena básica em três D
e um novo projeto. Abrindo o Gada pela primeira
vez, não há projetos. Cadeau recomenda explorar exemplos de projetos
oficiais. Pressione cancelar para ignorar
essa recomendação. Começaremos um novo
projeto do zero. Clique no botão novo
para criar um novo projeto. Precisaremos dar um nome
ao novo projeto. Vou nomear meu curso Gada
Three D. E selecione uma pasta no seu
disco rígido para armazená-la. Eu recomendo criar uma pasta para projetos
do Gada em documentos. Em seguida, clique no botão de
repasta para criar uma nova pasta neste local com o nome do projeto. Você pode alterar as
configurações do renderizador do seu projeto. O Forward é melhor
para jogos de alta fidelidade, para PC ou console Ou o renderizador móvel
para dispositivos móveis. Gosto de usar o renderizador de
compatibilidade para a maioria dos projetos
porque ele é mais compatível com
compilações da web que podem ser enviadas para sites como o dot IO Por fim, Deus suporta a integração com o
controle de versão GT Tub por padrão Clique em criar e editar para criar o projeto e
abri-lo para edição. A janela do editor Gdo é
dividida em várias guias. No centro, há uma prévia da aparência da
cena atual, além de várias ferramentas
que podemos usar para editar coisas. No canto superior esquerdo
está a guia da cena, que contém uma lista de tudo
na cena atual. Abaixo está a guia do sistema de
arquivos, que contém todos os ativos importados para nosso projeto, como modelos, texturas, sons e músicas Além de todos os arquivos, criaremos usando
o editor Gada, como cenas, scripts
e recursos. Atualmente, o único arquivo
aqui é o logotipo da Gada. À direita está
a guia do inspetor,
onde, se selecionarmos
qualquer coisa na cena, podemos ver suas propriedades
e editá-las. Todas essas guias
podem ser redimensionadas e reorganizadas conforme você achar melhor
para acomodar
melhor seu fluxo Nossa cena é um vasto espaço
vazio de três D dividido por três eixos coloridos O eixo x vermelho representa a
direita e a esquerda. O eixo y verde
representa para cima e para baixo. O eixo Z azul representa
para frente e para trás. Vamos começar clicando nos três botões
de cena D
na guia de cena. Isso criou um nó raiz para nossa cena na guia cena, chamado Node three D, que também é o tipo de nós. Podemos renomear esse nó
clicando duas vezes nele ou clicando com o botão direito do mouse
e selecionando renomear Em muitos jogos, essa
cena será chamada de cena principal
ou cena do jogo. Você também pode nomeá-lo o estilo de jogo
que será usado, como a cena de plataforma, exploração, combate
ou quebra-cabeça Vou dar um nome ao meu jogo. Esse nó raiz formará nossa árvore de cena à medida que
adicionamos ramificações a ela. Clique no botão de adição ou clique com o
botão direito
do mouse no nó raiz e selecione Adicionar nó filho para adicionar uma
ramificação à árvore da cena. Há muitos tipos
diferentes de nós para escolher que servem a
muitos propósitos diferentes. Os tipos de nós seguem uma
hierarquia de herança. Portanto, todos os nós compartilham
o tipo comum de nó. Mas há o nó
três D, o item Canvas, nó dois D, o controle, cada um com muitos subtipos
diferentes Se você sabe o que
está procurando, você pode digitar o nome do
nó no campo de pesquisa. Vamos adicionar uma
instância de malha com três nós D. Você pode ver que uma
instância de malha de três nós D está herdando propriedades de
uma instância de geometria,
três nós D, instância
visual três, nó D,
nó três D e Clique no botão Criar para adicionar o
nó D da instância de malha três à árvore de cena. Você pode ver que o nó
foi adicionado à árvore de cena, mas está recuado para sugerir que é
filho do nó raiz Qualquer nó com filhos
pode ser reduzido ou expandido para ocultar ou
mostrar seus nós filhos Supõe-se que
seja uma imagem em três D, mas nada é exibido
na janela de visualização. Isso ocorre porque
essa instância de malha não tem um recurso de malha
informando o que desenhar. Com a instância de malha,
três nós D selecionados. Consulte a guia do inspetor para visualizar e editar as propriedades dos
nós As propriedades são divididas
nos mesmos tipos que vimos
ao criar o nó. Assim, podemos ver quais
propriedades são herdadas de diferentes tipos e quais são específicas para nossa instância de malha Podemos ver que o campo
de malha está vazio. Ao clicar no menu suspenso, há várias opções, incluindo algumas formas
básicas, caixa,
cápsula, cilindro, quadriciclo,
prisma, esfera e Vamos transformar essa forma em um avião. Agora podemos ver uma
forma de três D desenhada em nossa prévia. Clicar no
recurso de malha expande suas propriedades para que também possamos
visualizá-las e editá-las Aqui, podemos definir o
tamanho do plano nas dimensões x e
y digitando um número no campo ou clicando e
arrastando o rótulo do campo As unidades geralmente são
consideradas metros ou aproximadamente três pés
em medidas imperiais. Mas não há necessidade
de usar essa proporção. Em um jogo de estratégia, uma unidade pode ter um
quilômetro ou uma milha, ou se você estiver jogando
como um inseto minúsculo
, uma unidade pode ter um
centímetro ou uma Agora que temos
algo em nossa cena para nos dar um ponto de referência, vamos explorar a
cena um pouco mais. Há uma grade de linhas
cinza mais claras dividindo o plano x z em unidades, com cada oitava
linha sendo Podemos aumentar ou diminuir o zoom
usando a roda do mouse. diminuir o zoom, podemos ver que esse padrão continua à
medida que cada oitava subdivisão
maior também
é marcada, com
64 unidades de distância, o que
equivale E, novamente, a cada oito ou 512ª unidade, oito é
a potência de três zoom, a
inclinação original fica visível novamente. Manter pressionada a roda do mouse e movê-lo nos
permite girar o mundo em torno do eixo y e também inclinar nossa
perspectiva para cima ou para Manter pressionado o botão direito
do mouse e mover o mouse nos permite
girar nossa perspectiva,
olhando para a direita, para a esquerda, para cima ou para baixo Ainda pressionando o botão
direito do mouse, podemos usar as
teclas WASD para voar pela cena e, ao mesmo tempo, usar o mouse para orientar
nosso ponto de vista Se parecer que você está se
movendo lentamente ou não está se movendo, você provavelmente está diminuindo o zoom. Isso nos permite
visualizar nossas cenas de
forma rápida e fácil de
qualquer posição ou ângulo. A malha define apenas a
forma de um objeto de três D, não sua iluminação colorida
ou qualquer outra coisa. Tudo isso é definido por material. Expandindo o menu
suspenso rotulado, selecione o novo material padrão
três D. Em seguida, clique no recurso de
material recém-criado para visualizar e editar suas propriedades Os materiais têm
muitas propriedades para controlar como eles
interagem com a luz. Expanda a seção do albedo. Aqui podemos ajustar
a cor ou também usar um arquivo de imagem em dois D para aplicar
textura ao material. Tente arrastar o logotipo do Gada
para o campo de textura. Se houver uma
textura e uma cor
, a cor de cada pixel será multiplicada pelo
valor da cor para produzir o resultado No canto superior direito
há uma série de botões, um dos quais é
uma
claquete com
um ícone de reprodução, que executa a cena atual Clicar nesse botão
solicitará que salvemos a cena atual, caso ainda não
tenhamos feito isso. Caso contrário, ele salvará
a cena automaticamente. Isso nos permite executar uma simulação do nosso
jogo a partir da cena atual que estamos editando. Nada é exibido. Podemos fechar a janela
para finalizar a simulação. Isso ocorre porque
não há câmera na cena. É necessária uma câmera para
visualizar três cenas em D. Uma câmera é apenas
outro tipo de nó. Portanto, podemos adicioná-lo
à cena da mesma forma que adicionamos
a instância de malha. Precisamos usar uma câmera três
D para ver três cenas em D. A câmera é adicionada
na origem da cena, que é o centro
do piso, e está olhando na direção Z
negativa. Podemos ver para qual direção a câmera está olhando,
bem como a largura de
seu campo de visão com base
no dispositivo magenta em
forma de pirâmide E o triângulo também nos mostra
qual direção está para cima. Com os três nós D da câmera
selecionados na árvore da cena, clicar no botão anterior nos mostrará o que
a Onde a câmera está sentada agora, ela não consegue
ver nada. Clique no botão de pré-alternância
novamente para retornar. Precisamos
afastá-lo do chão e girá-lo para
olhar para o chão Podemos mover a
câmera facilmente ao longo um único eixo clicando e arrastando qualquer uma das
três setas, vermelha para o eixo x, verde para y e azul para Z. Também
podemos mover a
câmera ao longo de um plano clicando e arrastando
qualquer um dos Isso bloqueará o valor de x y ou
z
associado enquanto movemos a posição ao longo
dos outros dois eixos. Mova a câmera para cima ao longo do eixo verde e
para frente ao longo do eixo Z. Dependendo da
perspectiva do seu editor, avançar pode parecer retrocesso Mas, para maior clareza, avançar é usado para se referir à direção Z
positiva, que é a direção dos pontos
da seta azul. Isso também pode ser feito
bloqueando o eixo vermelho e movendo a câmera ao longo
do plano Y Z dessa forma Em seguida, precisamos girar a câmera para olhar
para o chão Podemos girar em torno de
um único eixo
clicando e arrastando qualquer um
dos três círculos Girar em torno do eixo y verde será como virar a
cabeça para a esquerda ou para a direita Girar em torno do eixo z
azul será como inclinar a cabeça para um lado ou até mesmo de cabeça para baixo Olhando para baixo, há uma rotação torno do eixo x, que é vermelho. Clique na pré-visualização para ver se sua câmera consegue ver
o chão com clareza. Com os três nós
D da câmera selecionados, observe no inspetor
as propriedades herdadas do nó três D.
Ao expandir a transformação, podemos ver que os valores
de posição
e rotação da câmera foram Todos os três nós D
herdarão essa propriedade para controlar sua posição e
rotação em três espaços D. Aqui, podemos
editar manualmente os valores ou clicar e
arrastar os rótulos para ajustá-los com o mouse,
como fizemos com o avião. A escala é um multiplicador do tamanho
de três objetos D. Por padrão, os
valores X, Y e Z estão todos vinculados,
portanto, editar um deles editará os três. As câmeras não têm tamanho,
portanto, alterar o valor
não afeta a câmera Mas definir a escala
para um valor negativo refletirá efetivamente sua rotação. Podemos redefinir a escala
para uma clicando
no botão de redefinição e
ignorar essa propriedade. Verificando a pré-visualização, a
câmera agora pode ver o chão. Mas se executarmos a
cena atual, o chão é preto. Isso ocorre porque não há nenhuma fonte de
luz em nossa cena. No editor, o
piso é iluminado porque há uma pré-visualização
de luz e ambiente, que podemos ativar ou
desativar usando Tirá-los do
chão fica preto, que é o que vemos
quando executamos a cena. Portanto, para que a câmera
possa ver o chão, também
precisamos adicionar uma
fonte de luz à cena. Adicione uma luz direcional
três D não à cena. Como a câmera, ela é adicionada na origem
da cena voltada para a direção
negativa. Uma luz direcional
simula a luz do sol, produzindo raios de
luz paralelos em toda a cena Sua posição não afeta seu comportamento, apenas sua rotação. Podemos movê-lo e
posicioná-lo em qualquer lugar da cena, preferência em algum lugar onde
possamos ver o dispositivo de seta branca. Essa seta aponta na
direção dos raios de luz. Gire a fonte de luz para que a luz aponte para
baixo em direção ao solo, iluminando-a para a câmera Agora, se executarmos a cena, a câmera pode ver o chão graças à luz
refletida nele Todo jogo executável precisa ter esses três componentes
básicos, algo para olhar, uma câmera para ver e
uma fonte de luz Se você precisar praticar com três posições e rotações D, tente fazer uma obra de arte
tridimensional abstrata usando instâncias de malha Observe que as luzes não
projetam sombras por padrão. Para ativar as sombras, clique
no nó da fonte de luz, expanda a seção de sombras
sob a luz três D e clique no botão de ativação Você também pode adicionar
luzes adicionais à cena, ajustar a energia ou a
cor para produzir uma grande
variedade de iluminação. Sinta-se à vontade para
experimentar diferentes propriedades dos materiais e também como eles
interagem com a iluminação. Ao terminar,
você deve ter uma boa compreensão da
relação entre malhas,
materiais, câmeras
e fontes de luz Como eles são usados para
criar uma cena em três D, como mover e girar objetos no espaço tridimensional e como navegar pela cena Na próxima lição, começaremos a receber informações do jogador. vejo na
próxima aula. Ok.
15. Roteiros: Olá, amigos.
Na lição anterior, montamos uma cena básica em três
D com malhas,
materiais, uma câmera
e uma fonte de luz Nesta lição, aceitaremos a
opinião do jogador. Clique no projeto
na barra de menu e abra
as configurações do projeto. Mude para a guia do mapa de entrada na parte superior da janela de configurações do
projeto. Para alcançar
nosso objetivo de controlar
três caracteres D, precisamos aceitar entradas
para as quatro direções de
movimento,
esquerda, direita, para frente
e para trás Digite, mova para a esquerda no campo
Adicionar nova ação. Em seguida, clique em
Adicionar para adicionar a ação. O nome da ação é
uma descrição da finalidade da entrada em nosso jogo, convencionalmente
escrito em minúsculas separadas por As ações são acionadas por eventos, que podemos adicionar clicando
no botão de adição. Os eventos podem ser teclas do teclado, cliques
do mouse ou movimento
ou entrada de um joypad Podemos pesquisar
as entradas desejadas expandindo suas categorias, filtrando os resultados da pesquisa ou usando o campo de escuta para simplesmente pressionar o
botão desejado Para mover para a esquerda, a maioria dos
jogos usa a tecla A
ou o controle esquerdo de um
joypad inclinado para a esquerda Adicionar vários eventos acomodará melhor os
diferentes estilos de jogo. Também precisamos ser
capazes de nos mover para a direita, frente e para trás, adicionando
uma nova ação para cada Vou usar a tecla D ou o
manípulo esquerdo da direita para a direita. WK ou manípulo esquerdo para cima para avançar e tecla S ou manípulo
esquerdo para trás O valor da zona morta é
a quantidade mínima de pressão ou inclinação necessária
para acionar essa ação Agora, o mecanismo escutará esses eventos de entrada e
acionará essas ações. Ao terminar,
clique no botão fechar para fechar as configurações do projeto. Vamos criar um novo
nó que
reagirá às
ações de entrada que criamos. Esse nó não precisa representar nenhum
objeto físico em nossa cena, então ele pode ser apenas um
nó básico e um jogador de nomes. Qualquer coisa em nossas
cenas pode se comportar anexando
scripts a elas. Clique com o botão direito do mouse no
nó do player e selecione Script anexado. Ou com o
nó do jogador selecionado, clique no
botão de script anexado na guia da cena. O idioma padrão
para scripts no mecanismo
Goda é o Goda,
que é muito fácil de aprender e bem otimizado para o desenvolvimento de
jogos Os scripts herdam os comportamentos
do tipo de nó ao qual
foram anexados Nesse caso, apenas
um nó normal. Os modelos são fornecidos para diferentes tipos de nós para
fornecer funcionalidade básica. As
caixas de seleção do modelo são ativadas por padrão. Vamos dar uma olhada no que
o modelo padrão
de um script de nó contém. Estamos criando um novo script, não usando um que esteja
embutido no motor. Podemos dar um nome ao script, que será recomendado
pelo mecanismo,
correspondente ao nome do nó ao qual
ele está sendo anexado. É convencional
usar snake case ao nomear scripts
como as ações de entrada Minúsculas separadas por
sublinhados. Clique no botão criar
para criar o script, e o editor
mudará automaticamente para a
visualização do script para editá-lo. Você pode voltar para a visualização em
três D a qualquer momento clicando nos
três botões D na parte superior do editor Da mesma forma, alterne para a
visualização do script clicando no script. A linha superior especifica
o tipo de nó ao qual
esse script pode ser anexado
, que é nó A palavra-chave extends
permite que esse script herde as propriedades
e os comportamentos de um nó, para que possamos usá-los
no script Funções são comportamentos que o script executará no
nó ao qual está anexado. Nosso modelo de script
começa com duas funções:
pronto e em processo. Texto cinza, começando com
um catthorp ou comentários. Texto que existe apenas
para nosso benefício como desenvolvedor para explicar o
script em linguagem simples. Os comentários nos dizem que
a função ready é chamada
automaticamente
quando o nó entra na árvore da cena
pela primeira vez. Não é quando criamos
o nó no editor, mas quando pressionamos o botão run
current scene. A simulação
construirá a árvore da cena
e, quando o nó do jogador for adicionado à
árvore da cena e estiver pronto, ele chamará esse comportamento. A função de processo
é chamada de cada quadro, que com as configurações padrão
do projeto é de 60 quadros por segundo. Essa função tem um
parâmetro chamado Delta, que é a quantidade
de tempo decorrido desde o
quadro anterior em segundos Essa variável é representada
como um número de ponto flutuante, um número com pontos decimais Podemos especificar o tipo de
qualquer variável com dois pontos, seguido pelo nome do tipo Como o script Gudo é
digitado vagamente, isso é opcional, mas especificar um
tipo melhorará a eficiência
do mecanismo e
reduzirá a frequência de reduzirá Portanto, é recomendável
sempre especificar o tipo de suas variáveis, a menos que você
precise permitir vários tipos. Ok. Podemos usar o
comando print em nossos scripts para enviar texto básico para o console de saída aqui
na parte inferior da janela. O comando print usa
uma string como argumento, que é uma sequência
de caracteres contida
entre aspas Vamos imprimir pronto durante
a função de preparação e processar durante a função de processo. Também podemos usar
o operador plus para acrescentar cadeias de caracteres, que nos permite acrescentar o valor de Delta à cadeia de caracteres
do processo Mas Delta é um flutuador, não uma string, o que não
é permitido Podemos converter o
tipo de Delta de um float para uma string
usando o comando STR, passando Delta como
argumento entre colchetes Execute a cena atual e
pare-a após um breve momento. No console de saída,
podemos ver que ready
foi impresso uma vez, seguido pelo processo 0,016, etc., muitas vezes, que é a taxa
de quadros de um 60º de segundo Às vezes, o número
pode ser maior porque o quadro demorou um pouco
mais para ser processado. Então, podemos ver que
esses comportamentos estão sendo chamados automaticamente
pelo motor. Vamos remover essas instruções de
impressão e toda a função ready. Em vez disso, queremos
verificar se o player está dando alguma entrada durante
a função do processo. Para armazenar essas informações, precisamos declarar uma
variável na parte superior
do script usando
a palavra-chave VR Vamos chamar isso de direção do movimento. Antes do nome
da variável com um sublinhado, ela é
marcada como privada, o que significa que somente esse script precisa se preocupar com O tipo da nossa variável
será um vetor dois. Um vetor dois é uma estrutura para armazenar dois flutuadores
chamados x e y. Já
trabalhamos com o vetor dois ao redimensionar
a malha plana e o vetor três ao editar a posição ou rotação
de qualquer nó de três D. Durante a função do processo, podemos definir o valor da direção do movimento para
o estado atual das
ações de entrada
do movimento que criamos anteriormente usando o
operador de atribuição ou o sinal de igual A direção do movimento
é igual ao vetor de entrada. A entrada é uma classe singleton, um script embutido que
podemos referenciar por seu tipo, pois sempre haverá
apenas uma instância dela O período acessa
variáveis ou funções
que, nesse caso, são chamadas métodos porque
pertencem a uma classe O método que estamos chamando
se chama get vector. Get vector aceita quatro
strings como argumentos, que são os nomes
das ações de entrada que serão usadas para
criar um vetor dois, que será então
armazenado na variável Um valor x negativo, que resta, será subtraído
de um valor x positivo, para calcular o valor
de x no vetor dois Da mesma forma, um valor negativo de
y para cima será subtraído de um valor y
positivo para
baixo para calcular
o valor de y. Isso pode parecer invertido, mas ao observar
os mapeamentos de entrada, a direção para cima é listada como
o lado negativo
do eixo
e para baixo é a Além disso, a câmera olha
na direção negativa definida. Avançar a partir da perspectiva da
câmera na verdade, significa retroceder
em três espaços D. Isso é consistente com jogos
bidimensionais pois a origem da cena está na parte superior da tela e os valores
positivos
se movem para baixo, não para cima. Por enquanto, podemos simplesmente imprimir o valor da nossa variável
para ver o que ela é. Vamos rodar a
cena atual e testá-la. O console de saída está
constantemente imprimindo
zero, zero porque nenhuma entrada
está sendo fornecida. Se pressionarmos qualquer uma das teclas WASD ou inclinarmos o controle
esquerdo em nosso joypad, o valor que está sendo
impresso Esquerda significa que o valor x
é negativo, positivo. Down define o
valor y como positivo, que está voltado para a câmera e cima negativo
longe da câmera. Fechando a janela, podemos
ver uma mensagem de aviso. O valor de Delta não está sendo usado pela nossa função
de processo. Podemos adicionar um sublinhado na frente
do Delta para marcá-lo que o motor saiba que ele pode ser ignorado, pois não
precisamos dele Agora podemos ler a entrada de movimento
do jogador a partir do teclado
ou do JoyPad Na próxima lição, usaremos a entrada do jogador para mover
um objeto pela nossa cena. Te vejo na próxima aula.
16. Controles: Olá, amigos.
Na lição anterior, começamos a receber
informações do player. Nesta lição, moveremos um objeto de três D pela
nossa cena usando essa entrada. Vamos começar removendo todas as malhas da nossa
cena, exceto o chão E adicionando um novo nó
à cena do jogo, um nó D do corpo do personagem. Esse nó vem com algumas funcionalidades
integradas para a física de mover um personagem, mas
na verdade não representa nada que
o jogador possa ver. Portanto, devemos adicionar um
nó filho ao corpo do personagem, uma instância de malha três
D. Que podemos preencher com uma malha de
cápsula com a intenção de substituí-la por um
caractere real posteriormente O corpo do personagem três D está
na origem da cena no chão, assim como a instância da malha. Se considerarmos que a
posição do personagem está
entre os pés
, a cápsula deve ser movida cima em relação ao corpo
do personagem. Com a instância de malha,
três nós D selecionados, que devem ser vinculados
ao corpo do personagem, movem a cápsula para cima ao longo do eixo y até que ela
esteja no chão, que deve ser uma unidade Ao selecionar o nó D
do corpo do personagem, se movermos esse nó, a instância da malha também se
moverá. Os nódulos infantis seguem a posição, rotação e escala
de seus pais. OK. Há um aviso na guia da cena informando que o corpo do personagem precisa de
uma forma de colisão. Esse é outro nó secundário. Precisamos adicionar ao corpo do
personagem três nós D, uma forma de colisão três nós D. O motor Goto não presume que colisões ocorrerão
quando as malhas colidirem Em vez disso, podemos adicionar
uma forma extra, geralmente uma que seja muito
mais simples de detectar colisões, a fim de tornar os cálculos mais eficientes Assim como o nó D da instância de malha três precisa de
um recurso de malha, o nó D da forma de colisão requer um recurso de forma Usaremos o mesmo formato de
cápsula e
a moveremos uma unidade acima para ficar na
mesma posição da malha. OK. Agora, é uma ramificação de nós
que se relacionam especificamente com
nosso personagem e
não têm nada a ver com a cena
geral do jogo. Clique com o botão direito do mouse nos três nós D do corpo do
personagem, selecione o galho seguro como cena e dê um nome a essa cena. Você pode nomear essa
cena com o nome
do personagem ou simplesmente
deixá-la como personagem por enquanto. Os nós secundários na árvore da
cena agora estão ocultos, e o nó do personagem
tem um ícone de claquete. Se clicarmos na
claquete, a cena
do personagem é
aberta para edição OK. Uma nova guia é aberta no editor
para nossa nova cena, e podemos alternar entre
a cena do jogo ou cena do
personagem
clicando nas guias. O personagem agora é
uma cena separada
da cena do jogo que
podemos editar isoladamente. Qualquer alteração que
fizermos nessa cena
alterará qualquer ocorrência
dela em outras cenas. Assim como nosso nó de jogador
tem um script de jogador, o nó de personagem também precisa um script de personagem para
dizer como se comportar. Ao anexar um novo script ao nó
raiz do nosso personagem, esse novo script
herdará do corpo do personagem
três D. Podemos usar o modelo básico
para esse tipo de nó e clicar em Criar para
abrir o Novo Há algumas diferenças
nesse modelo. O personagem tem
uma velocidade e uma
velocidade de salto armazenadas como constantes As constantes são semelhantes
às variáveis, mas são mais eficientes para
valores que nunca mudam Uma força gravitacional está sendo lida nas configurações do
projeto OK. Em vez da função de
processo, há uma função de
processo físico. Por padrão, tanto o
processo quanto o processo físico são executados 60 vezes por segundo. Mas em jogos com muitos corpos físicos
complexos,
a taxa de quadros do processo físico
pode ser reduzida para melhorar a eficiência sem sacrificar as atualizações
gráficas
ou o tempo de resposta Qualquer coisa relacionada aos cálculos de velocidade
ou força é feita na
função do processo físico para mantê-los separados. Durante a função do
processo físico, se o personagem
não estiver no chão,
então a gravidade vezes
Delta está sendo subtraída de sua velocidade
vertical Se o jogador pressionar
a ação de aceitação da interface,
uma ação de entrada incorporada
atribuída à barra de espaço
, o personagem pulará Este modelo também está usando código
semelhante para ler a entrada de
movimento
das teclas de seta. A entrada é então convertida em um vetor três
adicionando um zero para o valor y e usando o movimento vertical y
para o eixo zt, convertendo as
entradas para cima e para baixo no teclado do controlador em movimento para frente
ou para trás Isso é então multiplicado
pela base dos nós, que é uma estrutura de três vetores apontando para cima e para
frente Essas são as mesmas três setas
coloridas que são exibidas no editor quando
selecionamos qualquer nó de três D. No entanto, essas flechas
estão no espaço global. Se girarmos o corpo do personagem, as setas permanecerão as mesmas Os vetores básicos dos nós são
exibidos se mudarmos para o espaço
local clicando
nesse botão ou pressionando
a tecla de atalho T. Conforme o nó gira, seus vetores básicos ou suas interpretações locais de cima e para frente
também Esses são os
vetores direcionais que estão sendo usados para
determinar a direção em que
o personagem se
moverá quando a entrada for fornecida A direção é
então normalizada. seja, independentemente
de qualquer rotação ou inclinação parcial do
manípulo esquerdo, o comprimento do
vetor direcional se tornará um, resultando no
personagem sempre se
movendo a uma velocidade constante Isso é uma abreviatura para se
a direção não for zero. Em seguida, mova o personagem
ao longo dos eixos x e z pela direção
multiplicada pela velocidade Se a direção for zero, mova sua velocidade em direção a
zero a uma taxa de velocidade Finalmente, o método move
in slide é chamado para aplicar
sua velocidade e forças
externas durante
o Delta para descobrir onde o personagem
deveria estar nesse quadro Se tentarmos executar essa cena, nada será desenhado porque essa é a cena do personagem que não
tem câmera ou iluminação. Então, mude para a cena do jogo e execute esse cisne
para testar o jogo O personagem
cai imediatamente no chão. Isso ocorre porque o piso
não tem nenhuma colisão. Vamos adicionar um corpo estático de
três nós D à cena. Um corpo é um termo geral para qualquer objeto afetado
pela física ou por colisões Estática significa que é
imutável ou, nesse contexto, que não se moverá nem da física, como a
gravidade,
nem de colisões com outros corpos,
como nosso personagem A instância do piso mesh
deve ser filha
desse nó corporal estático ,
pois é o
componente visual dele. Em seguida, precisamos adicionar um nó D em
forma de colisão para dar
ao chão uma forma com qual ele colidirá
com outros corpos Essa forma será uma caixa. Expandindo o recurso de
formato de caixa, podemos atribuir a ele um comprimento e
largura correspondentes ao piso, -5 metros de comprimento e
largura e uma altura de zero Podemos renomear os nós para
refletir esse novo arranjo, forma que o nó
D do corpo estático três seja o piso e a instância da malha três D seja um filho usando
seu nome padrão Agora, quando executamos
a cena atual, a forma de colisão do personagem colidirá com
a
forma de colisão do chão,
impedindo O piso não reagirá
à colisão porque
é estático Cruzar as
teclas de seta moverá o corpo do personagem para três nós D e pressionar a barra de
espaço pulará. De volta ao script do personagem, os comentários nos dizem
que, como boa prática, devemos substituir as ações
integradas da interface ações de jogabilidade personalizadas,
que já temos. Então, podemos comentar
essas duas linhas, pressionando Control
ou o comando K. Mas a variável de direção
está sendo declarada aqui dentro da função de
processo físico Isso é chamado de
escopo da variável. Ele é declarado dentro
dessa função e , portanto, só existe
dentro dessa função. Como fizemos com
o script do player, podemos declarar essa
variável de direção na
parte superior do script fora do processo físico para expandir seu escopo para todo
o script Vamos defini-lo como privado,
prosseguindo com um sublinhado e definindo seu
tipo como vetor três,
uma estrutura contendo
três flutuadores para uma estrutura contendo
três flutuadores E também edite o nome
da variável dentro do processo
físico para combinar. Para mover o personagem,
vamos escrever uma nova função em nosso
script chamada move, qual aceitaremos um parâmetro chamado direção do
tipo vetor três. Esse parâmetro de direção é diferente da nossa variável de
direção, pois esta não
tem sublinhado e sua finalidade será armazenar
o valor que foi passado
para essa função de movimento, atribuindo-lhe o operador de
atribuição O nome dessa função move não tem um sublinhado, marcando-a como
pública, o
que significa que ela deve ser
acessível a outros scripts OK. Nosso
script de jogador chamará esse método para
mover o personagem com base na direção
de movimento recebida. Podemos alternar entre
scripts clicando neles na lista de scripts à esquerda
da visualização do script. Mudando para o script do jogador, podemos adicionar uma nova variável para manter o personagem
dos jogadores controlando. Este é um caractere
sublinhado de variável privada do tipo body three D. Adicionar na exportação à frente
da declaração da
variável permitirá que ela seja acessada por outras partes do editor
Gda,
ou seja, a guia inspetor Na cena do jogo, se
selecionarmos o nó do jogador, a
variável do personagem é listada
no inspetor e
podemos atribuir seu valor Como especificamos o tipo
da variável como corpo de
caractere três D, somente nós desse tipo ou nós que herdam desse
tipo podem ser atribuídos Atribua o
nó do personagem para ser
o valor da variável
do personagem no script dos nós do jogador, clicando em um
sinal e selecionando-o
na lista ou clicando e arrastando o
nó para o campo Em vez de imprimir o
valor da direção do movimento, queremos chamar o caractere do move e passar a
direção do movimento como argumento. Mas o tipo de
direção do movimento é um vetor dois, e o tipo do
parâmetro esperado pelo personagem se
move é um vetor três. Mesmo que fossem
do mesmo tipo, essa não seria a direção correta
para mover o jogador. Já que a direção em que
esperamos que o personagem se mova depende
da perspectiva da câmera. Vamos adicionar outra
variável exportada para a câmera. Em seguida, atribua seu valor. Vamos renomear
a direção do movimento para a direção de entrada e criar outra variável para a
direção do movimento do tipo vetor três Como convertemos a direção de
entrada bidimensional em
uma direção de
movimento tridimensional com base na
perspectiva da câmera? Multiplicamos a
base da câmera pela direção de entrada, semelhante à forma como foi
feito no código do modelo, mas faremos isso um
pouco melhor Primeiro, pegue a
direção certa da câmera, é a seta vermelha, que podemos acessar com o ponto base X da
câmera
e multiplicá-la pelo ponto x da direção de
entrada. Se o jogador pressionar para a direita, se moverá na direção direita da
câmera
e, se pressionar para a esquerda, direção de entrada
x
será negativa e direita multiplicada pelo
número negativo irá para Em seguida, adicione, usando o operador
mais igual, a
direção para frente da câmera, sua seta azul, base de pontos da
câmera multiplicada
pela direção de entrada ponto y, convertendo a
entrada vertical em movimento
nas frente
e para trás da câmera Mas a câmera está
girada no momento , pois está olhando para baixo. Portanto, se o jogador avançar, ele se moverá um pouco
para o chão, se movendo mais devagar do
que para a esquerda ou para a direita, e se movendo para trás, na verdade
estará tentando se mover no ar para
se aproximar da câmera Multiplicar o
vetor base pelo vetor 3101 removerá qualquer componente y, achatando-o no Em seguida, precisamos normalizar
o vetor achatado três, para que ele sempre
tenha um comprimento de
um e não afete a velocidade de movimento do
jogador Isso removerá qualquer efeito da rotação x ou z
nessas direções, mas a rotação y da câmera ainda
alterará os controles do
jogador. Agora, quando executamos
a cena atual, o script dos jogadores está
verificando a entrada, cada quadro. Se fornecermos uma
entrada, ela
verificará as direções para a direita
e para frente da câmera, as
nivelará no plano vermelho, as normalizará e dirá ao personagem em que direção se
mover com base na Então, o processo
físico do personagem moverá
nessa direção. Mover o personagem usando os vetores de
base achatados da câmera permite que o jogador
mantenha
o controle do personagem de qualquer ângulo da câmera, mesmo enquanto a câmera está se movendo ou também sendo
controlada pelo jogador ao mesmo tempo, já que
a direção do movimento
é calculada
dinamicamente
a é calculada
dinamicamente Separar as entradas
do jogador do personagem também é uma estrutura mais flexível, pois
o personagem que o jogador está controlando pode ser
facilmente alterado O script que diz ao personagem para
onde se mover pode ser facilmente controlado com a lógica do jogo,
em vez da entrada do jogador. Agora, o jogador pode
mover uma cápsula
pela nossa cena
e, na próxima lição, importaremos um modelo de personagem para
substituir a cápsula. Te vejo na próxima aula.
17. Importação: Olá, amigos.
Na lição anterior, costumávamos reproduzir
sua opinião para mover uma cápsula por
uma cena em três D. Nesta lição, substituiremos a cápsula por um modelo de
personagem. Vamos começar baixando
um pacote de ativos da Soto. Para este curso, estou
usando a versão gratuita do Kits character Pack Adventurers Ao clicar em baixar agora, você será solicitado a pagar, mas você pode clicar em Não, obrigado Basta me levar aos downloads. Opcionalmente, optamos por
apoiar o artista dando qualquer quantia em dinheiro
que você achar apropriada Também existem versões pagas
desses pacotes de ativos, que
incluem mais conteúdo Eu recomendo
experimentá-los gratuitamente e pagar pelas versões extras
se você gostar do trabalho deles. Em seguida, clique em baixar
para baixar os ativos. Enquanto aguardamos a conclusão do
download, vamos voltar à página do
ativo e dar uma olhada no que está incluído
nesse pacote de ativos. Existem quatro
personagens, todos com uma variedade de armas
e acessórios, e cada personagem
é animado com uma grande variedade de animações para usarmos em um formato
consistente Os modelos são
eficientes para uso em jogos
móveis e são compatíveis
com o motor Cada. Esses ativos são gratuitos para uso
pessoal ou comercial sob a licença Creative
Common Zero. Certifique-se de verificar o
licenciamento dos ativos que você baixa antes de
usá-los em seus projetos Em alguns casos, a atribuição
pode ser necessária
ou o uso em projetos comerciais
pode ser totalmente proibido Quando o download estiver concluído, extraia o conteúdo
da pasta compactada em algum lugar do disco rígido Em seguida, abra a pasta
para ver o que há nela. Queremos usar os
personagens e
os modelos estão disponíveis
em dois formatos diferentes. Para este curso,
usarei os arquivos GLTF. Importar os ativos
para o Coda é tão
simples quanto clicar e
arrastá-los para a janela do editor Nossa pasta de recursos
está começando a ficar um pouco confusa, então
vamos organizá-la Clique com o botão direito na pasta
raiz do recurso e crie uma nova pasta. Vamos chamar essa pasta de ativos
importados. Em seguida, crie outra pasta dentro dessa pasta
chamada de caracteres. Agrupe, selecione e arraste os
ativos de personagens importados para essa nova pasta. Ok. Também podemos criar uma nova pasta na pasta raiz de recursos para armazenar scripts e outra para cenas. Os scripts têm um ícone de engrenagem
e a extensão do GD. Enquanto as cenas têm o ícone do tabuleiro e sua extensão é TCN Você pode organizar seus
recursos, no entanto, faz sentido para você e se
adapta melhor ao seu fluxo de trabalho Antes de trabalharmos com
os ativos importados, precisamos editar algumas configurações de
importação. Selecione qualquer um dos arquivos GLB de
caracteres na guia do sistema de arquivos Em seguida, mude o documento
que está
exibindo atualmente a
guia da cena para a guia de importação. Aqui podemos editar
como o editor God interpreta os arquivos e
gera os ativos importados A maioria dessas configurações é
adequada para nossos propósitos. Primeiro, vamos adicionar um tipo raiz de corpo de caractere três
D. Por padrão, o caractere
terá sido importado como um nó três D. Mas queremos que nó
raiz do
nosso personagem seja um corpo de personagem três D para ser compatível
com nosso script de personagem. Se alterarmos alguma
das configurações, elas não serão atualizadas,
a menos que reimportemos o ativo. Em seguida, clique no botão
Avançado. A janela de
configurações avançadas de importação é aberta e podemos ver uma prévia
da aparência do ativo
importado. Você pode ampliar e reduzir o zoom com
a roda do mouse ou clicar e arrastar para girar o
modelo e obter uma melhor visualização À esquerda está a árvore de cenas que será gerada
por esse recurso, incluindo um esqueleto, ossos, malhas e um reprodutor de animação
com todas as Antes de trabalharmos com
esse modelo de personagem, precisamos permitir que certas
animações se repitam. Vamos começar com
a animação ociosa. Com a
animação inativa selecionada, podemos visualizar sua
aparência com o botão play na
parte inferior da janela Mas ele só toca
uma vez e depois para, o que é exatamente o problema. No lado direito, podemos alterar as configurações
de importação
da animação,
alterando o modo de loop para linear. Agora, quando clicarmos em reproduzir, quando
a animação terminar, ela retornará ao
início e será reproduzida novamente. Em vez disso, o
pingue-pongue reproduzirá a animação ao
contrário para retornar ao início e avançar novamente depois disso. Vamos configurá-lo como
linear. Em seguida, repita o procedimento para todas as animações
dessa lista que contenham a palavra ocioso,
bloqueio ou execução Embora não seja abordado
neste curso, você também pode permitir o
loop para atirar,
girar, bloquear
e lançar feitiços Quando terminar, clique
no botão de reimportação para
reimportar os ativos com as configurações de animação
atualizadas. Você precisará repetir
esse processo para os outros personagens antes de
poder usá-los. Mude para a cena do personagem. Clique e arraste o ativo do
personagem até o nó raiz
da cena do personagem para adicioná-lo à árvore da cena. Vamos ativar a iluminação de visualização para que possamos ver
melhor nosso personagem
importado e excluir o nó da instância da
malha desenha a malha da cápsula. O nó bárbaro
é apenas um nó, não a grande árvore de nós que
vimos nas configurações de importação, e tem o ícone de
claquete, o que
implica que essa é uma
instância Como se tivéssemos criado a
cena do personagem a partir da cena do jogo. Podemos fazer isso ao contrário. Clique com o botão direito do mouse no Bárbaro
e selecione Tornar Local. Isso quebrará o
vínculo que esse nó tem com o ativo importado e o tornará uma versão
exclusiva que só
existe nesta cena. E agora podemos ver todos os
seus nós secundários. As animações estão
contidas no nó do
reprodutor de animação Vamos derrubar o nó da plataforma
por enquanto para esconder a maior parte dele. Em seguida, queremos que o
Bárbaro seja o
nó raiz da cena Podemos clicar com o botão direito do mouse novamente
e selecionar criar raiz vista para organizar a árvore da
cena para que ela se torne o novo nó raiz da
cena. Em seguida, vamos clicar e
arrastar o nó D da forma
de colisão para
representá-lo novamente para o nó Bárbaro Torne essa a
forma de colisão do Bárbaro e exclua o nó D original do corpo do
personagem pois agora ele é redundante No entanto, ainda precisamos de um script de
caracteres anexado
ao nó raiz. Também podemos adicionar isso
clicando e
arrastando-o para o nó raiz Nossa árvore de cenas ainda parece
a mesma de antes. Somente o nó D da
instância de malha três agora
é substituído pelo equipamento
do personagem, e há um nó de player de
animação Nosso personagem parece
estar
segurando muitos itens
em suas mãos. Expanda o nó da plataforma
para ver seus filhos. Podemos esconder qualquer um dos
itens que estão nas mãos do personagem clicando no ícone
ao lado deles. Também podemos esconder o chapéu e o
p do
personagem para qualquer um dos personagens que não
seja o ladino O ladino tem um modelo totalmente
diferente para quando o capuz está levantado, já que o
cabelo também é removido Dependendo da versão do Coda ou dos ativos que você está usando, pode
haver um ícone X vermelho mostrando que há um
problema com esse ativo Selecionando-a e
examinando as configurações de importação, podemos alterar a versão de
nomenclatura do GLTF para 4.1 ou anterior e reimportar
o ativo para corrigir esse problema Quando terminar, derrube
a plataforma mais uma vez. Se salvarmos a cena do
personagem no menu
da cena ou pressionarmos o controle S ou o comando S. Em seguida, mude para
a cena do jogo. Podemos ver que o personagem
em nossa cena de jogo
foi atualizado
ao executar esta cena, podemos movê-lo exatamente como antes, mas ele está se
movendo desajeitadamente nos Agora temos o modelo do personagem importado para o nosso projeto. Na próxima lição,
animaremos nosso personagem andando. Te vejo na próxima aula.
18. KayKit Update: Olá, amigos. O pacote de ativos de personagens do KayKit usado neste curso
foi atualizado, separando os
modelos de personagens das animações, que é mais flexível
e eficiente para nós, mas requer algumas etapas extras Primeiro, você pode importar os modelos de personagens para
o motor da mesma forma. Basta clicar e
arrastá-los para a janela do editor. As animações e os itens retidos agora
estão em pastas separadas, então eles também precisam ser importados. É uma boa ideia
importá-los para pastas separadas. Selecione as animações importadas e, em
seguida, alterne a
guia da cena para a guia Importar No menu suspenso Importar como, altere a cena para a biblioteca de
animação clique no botão
reimportar Em seguida, clique no botão
Avançado. Nessa janela, clique
no botão Ações e selecione
definir caminhos de salvamento da animação. Você pode selecionar essa pasta ou criar uma nova
para cada biblioteca. Clique em Selecionar pasta
e reimportar para importar todas as animações
como ativos individuais do projeto Precisamos que as
animações individuais sejam
importadas para o mecanismo para poder editá-las e adicionar
nossas próprias faixas, e precisamos que as bibliotecas
possam adicioná-las ao
nosso reprodutor de animação Com as animações salvas
como recursos do projeto, também
podemos definir o modo de loop com
um pouco mais de facilidade Qualquer animação que
contenha inatividade ou seja nomeada no
tempo presente contínuo deve ser repetida Para os modelos de personagens, precisamos apenas alterar o tipo raiz para o corpo do
personagem três D. Não há necessidade alterar nenhuma das configurações
avançadas de importação. Podemos arrastar
esse modelo para
uma cena em três D
e torná-lo local, o que corta sua conexão com
o ativo importado Ou podemos criar uma
nova cena herdada do modelo
de
personagem importado Ao usar uma cena herdada, sua capacidade de editar o modelo
importado será limitada De qualquer forma, podemos adicionar um
nó de player de animação à cena. No painel de animação, clique no botão Animação e selecione gerenciar animações. Clique no botão Carregar
biblioteca selecione as
bibliotecas de animação que foram importadas. Isso adicionará todas
as animações incluídas
nessa biblioteca Todas essas animações
agora funcionarão com o modelo do
personagem Se suas animações não conseguirem encontrar o esqueleto do personagem
para animá-lo, certifique-se de que a estrutura da cena do personagem
corresponda ao caminho do nó nas faixas de animação, com o nó médio da plataforma como filho direto do nó raiz do
personagem Na árvore de animação, ao adicionar animações
que fazem parte de
uma biblioteca de animação a um recurso de máquina de
estado, o nome da biblioteca de animação será incluído
no nome dos nós Mas podemos alterá-lo facilmente
para facilitar a leitura. As animações de combate não estão mais incluídas
neste pacote de ativos, mas ainda estão
disponíveis gratuitamente Você só precisa baixar o pacote de animações de
personagens separadamente. Em seguida, siga as mesmas etapas
para importar essas animações como bibliotecas e adicioná-las ao nó
do reprodutor de animação Agora que todos os
seus personagens
e animações foram importados corretamente, você pode continuar
com o resto
do curso.
Nos vemos no próximo vídeo.
19. Caminhada: Olá, amigos.
Na lição anterior, importamos
modelos de personagens para o Cada. Nesta lição, vamos animar o personagem para
percorrer nossa cena Vamos começar movendo
a câmera um pouco para trás já que o personagem é
maior do que a cápsula. Os movimentos dos personagens
são muito rígidos. O personagem está se movendo a toda velocidade ou não está se movendo. Isso não parece muito bom e não é como as coisas
realmente se movem. Deve haver
aceleração até a velocidade máxima e
desaceleração Abrindo o script,
podemos ver que a velocidade do personagem é
declarada como uma constante. Em vez disso, vamos declarar algumas variáveis privadas
exportadas para definir como nosso
personagem Começando com
a velocidade de caminhada medida em unidades por segundo, que é melhor
representada como um flutuador Podemos atribuir às variáveis
um valor padrão usando o operador de atribuição
na mesma linha quando elas são
declaradas. Vou configurá-lo para um. Também queremos valores de aceleração
e desaceleração medidos em unidades
por segundo Também tipos flutuantes. Considere a rapidez com
que você passaria de ficar ocioso para
caminhar a toda velocidade Cerca de meio segundo
parece razoável, o que é uma aceleração do
dobro da velocidade de caminhada. E também a rapidez com que
você pararia completamente ao
caminhar a toda velocidade. Isso geralmente é mais rápido do que aceleração, então
vou fazer com que seja quatro. Selecionando o nó raiz
dos Bárbaros, podemos ver as variáveis
exportadas disponíveis para serem editadas
na guia do inspetor edição desses números
substituirá os valores padrão
fornecidos no script Mas pressionar o botão de reset os
retornará
aos valores padrão. Isso nos permite
experimentar facilmente valores diferentes e também oferece a possibilidade de personagens
diferentes terem velocidades de movimento
diferentes. Para facilitar as coisas, podemos separar a velocidade dos
caracteres no plano x z
da
velocidade ao longo do eixo y, o que nos permite isolar
ajustes na velocidade de
movimento de coisas
como Vamos declarar outra
variável privada X Z velocidade do tipo vetor três No início do processo
físico, podemos definir o valor da velocidade
x como um
novo vetor três, copiando a
velocidade do personagem nos eixos x e z, enquanto definimos o valor
y Podemos então fazer nossos
ajustes na velocidade
X Z dos caracteres aqui sem preocupar com o impacto
de sua velocidade y. Então, no final do
processo de física , antes do movimento deslizar, podemos definir a velocidade dos
caracteres para ser os
valores ajustados para X e Z, mas o
mesmo valor que era para y. Esse método também
terá benefícios adicionais posteriormente. OK. Em seguida, precisaremos
editar esse bloco de código que move
o personagem. A declaração está dividindo
isso em dois casos. Se o jogador está fornecendo uma direção de
movimento ou não. Em vez de dividir a velocidade em componentes x e z, já que removemos a velocidade y, podemos simplesmente editar a velocidade x
z diretamente aqui Se o jogador estiver fornecendo
uma direção de movimento, devemos atribuir a
velocidade x z para se mover em direção multiplicada pela
velocidade de caminhada a uma taxa de
aceleração vezes Isso pegará qualquer velocidade
atual ao longo do plano XZ e a moverá em direção
à velocidade de caminhada
na direção em que o jogador deseja ir com
uma taxa de aceleração Já que Delta é a
quantidade de tempo que passou desde
o último quadro, geralmente um 60º de segundo Ele ajustará a aceleração
para corresponder à taxa de quadros
, fazendo com que o personagem acelere e se mova
nas velocidades especificadas, independentemente da configuração da taxa de quadros do
jogo Da mesma forma, quando nenhuma entrada de
movimento é fornecida, o personagem deve
desacelerar até uma velocidade
zero a uma taxa de desaceleração
multiplicada zero a uma taxa de desaceleração
multiplicada Podemos excluir a
constante de velocidade original agora, pois ela não
é mais usada. Vamos mudar para a cena do jogo e tentar mover o
personagem agora. Agora, o personagem
acelera até a velocidade
de caminhada e
desacelera De volta à cena do personagem, podemos mudar para a visualização em
três D para que possamos
ver o personagem. Selecione o nó
do player de animação e a guia de animação será aberta
na parte inferior da janela. A animação
atualmente visualizada é um golpe de ataque masculino com uma mão, e o modelo do personagem
assumiu o primeiro quadro
da animação. Podemos pressionar o
botão play na parte superior
da guia de animação para
visualizar a animação. Expandindo a guia de animação e percorrendo as faixas de
animação, podemos ver que cada osso tem quadro-chave para produzir uma Use o controle deslizante Zoom para ajustar a quantidade de
tempo exibida
na guia Animação e você poderá ver cada quadro-chave individual Usando o menu suspenso,
podemos selecionar qualquer uma
das animações que foram
importadas, inclusive ociosas E ao visualizar essa animação, já que definimos as configurações de importação, a animação será repetida Portanto, o nó do reprodutor de animação pode reproduzir qualquer uma
dessas animações. Só precisamos controlar
qual animação está sendo reproduzida. Você pode fazer isso
por meio de um script, mas o código será
muito longo e terá que
acomodar muitas possibilidades. A melhor maneira de controlar
qual animação está sendo reproduzida é usando
outro nó, que podemos adicionar à
cena do nosso personagem, uma árvore de animação. A árvore de animação
precisa ser informada sobre qual player de animação
ela está controlando. Então, clicando no
campo atribuído ao lado do Anim player, podemos selecionar o nó do
player de animação na lista Em seguida, precisamos fornecer um
recurso para esse nó, assim como fizemos com as instâncias de malha e
as formas de colisão Esse recurso é chamado de
máquina de estado. Ao criar a
máquina de estado, abriremos a guia da árvore de
animação na
parte inferior da janela do editor. Podemos deslocar a janela de visualização dessa janela arrastando com
a roda do mouse pressionada A máquina de estado rastreará em
que estado o personagem
está e reproduzirá a animação correta
para esse estado ou até mesmo mesclará várias
animações Nós simplesmente precisamos dizer à máquina de
estado quais são
esses estados e também como e quando o personagem fará a
transição entre os estados. Por enquanto, teremos
apenas um estado, que mesclará as animações de
inatividade e caminhada Se o personagem começar a
andar do modo inativo, ele não deve fazer a transição
imediata do inativo para o andar, nem deve voltar imediatamente
quando parar Sem falar que o
jogador poderá inclinar levemente o
manípulo esquerdo para
se mover mais devagar, se quiser Precisamos que as animações de marcha lenta e de
caminhada se
misturem dependendo da velocidade de movimento do
personagem Isso pode ser conseguido
com um espaço de mesclagem. Clicando com o botão direito do mouse no espaço vazio, adicione um
espaço de mesclagem unidimensional à máquina de estados e chame-o de locomoção Em seguida, clique na ferramenta
Connect Nodes. Clique e arraste do
início até a locomoção. Tornando esse o estado
padrão em que o personagem começará
quando rodarmos o jogo. Volte para selecionar
e mover nós. Em seguida, clique no lápis para editar o espaço de mistura da locomoção. Um
espaço de mesclagem unidimensional tem um eixo, que é exibido
horizontalmente variando de menos um a positivo com
um valor nomeado Se considerarmos que essa é a
velocidade do caractere, podemos renomeá-la para velocidade e definir seu valor
mínimo zero e o
valor máximo como um Um, nesse caso,
deve ser considerado 100% de velocidade, não uma velocidade de uma
unidade por segundo. Podemos adicionar animações ao espaço de mesclagem com
a ferramenta de criação de pontos Clicando em zero. Podemos adicionar a animação ociosa. Uma, a animação ambulante. Clique em definir a
posição de mesclagem dentro do espaço. Em seguida, clique em qualquer lugar
ao longo do eixo para ver como a animação
fica nessa velocidade. Você também pode clicar e
arrastar para ver como a alteração da velocidade ao longo do tempo combina
as animações. OK. Agora, tudo o que precisamos fazer é ter
o script do personagem, dizer à árvore de animação
a velocidade do personagem. Os nós podem se
comunicar facilmente
atribuindo-os a variáveis, e podemos fazer tudo isso em
uma linha do nosso script usando at on ready no
início da declaração Vamos chamar essa variável, sublinhar a animação
do tipo árvore de animação e atribuir valor a ela Usando o cifrão,
podemos então especificar um caminho de nó para acessar qualquer
nó na árvore de cena, partir desse nó ao qual
o script está anexado. Se o nó que estamos tentando acessar for filho desse, simplesmente
especificaremos
o nome do nó. de uma sequência de
nós pode ser feito
separando os nomes dos nós
com uma barra Se o nome do
nó contiver espaços, você poderá colocar o
caminho do nó entre aspas Se você não tiver certeza
sobre o caminho do nó, clique em qualquer nó na árvore
da cena e
selecione Copiar caminho do nó Em seguida, cole-o como texto. Nosso script agora tem uma referência ao nó da árvore de animação. Tudo o que precisamos fazer é definir a posição do espaço de mesclagem após nossos cálculos de velocidade XZ Usando a variável,
podemos acessar o método set para definir
qualquer propriedade que quisermos. A propriedade que queremos definir
é definida como uma string, representando um caminho
para a propriedade, usando o mesmo formato
do caminho do nó. Podemos usar as sugestões
para preencher automaticamente esse parâmetro, procurando a posição sangrada de nossos
estados de locomoção Assim como no caminho do nó, selecionando a
árvore de animação na árvore da cena, podemos expandir os parâmetros, locomoção e copiar
o caminho da propriedade Em seguida, cole-o como texto. Em seguida, especifique o valor para o
qual
queremos definir essa propriedade, que será um valor de
0 a 1 representando a porcentagem da velocidade
máxima
do personagem na qual
ele está se movendo Como a velocidade D
é um vetor, podemos usar o
método do comprimento para
saber exatamente a velocidade com que o personagem está
se movendo ao longo do plano D. Em seguida, divida isso pela
velocidade de caminhada para convertê-lo em um número 0-1 Vamos ver como isso fica
quando executamos a cena do jogo. Agora, o personagem mistura a animação de marcha lenta e a de caminhada em relação à velocidade
no plano x d, mas não está girando para
coincidir com a direção em
que está se Experimente
experimentar valores diferentes para a velocidade de
caminhada,
aceleração e desaceleração do personagem para ver como ele se sente Na próxima lição,
adicionaremos rotações e saltos. Te vejo na próxima aula. OK.
20. Rotação: Olá, amigos.
Na lição anterior, animamos a locomoção do nosso
personagem Nesta lição, rotacionaremos modelo
do personagem para olhar na direção em
que ele está andando Começando no script do
personagem, se o jogador estiver fornecendo informações sobre a direção do
movimento, podemos simplesmente
dizer a esse nó que
observe sua posição atual
mais a direção. Isso girará o
corpo do personagem em três nós D para que seu vetor de base
direta aponte diretamente para
essas coordenadas Como restringimos a
direção ao referido plano x, isso resultará em apenas
girar o personagem em
torno do eixo y para ficar voltado
para a direção que o
jogador deseja se mover Mas a rotação
será imediata e apontará o personagem
na direção oposta. Como Gudo inverte o eixo Z, podemos corrigir isso simplesmente
mudando a direção positiva
para a direção negativa Além disso, se tivermos algum
nodo infantil do personagem na
cena do jogo, como a câmera, por exemplo, ele também
será movido e girado, o
que não é o que queremos A solução não
será suficiente. OK. Na cena do personagem, podemos ver que todos os componentes
visuais
do personagem são filhos
de um nó três D chamado rig Selecionando rig na árvore da cena, podemos editar sua transformação, clicando e arrastando
a
alça deslizante de rotação y para girar o
modelo do personagem em torno do Dessa forma, o modelo do
personagem pode ser girado independentemente do corpo
do personagem em três D, para que isso não afete nenhuma outra
criança na cena do jogo No script do personagem, assim como fizemos com
a árvore de animação, podemos usar at on ready para armazenar uma referência ao nó da plataforma
em uma variável privada Então, quando adicionamos
velocidade de movimento ao personagem, também
podemos dizer ao equipamento que
veja para onde está indo O personagem agora está
voltado para a direção que está se movendo sem
afetar outros nós. Mas a rotação imediata pode não ser o que
estamos procurando. Então, vamos fazer o personagem girar um pouco em cada quadro Podemos definir a velocidade de
rotação de um personagem como uma variável privada exportada
e atribuir a ela um valor padrão Os mecanismos de jogo normalmente calculam as rotações em radianos,
não Se você não estiver familiarizado
com radianos, um círculo completo de 360
graus é Pi vezes 2 radianos Há também outra constante
matemática chamada T, que é Pi vezes dois. Mas se considerarmos o caso de
uso desse valor, estamos preocupados apenas
com
a rapidez com que o personagem girará
até 180 graus. Caso contrário, eles simplesmente
girariam na direção
oposta. Assim, podemos definir o valor das
variáveis exportadas como
um múltiplo de Pi ou quantas meias rotações o personagem pode
fazer em 1 segundo O invertido nos
dirá quanto tempo o personagem levará
para girar até a metade Como alternativa, você pode definir a velocidade de
rotação do
seu personagem em graus e usar a função de grau de
brilho para convertê-la quando o jogo começar Vou usar o
método Pi e dizer que meu personagem deve ser capaz se virar em meio segundo,
tornando a velocidade de rotação
Pi vezes duas. OK. No processo de física, se o personagem estiver
fornecendo informações de movimento, primeiro
precisamos descobrir que ângulo estamos girando dois Chamaremos isso
de ângulo alvo. Podemos encontrar nosso
ângulo alvo usando trigonometria. Se o ângulo alvo for teta,
que, neste caso, representa a rotação y de um objeto voltado
na direção, podemos encontrá-lo usando a função tangente
inversa Às duas. Isso usa
dois argumentos flutuantes, que são valores de ponto de direção x
e ponto de direção z. Agora, o ângulo alvo
mantém o valor para o qual
queremos
mover gradualmente nossa rotação y. Em seguida, precisamos da diferença
entre esses dois ângulos, expressa como um número entre Pi
negativo e Pi positivo. Nos dizendo até onde precisamos
girar e em qual direção Subtrair nossa rotação
y atual do ângulo
alvo fornecerá a diferença entre
os dois Para garantir que o
personagem gire apenas ao longo
do caminho mais curto, envolvemos esse resultado
usando a função rap f, garantindo que o
resultado esteja sempre entre
o valor de
Pi negativo e Pi positivo Agora temos todos
os números mágicos, precisamos girar o personagem,
mas como podemos usá-los. Podemos determinar
a direção
da rotação usando uma
função chamada seno, passando a
diferença do ângulo como argumento Isso retorna menos um se o número for negativo, zero, se for zero, e positivo, se for
um número positivo. Se multiplicarmos isso pelo
caractere da velocidade de rotação e Delta,
saberemos o quanto eles podem girar e em qual
direção em um único quadro Adicionando isso à rotação em y, rotacionaremos o personagem, mas também ultrapassaremos
o ângulo alvo Então, adicionando uma função de fixação, podemos restringir o valor da velocidade de
rotação vezes Delta para ficar apenas entre zero e o valor absoluto da diferença
do ângulo O valor absoluto é
com o seno removido, então um número negativo se
tornará positivo Em seguida, multiplique pelo seno para garantir que o personagem gire
na direção correta Isso impedirá que o
personagem ultrapasse a rotação e
pare no ângulo alvo Para tornar isso mais eficiente, já que estamos
usando o ângulo alvo apenas uma vez no cálculo
da diferença de ângulo, podemos copiar e colar
seu cálculo na mesma linha e
ter uma variável a menos. E como esse processo é
executado 60 vezes por segundo, ele não deve
declarar nenhuma variável Então, vamos mover a
declaração da variável para o
topo do script. Por fim, precisamos remover
a linha de visualização abaixo, pois
ela não é mais relevante Agora, o personagem gira gradualmente para ficar de frente para a direção de entrada do
jogador E podemos alterar a rapidez com
que eles giram no inspetor. Em seguida, vamos adicionar um botão de
execução que o jogador pode
segurar para se mover mais rápido. Abra as configurações do projeto e vá para a guia do mapa de entrada. Adicione uma ação de execução. Vou usar a tecla shift
ou o botão esquerdo. No script do player, podemos reagir aos eventos individuais de pressionamento do
botão com mais eficiência do que
com as entradas de movimento usando uma função diferente, a entrada de
sublinhado Essa função
só é chamada durante quadros quando há um evento
de entrada acontecendo. Em vez de Delta, o parâmetro para entrada é um evento de entrada, que é uma estrutura contendo informações sobre o
evento que aconteceu. Dentro dessa função,
podemos então verificar essa estrutura para ver se
o botão de execução foi pressionado. Se foi, podemos mandar
o personagem correr. OK. Da mesma forma, também podemos verificar se o
botão de execução foi liberado. E se sim, diga ao
personagem que ande. No
script do personagem, podemos adicionar uma velocidade de corrida para
acompanhar a velocidade de caminhada. Em seguida, adicione outra variável
privada não exportada chamada
velocidade de movimento com um
valor padrão de velocidade de caminhada Tudo o que precisamos fazer
nas funções de caminhada e corrida é definir o valor da velocidade de movimento como sendo a velocidade de caminhada ou
corrida de acordo. Em seguida, use a velocidade de movimento
em nossos cálculos de velocidade. No entanto, ao determinar
a posição de mesclagem para as animações de
locomoção do personagem, usaremos a Selecionando a árvore de
animação do personagem, podemos então editar o espaço de mistura de
locomoção. Agora, se considerarmos que
um valor de velocidade de um é o personagem
correndo a toda velocidade. Podemos usar a ferramenta selecionar
e mover pontos para mover nossa animação de caminhada para
algum lugar mais próximo do meio do eixo e adicionar outra animação
na extrema direita para nossa animação em execução,
alternando para a ferramenta de criação de
pontos ou clicando com o botão direito do mouse. Em qualquer valor de velocidade, o espaço de mesclagem
mesclará a
animação mais próxima à esquerda e à direita,
aplicando pesos
à animação com
base na proximidade De volta à cena do jogo,
antes de testar uma corrida, talvez
queiramos dar mais espaço ao nosso
personagem. Então, selecionando o piso, podemos editar o tamanho
do piso e de todos os seus filhos rapidamente
aumentando sua escala. Agora, quando executamos a cena do jogo, o personagem pode não apenas
andar pela cena, mas também correr
pressionando o botão de execução. Dependendo dos valores usados para aceleração
versus desaceleração, pode parecer
que o
personagem desliza por aí lutando para
redirecionar Se dermos uma olhada
no processo físico, a afirmação divide
isso em se o jogador está fornecendo informações de
movimento ou não. Podemos detalhar isso ainda mais
para considerar se o jogador quer se mover
na mesma direção
do personagem ou não. Para verificar se a direção que
o jogador quer ir é semelhante à direção em que
o personagem já está se movendo. Podemos usar um pouco de matemática vetorial. Um produto escalar é uma forma de multiplicar dois vetores
que
resultará em um número representando quão semelhantes ou diferentes
esses O produto escalar de dois vetores, ambos apontando na mesma
direção, será um, e em direções opostas,
menos um Se os dois vetores
formarem um ângulo reto, eles são perpendiculares e seu produto
escalar será zero Assim, podemos verificar
se os resultados
do produto escalar são
maiores ou iguais a zero para saber se o caractere deve estar acelerando
na direção desejada Como o jogador
deseja se mover
mais ou menos em uma direção semelhante à de onde o personagem já
está se movendo, caso contrário, o
produto escalar é negativo, o
que significa que o
jogador está tentando se mover mais ou menos
na direção oposta. Devemos dizer ao personagem que
desacelere , não acelere Agora, a
desaceleração do personagem pode ser aplicada quando o jogador muda de direção
repentinamente Agora temos o
personagem girando e correndo pela cena Na próxima lição,
adicionaremos animações de salto. Te vejo na próxima aula.
21. Salto: Olá, amigos. Na lição anterior, giramos
o personagem
para ficar voltado para a direção em
que ele está se movendo Nesta lição,
adicionaremos animações de salto. Vamos começar ativando as sombras
da luz solar de nossas cenas. Selecione os três nós D da
luz direcional, expanda a seção de sombra
e ative o botão de ativação, caso ainda não esteja ligado Isso nos dará um
pouco mais
de perspectiva de quão alto o
personagem está pulando Na cena do personagem, se
selecionarmos o nó do
player de animação, a guia de animação deverá abrir na parte inferior
da janela. Você também pode abri-lo manualmente clicando na animação aqui. Examinando a
lista de animações, podemos ver que existem várias animações de
salto diferentes Se selecionarmos qualquer uma dessas
animações, elas não serão reproduzidas. Isso ocorre porque
a árvore de animação está sob controle total no momento. Selecione a
árvore de animação e clique
no botão ativo para
desativá-la enquanto exploramos
as animações de salto Voltando ao player de
animação, abra a animação curta ou
longa completa do salto e pressione play. Essas animações
não são muito flexíveis. Queremos que nossos saltos
sejam mais dinâmicos. Abrindo a animação de
início de salto, podemos ver que essa
animação é o que deve acontecer quando o jogador
pressiona o botão de salto Aumente o zoom para que você possa ver
os quadros-chave da animação. Como há 30
quadros por segundo, eles são espaçados 0,033 por
3 segundos. Podemos definir o snap com
esse valor para permitir que examinemos cada
quadro individual usando a linha Se mudarmos nossa visualização
para a visão ortogonal esquerda ou direita e ampliarmos os
pés do personagem Observe que os
pés do personagem permanecem no chão por 0,3 segundos inteiros
da animação. Isso é importante, pois
se adicionarmos velocidade
ao personagem no início
da animação, ele
parecerá errado Isso é seguido
pela animação jump idle, que deve ser repetida até que o
personagem toque o chão O que deve então levar
ao salto e à animação. Dividir essas animações
dessa forma permite que o salto tenha qualquer duração e ainda tenha uma boa aparência
para o jogador Observe também que o
quadro final da
animação de início de salto é idêntico
ao primeiro quadro da animação de
salto inativo Isso também vale para
o quadro final do jump idle e o
primeiro quadro do jump land, mas
é menos importante que o
momento em que o personagem aterrisse
possa acontecer a qualquer momento Selecionando o nó da árvore de
animação, podemos ativá-lo novamente
no inspetor e, em seguida, dar
uma olhada na máquina de estado Podemos adicionar as três
animações de salto à máquina de estado Eu gostaria de colocá-los acima
do espaço de mistura de locomoção, dispostos na mesma sequência da esquerda para a direita em
que serão usados Adicione uma conexão do
jump start ao jump idle. Em seguida, olhe no painel do
inspetor. Essas são as propriedades
da transição entre estados. Queremos que essas duas
animações sejam reproduzidas em sequência
direta, já que o último e o primeiro
quadro são idênticos Quando a
animação de início de salto estiver concluída, basta
mudar imediatamente para pular em marcha lenta Expandindo a seção de comutação, podemos definir o
modo de comutação para no final. O ícone de seta na
máquina de estado mudará para indicar que essa
transição acontecerá no final
da animação. Adicionando a transição de
jump idle para jump land. Queremos que essa
transição aconteça imediatamente quando o
personagem tocar o chão O que significa que não saberemos
exatamente em que quadro jump idle está
quando isso acontecer Para evitar contrações estranhas, podemos cruzar as duas
animações em
uma breve janela, como
um décimo de segundo, apenas o tempo suficiente para Quanto ao momento em que a troca acontece, queremos que seja imediata, mas sob uma condição específica, quando o personagem
toca o chão Expandindo a seção avançada, podemos escrever qualquer condição ou combinação de
condições que desejarmos
na área de texto da expressão para controlar quando essa
transição acontecerá. Como no script do personagem, podemos usar o
método embutido de três nós D no chão para verificar se o personagem
está tocando o chão Quando isso se tornar verdade, a transição
começará, passando de jump Idle para jump land por
um décimo de segundo e, em
seguida, reproduzirá o
restante No entanto, para usar esse recurso, precisamos selecionar novamente o nó da árvore de
animação e alterar sua propriedade de nó
base de expressão avançada Esse é o nó no qual a expressão
avançada
será chamada, e queremos usar
o nó D do corpo do personagem três para verificar se
o valor de está no chão. Em seguida, em uma transição da terra de
salto para a locomoção. Queremos permitir que
essa animação seja reproduzida em
sua totalidade antes de voltar à locomoção. Portanto, o modo switch
deve estar encerrado. Já o quadro final do jump land é o mesmo
do primeiro quadro de inatividade Se o personagem pousar
enquanto estiver em movimento, não queremos
mudar imediatamente de pular terra
para caminhar ou correr. Portanto, também podemos adicionar uma cruz triste a essa transição para
misturá-la de forma mais suave. Adicionando uma transição da
locomoção para o salto, isso será acionado quando o
jogador pressiona um botão Expanda a
seção avançada e altere o modo avançado
de automático para ativado. Isso torna a seta verde
cinza na máquina de estado, já que a transição
não é mais automática. Isso nos permitirá
acionar manualmente essa transição por meio do script de nosso
personagem posteriormente. Como não sabemos o que o espaço de combinação de
locomoções está fazendo em um momento aleatório quando o jogador pressiona
o botão de pular, adicionar um breve crossfade a essa animação também ajudará a
facilitar a transição Por fim, as animações jump idle e jump
land também podem ser úteis se
o jogador sair de uma saliência em vez de pular Adicionar uma transição
diretamente da locomoção para o modo de marcha lenta
acomodará Podemos definir a
expressão avançada para essa transição como
se o personagem
não estiver no chão. E cruze o desvanecimento da locomoção para o salto em marcha lenta para facilitar a Mas e se as condições de
transição da locomoção para o
salto inicial ou o salto em marcha lenta forem verdadeiras ao
mesmo tempo O personagem
saiu do chão e o jogador pressionou o botão de
pular neste quadro. Se você quiser controlar
qual transição tem prioridade nesse caso, você pode selecionar cada transição e definir sua configuração de prioridade. A dica da ferramenta nos diz
que números mais baixos têm prioridade quando várias
transições são possíveis darei prioridade
ao início inicial Nesse caso, darei prioridade
ao início inicial, definindo sua prioridade de
transição como zero. Podemos visualizar a aparência dessas
animações, transições e teclas cruzadas
clicando no botão play em
qualquer estado para forçar a máquina de estado a entrar nesse estado Observe que esse personagem
está flutuando no espaço
vazio e
, portanto, não está no chão. Nosso script de personagem ainda
está usando o código básico do modelo para
fazer o personagem pular. Devemos atualizar
isso para corresponder à forma como
lidamos com as entradas para
caminhar e correr Abra as configurações do projeto e alternando para a guia do mapa de entrada, podemos adicionar uma ação para pular. Vou usar a barra de espaço e botão
inferior do meu controle como eventos para a ação de salto Ok. Fechando as configurações do projeto e abrindo o script do player, podemos adicionar outra condição à nossa declaração para verificar se
o botão de pular foi pressionado. E se sim, diga ao
personagem para pular. Passando para o script do
personagem, podemos adicionar uma função pública de
salto. Ok. Antes de escrevermos
a função de salto, precisamos acessar
a máquina de estado. Adicionar outra declaração de
variável abaixo da árvore de animação. Começando com o complemento pronto, obteremos uma referência à reprodução
da máquina de estado tipo é reprodução automática de
estado de animação e podemos acessá-lo a partir
da árvore de animação
usando colchetes Dentro dos colchetes, podemos especificar um caminho para o que estamos tentando
acessar como uma string O que queremos acessar
é a reprodução dos parâmetros. Ok. Como antes, se selecionarmos o nó da árvore de
animação, podemos ver o
recurso de reprodução listado aqui Passar o mouse sobre o nome nos
fornece o caminho da propriedade, ou podemos clicar com o botão direito copiar o caminho e
colá-lo como Agora que podemos acessar
a máquina de estado quando o personagem
é instruído a pular. Se o personagem
estiver no chão, podemos solicitar que
a máquina de estado viaje para o estado Jump start. Certifique-se de que o nome
do estado corresponda exatamente. Em seguida, copie também a
linha abaixo, que aplica a velocidade de salto do
personagem, e remova completamente essas linhas
do processo físico Se testarmos isso, o
personagem pulará, mas a animação e a
velocidade não estão sincronizadas Adicionando outra função
privada separada chamada apply jump velocity, podemos definir a velocidade y do
personagem como
a velocidade do salto,
movendo o corpo do personagem E certifique-se de que o script esteja
salvo antes de continuar. Desative a
árvore de animação por um momento. Em seguida, na animação de
início, esfregue até a moldura quando os pés do personagem
saírem do chão Clicar em mais adicionar faixa. Podemos adicionar nossas próprias faixas
a essa animação. O tipo de faixa que queremos
adicionar é uma faixa de método de chamada. Em seguida, selecione o nó no qual
queremos chamar um método, que é o nó D
do corpo do personagem três. Desça até a parte inferior para
encontrar nossa trilha recém-adicionada e clique com o botão direito na faixa em
que a
linha de limpeza a cruza Em seguida, selecione Inserir chave. Podemos chamar qualquer método do nosso script de caracteres ou qualquer um
dos métodos herdados
do próprio nó D do
corpo do personagem O método que queremos chamar é
aplicar a velocidade de salto
ao nosso personagem Lembre-se de reativar a árvore de
animação antes do teste. Agora, quando o jogador
pressiona o botão de pular, o personagem iniciará a animação
do salto
e esperará até que seus pés realmente
saiam do chão antes de subir. Ok. Em alguns jogos, você pode querer que o personagem pule com
mais responsabilidade Nesse caso, é importante
usar animações em que os pés do personagem
saiam do chão no início da animação Agora temos os personagens
pulando e caindo animados. Na próxima lição,
melhoraremos a sensação de pular e como ele
é controlado pelo jogador Te vejo na próxima aula.
22. Gravidade: Olá, amigos.
Na lição anterior, adicionamos animações de salto
ao nosso personagem Nesta lição, melhoraremos
a mecânica de pular e
cair Testando o salto,
existem alguns problemas. É lento e flutuante. O jogador tem
tanto controle sobre o personagem no ar
quanto no solo, e não podemos alterar a altura do
salto de forma alguma. Se olharmos no script do
personagem, a velocidade do salto é
definida como uma constante Também podemos ver
que a força da gravidade está sendo recuperada
das configurações do projeto Se abrirmos as configurações do projeto, podemos seguir essa
string para encontrar as configurações de gravidade em
Física três D hábil A direção da gravidade também
é editável aqui. Vamos aumentar a gravidade para que o personagem se sinta mais pesado Vou multiplicar por dois. Observe que essa mudança
afetará tudo em todo
o projeto que
está sujeito à gravidade. Se você quiser afetar apenas
a gravidade do personagem, podemos fazer isso
no script do personagem. Na cena do jogo, mude
para três D V. Na minha opinião, não
faz sentido
definir uma velocidade de salto Em vez disso, gosto de pensar em quão alto eu quero que o personagem seja
capaz de pular. Podemos criar geometria
básica em
nossa cena de forma rápida e fácil usando um tipo de nó chamado CS G ou geometria sólida
construtiva Vamos adicionar uma caixa CSG. Mova-o para o lado e
descanse-o bem no chão. Adicione colisão à caixa
clicando no botão de colisão no
inspetor Podemos redimensionar a caixa
inserindo valores
no inspetor ou clicando e arrastando os
pontos vermelhos na pré-visualização. Redimensione a caixa
até que ela represente a altura máxima em que
você gostaria que
seu personagem
pudesse pular Podemos ver exatamente
a altura da caixa com seu
valor y no inspetor Mas certifique-se de que a
parte inferior da caixa esteja no chão. valor y da posição de transformação deve ser a metade de sua altura. Duplique essa caixa clicando com o botão
direito do mouse nela e
selecionando duplicar ou usando o atalho
Control D ou o comando D. Coloque a duplicata
ao lado Faça com que esta caixa seja mais alta que
a anterior e faça com
que ela represente uma altura na qual o personagem não
deveria ser capaz de pular No
script do personagem, como
definimos várias variáveis para
personalizar a forma como o
personagem se move, podemos fazer a mesma coisa com a
forma como o personagem pula Vamos exportar uma
variável privada chamada jump height como flutuador e atribuir a
ela um valor padrão em
algum lugar entre
as alturas
das duas caixas que acabamos Isso permitirá que o
personagem
pule para a primeira caixa,
mas não para a segunda. Em seguida, adicione uma variável privada
não exportada para manter a velocidade real de salto necessária para
atingir
essa altura de salto Agora temos duas categorias
de variáveis completamente
separadas em nosso script, uma para controlar
como a transportadora se move e outra para controlar
como a transportadora salta Podemos adicionar outra linha
acima delas para
enfatizar ainda mais sua distinção
na categoria de porta. Em seguida, forneça um
nome de string para a categoria. Vou chamar essas variáveis de
locomoção
e as que estão abaixo de variáveis de
salto Isso não apenas nos fornece mais informações
aqui no script, mas também
as separa no inspetor Também vou mover a direção para a categoria de locomoção e a
gravidade para a categoria de
salto Eu o marco como privado
com um sublinhado. Se você quiser que seu
personagem experimente uma força de gravidade diferente de outros objetos em seu jogo, você também pode exportar
outra variável. Vamos chamá-la de massa e atribuir
a ela o valor padrão de um. Isso funcionará como um multiplicador
da gravidade que está sendo adicionada
ao personagem Então, em 0,5, a gravidade
seria reduzida pela metade, ou com uma massa de dois, a
gravidade dobraria. Na função ready, podemos calcular a
velocidade do salto usando a física A velocidade de salto necessária para
atingir a altura de salto desejada é a raiz quadrada da
altura do salto multiplicada pela gravidade, também multiplicada
pela massa se você a estiver usando e multiplicada Ok. Alterne a velocidade de salto está sendo adicionada à
velocidade y do personagem para essa nova variável, e agora podemos
excluir a constante pois ela não está
mais sendo usada Também precisamos multiplicar a grafite pela massa
no processo físico Vamos rodar a cena do jogo e
tentar pular em nossas caixas. O personagem pode
pular alto o suficiente para alcançar a primeira caixa,
mas não a segunda. Experimente
experimentar valores diferentes de altura, gravidade
ou massa do salto e veja como eles mudam a sensação dos
personagens pulando E se o jogador não
quiser pular a toda a altura? A maioria dos jogos fará com que
o
personagem um salto menor
tocando no botão e um salto mais alto,
mantendo o botão pressionado. A animação do personagem atrasar antes de realmente pular pode ser realmente benéfica para implementar esse recurso Vamos começar não
definindo uma altura de salto, mas uma altura máxima
e uma altura mínima de salto. O que significa que também precisaremos de uma velocidade de
salto mínima e máxima E calcule esses dois
valores na função pronta. Ok. Em seguida, precisamos escalar a quantidade de
velocidade adicionada
ao personagem com
base na quantidade de tempo em que o botão
foi pressionado Para medir o tempo, há um tipo de nó
conveniente que podemos adicionar ao nosso personagem: um nó temporizador Vamos dar um nome a esse suéter. E pegue uma referência ao nó
do temporizador durante
a fase de preparação, da mesma forma que fizemos
com os outros nós Como o nome do
nó contém espaços, o caminho está entre
aspas. Dividindo o salto em
duas funções de servidor, vamos chamar a primeira
de salto inicial Quando o botão de salto é pressionado,
podemos iniciar o cronômetro. Então, quando o
botão de pular for solto, podemos definir sua
propriedade paused como verdadeira O que significa que,
ao iniciá-lo, também
teremos que definir sua propriedade
pausada como falsa Portanto, precisaremos editar
o script do jogador para chamar start jump
quando o botão for pressionado e complete jump
quando o botão for solto. No inspetor,
podemos ver que o cronômetro está configurado para uma contagem
regressiva a partir de 1 segundo, que é maior que 0,3
segundos, então tudo Mas precisamos verificar
o botão de um disparo, para cronômetro
faça a contagem regressiva
apenas uma vez
e não se reinicie
toda vez e não se reinicie
toda vez Quando a velocidade do salto é realmente adicionada
ao personagem, podemos pausar o cronômetro se ele
ainda não tiver sido Caso o jogador ainda esteja
pressionando o botão de pular. Podemos começar adicionando a velocidade
mínima de salto. Em seguida, adicione também a
diferença entre a velocidade máxima e
mínima Multiplicado por um menos o
tempo restante no cronômetro, dividido pela
quantidade máxima de tempo possível, que determinamos a partir da
animação é Nunca queremos que isso fique
acima de 0,3 segundos, então
podemos aplicar a função min
para limitá-lo a 0,3. Se o jogador
pressionar e soltar o botão em
um único quadro, isso será próximo de zero e o resultado será a velocidade
mínima de salto Se o jogador
segurar o botão segurar 0,3 segundos, isso será zero ponto 3/0 0,3, que é um, e o resultado será a velocidade máxima do
salto Um intervalo de tempo
intermediário será escalado linearmente entre
os dois resultados Vamos experimentá-lo
executando a cena do jogo. Ao tocar
no botão de pular, o personagem pula até uma altura
de 1,5 unidades
e, pressionando o botão,
ele salta até 2,5 Manter o botão pressionado por durações
diferentes produz
saltos de diferentes Em seguida, vamos adicionar mais variáveis
exportadas à nossa categoria de salto Controle aéreo e freios pneumáticos. Esses são multiplicadores aceleração e
desaceleração, respectivamente, que reduzirá a quantidade
de controle que o jogador tem sobre
o personagem no ar sem eliminá-lo completamente 0,5 é um bom ponto de partida
para seu valor padrão. Você precisará testar para determinar como deseja que o personagem se
sinta em seu jogo. No processo de física,
o primeiro bloco de código gira o equipamento do personagem para ficar
voltado para a direção desejada Na maioria dos jogos, isso
acontecerá independentemente de o personagem estar
no chão ou no ar. Em seguida, é adicionar a gravidade, que só se aplica quando o personagem
não está no chão. Esse bloco está movendo
o personagem, mas está fazendo isso de uma
forma que só faz sentido quando o
personagem está no chão. Mas aplique-o em todas as molduras, independentemente de estarem no chão ou no ar. Em seguida, a posição de
mesclagem da animação de locomoção está sendo definida, o que, novamente, só se aplica quando o personagem
está no chão A aplicação da velocidade D e o método de movimento e deslizamento
são universalmente Assim, podemos separar as partes
do processo físico
em física geral, física terrestre e física aérea, escrevendo uma nova função para física
terrestre e aérea, tanto privada quanto aceitando
um parâmetro de fluxo para Delta. Podemos então recortar e
colar a gravidade na função física
do ar e os cálculos do movimento na função
física do solo. Então, no processo de física, se o personagem estiver no
chão, chame a física do solo. Caso contrário, ligue para a física do ar. Passando Delta como
argumento para ambos. Nosso processo físico agora é muito menor e
mais fácil de entender, enquanto a física terrestre
e aérea está separada uma da outra e também é
mais fácil de gerenciar. Então, como aplicamos o
controle aéreo e os freios pneumáticos? Copie e cole os cálculos
da
velocidade x da física do solo
na física do ar Em seguida, multiplique sempre
que o jogador estiver tentando controlar o personagem no ar
pelo controle aéreo E a qualquer momento eles não
estão tentando controlar o personagem no ar por meio
de freios pneumáticos Isso não é o
mesmo que aceleração e desaceleração neste caso, já que ao tentar se
virar no ar, o jogador ainda está tentando
controlar o Aplicando a velocidade do salto 0,3 segundos após o início da animação do
salto, produziremos uma grande quantidade de tempo de coiote para Se você não quiser isso, pode exigir que o
personagem ainda esteja no chão antes de adicionar a velocidade de salto
com uma declaração if Além disso, a inicialização da
velocidade de movimento deve estar usando o addon ready Atualmente, isso está inicializando velocidade de
movimento com o
valor padrão da velocidade de caminhada Mas se sobrescrevêssemos o valor padrão
da velocidade de caminhada, ele não seria atribuído
à velocidade de movimento Use blocos de geometria para construir uma pequena pista de obstáculos
para seu personagem Quão difícil é controlar
os personagens pulando? Experimente valores diferentes até obter a sensação
que deseja para o seu jogo. Agora temos os
personagens pulando e seguindo a mecânica,
parecendo mais E na próxima lição,
adicionaremos controles de câmera. Te vejo na próxima aula.
23. Câmera : OK. Olá, amigos.
Na lição anterior, ajustamos como as forças afetam
nosso personagem no ar. Nesta lição, adicionaremos
controles de câmera à cena do jogo. Como fizemos nas aulas
anteriores, seria fácil simplesmente passar
a câmera para o jogador. A câmera seguirá
o jogador, mas girar a câmera ao redor do jogador
seria complicado Mas se adicionarmos outra
camada de separação, uma sem filhos para o jogador
com a câmera e
depois um neto, isso se torna muito mais simples As inclinações e
rotações da câmera que
esperamos de jogos
controlados em terceira pessoa podem ser alcançadas apenas alterando os valores de rotação
desse nó intermediário, seja nos eixos x ou y. Girar em torno do eixo y girará a câmera ao
redor do personagem, como esperamos ao inclinar
o controle direito horizontalmente Girar em torno do eixo x inclinará a câmera para cima ou para baixo O que esperamos de inclinar
o manípulo direito verticalmente? Como a câmera é
filha desse nó, ela corresponderá à sua rotação e também
permanecerá focada no
personagem. Podemos ajustar o ponto focal da
câmera, movendo-o dos pés do
personagem até a cabeça, movendo o
nó para cima ao longo do eixo y. A partir daqui, também podemos ajustar a propriedade de
deslocamento horizontal da câmera para deslocar ainda mais
a câmera ao longo
do eixo x e produzir um efeito de câmera de
ombro Podemos até mesmo controlar a
distância que a câmera está
do personagem e controlá-la dinamicamente
alterando o tipo de nó Clique com o botão direito do mouse no nó e selecione alterar tipo e procure o
braço de mola três nós D. Também podemos editar o nome
do nó para refletir
seu novo tipo. Com a câmera como
filha do braço de mola, precisamos redefinir sua transformação, para que ela tenha a mesma posição e rotação do braço de mola. No inspetor, podemos ver o comprimento da mola
está ajustado para 1 metro A câmera sempre tentará se reposicionar
para ficar a 1 metro de distância desse
nó ao longo de seu eixo Z. Vamos aumentar essa distância para algo maior,
como 5 metros. OK. Este
nó de braço de mola também tem colisão. Se houver um
objeto de colisão entre a origem do
braço de mola e a câmera
, a margem é a distância da colisão que a
câmera será posicionada A câmera será posicionada o mais próximo possível do comprimento do
braço da mola antes
que
ocorra uma colisão , comprimindo a Se a obstrução for removida, a mola se descomprimirá e afastará toda a distância Isso é feito com um raio,
verificando um único ponto ao longo
do eixo definido dos braços da mola. Mas se também especificarmos uma
forma para o braço da mola, podemos fornecer o volume da colisão substituindo o raio por um
molde moldado Exigir que
haja mais espaço vazio antes de permitir que a
câmera volte para a distância total. Se transformarmos a forma em uma caixa, podemos definir suas dimensões, e agora a caixa
será usada para detectar até onde
a câmera pode ir ao longo do
braço da mola. Para controlar a câmera,
precisamos adicionar mais mapeamentos de entrada às configurações
do projeto Abra as configurações do projeto e mude para a guia do mapa de entrada. Adicione ações para esquerda,
direita, para cima e para baixo. Vou usar as
teclas de seta e o botão de inclinação para os eventos que
acionarão cada uma dessas ações No script do player,
já temos uma referência
à câmera, mas não é a câmera que
realmente vamos controlar. Precisamos obter uma referência
ao nó do braço de mola. E coloque-o no inspetor. Na função de processo, podemos chamar uma função que
ainda não escrevemos. Em um roteiro que ainda
nem criamos até o braço da mola para
olhar em uma direção. A direção de olhar que podemos obter da entrada, como fizemos aqui, vetor de
entrada com a esquerda
como o x negativo, direita como o x positivo. Olhe para cima como o y negativo e para baixo como o y positivo. Vamos criar o script
spring arm. Ele herdará do
Spring arm three D. Não há um modelo para scripts
Spring arm three D, e o modelo padrão sem
modelo não é relevante Vamos desmarcar a opção
de modelo, permitindo que comecemos com um script em
branco Vou apenas nomear esse braço de mola e salvá-lo na pasta de
scripts. Já sabemos que precisamos
escrever uma função pública n, que aceitará um parâmetro
de
direção do tipo vetor dois do script
do player. OK. Só precisamos
girar esse braço de mola torno do eixo x por direção e o
eixo y por direção x. Mas, como tudo que acontece durante uma função de processo, acontece 60
quadros por segundo, e queremos que funcione
independentemente da taxa de quadros, o que significa
multiplicá-la Mas não temos
acesso ao Delta aqui, pois essa função não o
tem como parâmetro. Podemos adicioná-lo à lista de parâmetros e passá-lo
do script do player. OK. Ou podemos simplesmente chamar um método incorporado processar o Delta
T para recuperá-lo Agora, o braço de mola
que segura a câmera girará
com a inclinação do manípulo direito Essas rotações estão acontecendo a
uma velocidade de 1 radiano/segundo Podemos editar a velocidade
das rotações exportando
uma variável privada Vamos chamar isso de velocidade de rotação. Em seguida, multiplique isso por
direção e Delta. Se você quiser que essas rotações
tenham velocidades diferentes, você pode exportar
variáveis separadas para elas. OK. Embora normalmente se permita
que a rotação y
gire indefinidamente, a rotação x
geralmente tem limites Os controles serão interrompidos se
permitirmos que a câmera se incline até olhar
diretamente para cima ou diretamente para baixo. Como o
eixo da câmera está achatado no plano x,
o triste
se tornará zero ou invertido Portanto, precisamos fixar a rotação
dos braços da
mola entre um valor mínimo
e máximo Se a câmera plana com o horizonte tiver uma
rotação de 0 radianos, olhar diretamente para cima ou para baixo é uma rotação de
Pi sobre 2 radianos
na
direção Pi sobre 2 radianos positiva
ou negativa Só precisamos ter certeza de
que o valor absoluto seja menor que Pi sobre dois. Colocar a rotação x entre Pi
negativo e positivo sobre três é uma solução rápida
e fácil que ainda oferece uma ampla faixa Também podemos exportar esses valores e permitir que esses
limites sejam ajustados OK. Você pode ir mais longe e usar
dois quintos de Pi, ou até mesmo usar a
função de
graus de radiância para converter 89
graus Desde que a câmera não possa ir diretamente acima ou abaixo
do personagem, tudo bem. No script do jogador,
precisamos fazer alguns ajustes nos controles do nosso
personagem. Como a câmera agora é
filha do braço de mola, ela não está
mais girando, pelo
menos não dentro do espaço local O braço da mola está girando e a câmera permanece
estacionária em relação a ele Podemos obter vetores de base
global das câmeras, que em vez de serem
relativos ao nó pai, serão relativos a toda
a cena Como alternativa, podemos usar os vetores básicos do próprio braço
da mola OK. E, nesse caso, nem
precisamos de uma referência
à câmera. Agora temos a câmera facilmente
controlada pelo jogador. Na próxima lição,
importaremos e implementaremos
modelos ambientais em nosso jogo. Te vejo na próxima aula.
24. Masmorra: Olá, amigos.
Na lição anterior, adicionamos
controles de câmera ao nosso jogo. Nesta lição,
construiremos uma sala para nosso personagem
correr e pular ao redor dela. Eu baixei o pacote de ativos remasterizado
K Hits Dungeon Abrindo a pasta de ativos. Se olharmos na pasta G LTF. Há um grande número
de modelos que podemos importar
facilmente para o
ado para nosso projeto. Em Go, vamos primeiro criar
uma nova pasta dentro
da pasta de ativos
importados chamada Dungeon Com essa nova pasta selecionada, a
importação dos ativos os
colocará nessa pasta Assim como com os personagens, precisaremos fazer
alguns ajustes nas configurações
de importação desses ativos. Vamos começar com a sujeira
do piso Large. Clique duas vezes no ativo
ou selecione avançado
na guia Configurações de importação para
abrir a janela de configurações avançadas de
importação. Se selecionarmos o nó D da
instância de malha três, podemos permitir que Deus gere
uma forma de colisão para esse ativo automaticamente,
verificando a alternância física Uma malha de arame com a forma de
colisão é visível na pré-visualização e uma nova seção de física é
adicionada com várias opções Como o piso faz parte
do ambiente, esperamos que ele tenha colisões mas não se mova como resultado
dessas colisões ou seja afetado por forças externas, como Seu tipo de corpo é estático. Existem algumas
opções diferentes para gerar
essa forma
de colisão, e podemos ver que
a atual foi produzida usando convexo
decomposto Isso é bom para a maioria dos
objetos em nosso jogo, mas se inclinarmos a prévia, podemos ver que a forma da
colisão está visivelmente muito acima do
chão Isso faria com
que os
pés do personagem não tocassem o chão, que não ficaria muito bom Selecionando convexo simples no
menu suspenso. Essa colisão tem
menos polígonos do que antes e
o Os pés do personagem não
tocariam o chão em alguns lugares. Ao selecionar tri mesh, a forma da colisão corresponderá exatamente à instância
da malha Como esses ativos são de baixo teor de poliéster, isso não é realmente
um problema tão grande em termos
de desempenho quanto seria se essa malha fosse feita de milhares
de triângulos No entanto, a forma de colisão do personagem colidirá com
essas rochas Dependendo de como você
quer que seu jogo funcione, isso pode ser bom ou
ruim. Apenas esteja ciente disso. Se você quiser ignorar completamente
as rochas e ter apenas uma
caixa plana para colisão, selecione a caixa para
a forma da colisão A forma de colisão da caixa não
será
configurada automaticamente para corresponder ao
tamanho ou formato da malha Mas podemos editar
suas dimensões e posicionamento aqui na
parte inferior do painel. Vou selecionar números primos
para este andar para demonstrar como a forma de
colisão do personagem interage
com Quando seu piso tiver
a forma de colisão, você prefere clicar em importar
para reimportar o ativo seguir, vamos dar uma olhada em um objeto que talvez
queiramos que seja mais dinâmico, como o ativo Boxarg Como fizemos com o piso, podemos selecionar o nó D da instância meta três e adicionar física
clicando no botão de alternância Como queremos que ele não
apenas tenha colisões, mas também se mova
e seja afetado por forças externas, como a gravidade, seu tipo de corpo deve ser dinâmico Em seguida, selecione uma
forma de colisão para ela. Vou mudar isso
para convexo simples. Em alguns objetos,
talvez você não queira se preocupar com colisões
ou física, como banners ou outros Nesses casos,
não é necessário se
preocupar em editar as configurações de
importação Repita esse processo para todos os ativos aos quais
você deseja aplicar a física. Há muitos ativos
neste pacote de ativos. Não há necessidade de fazer todas
elas agora. Você sempre pode editar
suas configurações de importação e adicioná-las ao seu
jogo mais tarde, se quiser. Queremos construir uma sala
com esses ativos, o que podemos fazer
clicando e arrastando qualquer ativo para a
árvore da cena para adicioná-lo à cena Mas posicionar manualmente cada
ativo individual é entediante Sem falar que talvez
queiramos que nosso jogo tenha salas
diferentes. Assim como definimos o
personagem como sua própria cena separada, queremos que nossos níveis
de jogo também sejam cenas
separadas. Dessa forma, a
cena do jogo pode carregar qualquer nível em que o jogador
esteja jogando atualmente Vamos excluir as caixas de
piso e CSG. Em vez disso, podemos substituí-los por um novo nó três D para
representar um nível do nosso jogo. Vamos chamá-lo de masmorra. Como a cena do jogo
foi feita para jogar em qualquer nível e
níveis diferentes provavelmente terão iluminação
diferente, vamos fazer com que a luz do sol seja
filha do nó de nível. Clicando com
o botão direito do mouse no nó Dungeon, podemos salvá-lo como sua própria cena Chamado Dungeon salvo
na pasta de cenas. Portanto, todos os componentes visuais da cena
do jogo estão, na verdade, contidos em outras cenas. As únicas coisas
em nossa cena de jogo devem ser o manipulador
de entrada do jogador, um personagem, a mola e a câmera para o jogador
controlar e o nível Em seguida, clique na claquete
para abrir a cena da masmorra Aqui podemos editar nossa
masmorra separadamente de outras coisas na cena do jogo como a câmera ou o personagem Na cena da masmorra,
podemos adicionar um novo tipo de nó, um nó de mapa em grade,
que
nos permitirá construir rapidamente
o nível usando os ativos que importamos Mas o mapa Grid requer um recurso chamado
biblioteca de malha, que precisamos gerar primeiro a
partir dos modelos importados. No menu principal,
selecione cena nova cena para criar uma nova cena em branco e selecione três cenas D
na guia cena. Na verdade, essa cena não
representará nada no jogo, mas funcionará como uma coleção de três modelos D para
usar no mapa da grade. Codificando e arrastando quaisquer
três modelos D que você quiser em seu mapa de grade para
o nó raiz da cena, nós os adicionamos à coleção Os modelos estarão todos
na origem da cena ocupando o mesmo
espaço, o que é bom Podemos filtrar nossos
recursos para
facilitar o processo de seleção usando esse campo. A filtragem por GLTF
mostrará somente os arquivos GLTF. Ao selecionar os ativos em grupo, eles poderiam ser adicionados à biblioteca
de malha com muito mais rapidez. Quando todos os modelos que você
deseja usar estiverem na cena, salve a cena não
na pasta de cenas,
mas na pasta Dungeon de
ativos importados E chame-a de Dungeon
Mesh Library, com a extensão T SCN seguir, uma cena do menu principal, Exportar como biblioteca Mesh. Vamos salvar isso na mesma pasta,
chame-a de Dungeon Mesh Library Desta vez com a extensão Mb. De volta à cena do Dungeon, selecionando o nó Grid Map, podemos atribuir nossa nova
biblioteca de malhas no inspetor Podemos arrastar o recurso
do sistema de arquivos, tocar
no campo ou clicar no
menu suspenso e selecionar Carregamento rápido Isso apresentará uma
lista de recursos dentro do projeto de
um tipo compatível. Ao selecionar nossa biblioteca de malhas
recém-criada, podemos ver que as
malhas foram preenchidas na grade de
seleção Seleção do ativo do piso. Podemos colocar quatro blocos em
qualquer lugar do
mapa da grade clicando em. Posicionando os ladrilhos,
eles se encaixarão nas coordenadas
da grade ao longo do plano XD Expandindo a seção
da guia do inspetor, podemos editar os tamanhos das células às os ladrilhos
estão se encaixando Como sabemos que esses
blocos têm 4 metros de largura, vamos definir o tamanho da
célula XD para quatro. Agora, podemos colocar facilmente uma grade de
ladrilhos de três por três clicando. E exclua-os clicando com
o botão direito do mouse. Todas essas quatro
peças estão ligadas por zero. Essa é a
coordenada da célula no eixo y. Se aumentarmos o piso
, os ladrilhos serão
colocados 2 metros acima e mesma forma, no piso menos
um, 2 metros abaixo. E podemos editar a diferença de altura do
piso com o valor y do tamanho da célula. Se quisermos adicionar malhas
à biblioteca de malha posteriormente, podemos retornar à cena da biblioteca
de malha Esse último ativo de parede
precisa ser
reimportado com uma versão anterior de nomenclatura
G LTF. Podemos adicionar mais malhas a
essa cena. Em seguida, denuncie. Verifique se a caixa de seleção mesclar com
as existentes está marcada para atualizar a biblioteca de malhas
existente incluir
as novas De volta à cena da masmorra, selecionando o
mapa da grade, as novas malhas são adicionadas à grade de seleção Nem todas as
malhas têm 4 metros. Muitos têm 2 metros ou
até 1 metro ou menos. Alterando as
dimensões da grade para 1 metro, posso apagar os blocos atuais pois agora eles estão sobrepostos Em vez disso, selecione
coordenadas separadas por
algumas células para
redesenhar os quatro blocos Mas agora uma malha menor pode ser colocada em coordenadas a
cada 1 metro em vez de a cada 4 metros. Ok. Ao decidir o local para colocar a malha
no mapa da grade,
as teclas WASD também podem ser
usadas para girar Com uma rotação em
torno do eixo x, eixo S y e eixo D Z. O Wk voltará
à rotação padrão. Crie uma cena básica de dragão a
partir dos ativos e salve-a. Se houver
objetos que você queira
colocar fora das coordenadas exatas
da grade, eles ainda poderão ser adicionados
à cena separados do mapa da grade e
posicionados manualmente Em seguida, retorne à cena do jogo. Na cena do jogo, o chão da masmorra está
acima do personagem Então, vamos mover o personagem
acima do chão. Quando executamos a cena do jogo, o personagem pode colidir
com o chão, paredes e quaisquer outros objetos
na cena,
que tiveram a física gerada
pelas configurações de importação Com essas ferramentas, você pode criar uma grande variedade de níveis para o seu jogo de
forma rápida e fácil, adicionando, removendo ou
alterando itens conforme necessário. Agora temos um controlador de
personagem em
terceira pessoa totalmente funcional , permitindo ao jogador
controlar um
personagem totalmente animado andando e pulando em um mundo de três D. Ok.
25. O que vem a seguir?: Bem-vindo ao meu curso
sobre os fundamentos do desenvolvimento
de jogos e do Gado Este curso é uma continuação da introdução ao
desenvolvimento de três jogos em D e ao Gado, mas pode ser seguido e aplicado
a qualquer projeto que contenha um personagem que o jogador possa controlar para passar por
vários níveis Você está convidado a se juntar ao
nosso servidor de discórdia para trabalhar neste curso
ao lado de seus colegas Neste curso,
abordaremos elementos essenciais que são comuns a quase todos
os jogos de qualquer gênero. Crie uma cena de título, menus, faça uma transição suave
entre as cenas, mova um personagem entre os
diferentes níveis do
jogo, música de fundo, configurações e
persistência de dados entre cenas, níveis Quando terminar,
você terá uma boa estrutura
básica de
um jogo que
poderá ser desenvolvida posteriormente em algo de seu próprio
design, de qualquer gênero. Você também aprenderá habilidades úteis para trabalhar com o motor de
jogo Gada, organizando e projetando seus projetos para
serem mais escaláveis Você
aprenderá a codificar com script
GD com tudo
explicado em detalhes Aplicaremos princípios de design
orientado a objetos em nossos scripts, herança,
encapsulamento e abstração, para mantê-los organizados, personalizáveis e
reutilizáveis Todos os arquivos do projeto
também estarão disponíveis no GitHub, se você precisar revisar
o projeto como estava depois de concluir
cada lição Esses vídeos foram gravados
usando o Gadot versão 4.2 0.2. O projeto começa
com ativos dos Ka Kit Character e Dungeon pacotes
remasterizados
Ka Kit Character e Dungeon
feitos por Kay Neste curso,
também adicionarei recursos do Basic Guy Bundle
feito pela Penzilla e músicas no pacote
Barns Music
feito por Eric the Funny Baron feito por Eric Todos estão disponíveis
para download gratuito no H dot IO.