Introdução ao desenvolvimento de jogos 3D no Godot! | Thomas Yanuziello | Skillshare

Velocidade de reprodução


1.0x


  • 0.5x
  • 0.75x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 1.75x
  • 2x

Introdução ao desenvolvimento de jogos 3D no Godot!

teacher avatar Thomas Yanuziello, Indie Game Developer

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Assista a este curso e milhares de outros

Tenha acesso ilimitado a todos os cursos
Oferecidos por líderes do setor e profissionais do mercado
Os temas incluem ilustração, design, fotografia e muito mais

Aulas neste curso

    • 1.

      Apresentação

      1:21

    • 2.

      0–1 Introdução à programação

      8:03

    • 3.

      0-2 Constantes e variáveis

      9:11

    • 4.

      0-3 Declarações e condições

      9:46

    • 5.

      0-4 While loops e operadores

      9:23

    • 6.

      0-5 Matrizes e For loops

      10:32

    • 7.

      0-6 Pilhas e funções

      10:53

    • 8.

      0-7 Combinação e retorno

      9:34

    • 9.

      0-8 Árvore de cenários e herança

      10:21

    • 10.

      0-9 Abstração e encapsulação

      10:41

    • 11.

      0-10 Polimorfismo

      8:01

    • 12.

      de 0 a 11 dicionários

      8:54

    • 13.

      0-12 Depuração

      9:08

    • 14.

      Noções básicas

      13:51

    • 15.

      Roteiros

      9:27

    • 16.

      Controles

      15:09

    • 17.

      Importação

      8:47

    • 18.

      KayKit Update

      5:45

    • 19.

      Caminhada

      12:53

    • 20.

      Rotação

      14:05

    • 21.

      salto

      12:45

    • 22.

      Gravidade

      15:38

    • 23.

      Câmera

      12:46

    • 24.

      Dungeon

      13:29

    • 25.

      O que vem a seguir?

      1:56

  • --
  • Nível iniciante
  • Nível intermediário
  • Nível avançado
  • Todos os níveis

Gerado pela comunidade

O nível é determinado pela opinião da maioria dos estudantes que avaliaram este curso. Mostramos a recomendação do professor até que sejam coletadas as respostas de pelo menos 5 estudantes.

360

Estudantes

4

Projetos

Sobre este curso

Neste curso, vamos abordar tudo o que você precisa saber para usar o Godot Engine para criar um controlador de personagem em terceira pessoa; desde os conceitos básicos do trabalho no espaço 3D até o controle de um personagem e câmera em uma cena 3D. guache e o que você precisa saber sobre como usar o Google Eng  Vamos explorar 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 bastão esquerdo se movendo e girando o personagem e o bastão direito girando a câmera ao redor dele.  Se você não tiver familiaridade com o mecanismo Godot e com a criação de scripts no GDScript, incluí aulas para iniciantes sobre como escrever scripts.  Se você já souber usar o Godot e escrever scripts, fique à vontade para pular essas aulas e ir direto para a aula chamada Básicos.

Clique no link do meu site no meu perfil para participar do nosso servidor do Discord!

Você também vai aprender habilidades úteis para trabalhar com o mecanismo de jogos Godot, organizar e projetar seus projetos para serem mais escaláveis.  Você vai aprender a programar com GDscript, 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 GitHub se você precisar revisar o projeto completo.  Estes vídeos foram gravados usando a versão 4.2 do Godot usando recursos feitos por Kay Lousburg no itch.io

Conheça seu professor

Teacher Profile Image

Thomas Yanuziello

Indie Game Developer

Professor
Level: Beginner

Nota do curso

As expectativas foram atingidas?
    Superou!
  • 0%
  • Sim
  • 0%
  • Um pouco
  • 0%
  • Não
  • 0%

Por que fazer parte da Skillshare?

Faça cursos premiados Skillshare Original

Cada curso possui aulas curtas e projetos práticos

Sua assinatura apoia os professores da Skillshare

Aprenda em qualquer lugar

Faça cursos em qualquer lugar com o aplicativo da Skillshare. Assista no avião, no metrô ou em qualquer lugar que funcione melhor para você, por streaming ou download.

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.