Desenvolvimento de jogos 2D para iniciantes e C# no Unity 2020. 3 | Kaupenjoe (Nico) | Skillshare
Pesquisar

Velocidade de reprodução


1.0x


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

Desenvolvimento de jogos 2D para iniciantes e C# no Unity 2020. 3

teacher avatar Kaupenjoe (Nico), CS Student, Nerd and Educator

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.

      Introdução ao meu curso Unity

      1:29

    • 2.

      Instalação de unidade

      8:27

    • 3.

      (C#) Criando nosso primeiro projeto de unidade

      3:55

    • 4.

      (C#) Introdução ao C# Datatypes

      12:43

    • 5.

      Sintaxe C# explicado

      6:51

    • 6.

      (C#) Inteiros e operadores Arithmetic

      11:40

    • 7.

      (C#) Métodos de matemática C#

      9:31

    • 8.

      Operadores de atribuição (C#)

      4:49

    • 9.

      (C#) Booleanos e operadores de comparação

      3:39

    • 10.

      (C#) Booleanos e operadores lógicos

      4:55

    • 11.

      (C#) Cordas e métodos de corda

      15:00

    • 12.

      (C#) Variáveis

      8:22

    • 13.

      (C#) Declarações condicionais (If e outras

      8:18

    • 14.

      Operador ternário

      4:55

    • 15.

      Declaração de comutação (C#)

      4:49

    • 16.

      (C#) enquanto loop

      8:08

    • 17.

      (C#) para loop

      4:20

    • 18.

      (C#) Quebra e Continue palavras-chave

      4:02

    • 19.

      Arrays C#

      11:32

    • 20.

      (C#) matrizes multidimensionais em C#

      5:49

    • 21.

      Listas C#

      8:01

    • 22.

      Dicionários em C #

      5:32

    • 23.

      (C#) Foreach Loop

      3:00

    • 24.

      (C#) Namespaces

      9:09

    • 25.

      Métodos C#

      9:33

    • 26.

      Sobrecarga de método (C#)

      6:10

    • 27.

      Aulas e objetos

      12:26

    • 28.

      Membros de curso (C#)

      4:49

    • 29.

      (C#) Membros estáticos

      7:26

    • 30.

      Modificadores de acesso (C#)

      10:24

    • 31.

      Propriedades C#

      9:08

    • 32.

      Herança (C#)

      9:55

    • 33.

      Polimorfismo (C#)

      4:49

    • 34.

      (C#) Aulas e métodos abstratos em C#

      8:04

    • 35.

      Métodos virtuais

      3:45

    • 36.

      Interface C#

      7:15

    • 37.

      Enums (C#)

      4:12

    • 38.

      (C#) Exceções e comprovação e captura

      7:28

    • 39.

      (C#) noções básicas de genéricos em C#

      5:18

    • 40.

      (C#) noções básicas do LINQ em C#

      5:58

    • 41.

      (C#) Eventos e delegados

      8:02

    • 42.

      (C#) arquivo I/O

      6:46

    • 43.

      Convenções C#

      8:19

    • 44.

      Layout e editor da unidade explicado

      18:03

    • 45.

      Estrutura de pasta de unidade

      4:42

    • 46.

      (Unity Basics) Scripts e o inspetor

      8:52

    • 47.

      (Unity Basics) Kenny Ativos e a loja de ativos para nossos jogos

      3:30

    • 48.

      (Unity Basics) Cenas e configurações de compilação

      7:31

    • 49.

      MonoBehavior em Unity

      12:54

    • 50.

      (Unity Basics) Matemática curta: vetores

      3:39

    • 51.

      (Unity Basics)

      15:15

    • 52.

      (Unity Basics) GameObjects em unidade

      12:18

    • 53.

      (Unity Basics) Métodos de entrada em unidade

      7:15

    • 54.

      (Unity Basics) Criando um script de movimento muito simples

      12:27

    • 55.

      (Unity Basics)

      10:49

    • 56.

      (Unity Basics) A câmera (principal)

      8:22

    • 57.

      (Unity Basics) GetComponent em unidade

      14:07

    • 58.

      (Unity Basics) Prefabs e criando novos objetos

      11:00

    • 59.

      Texturas e sprites

      10:11

    • 60.

      Editor Sprite

      5:42

    • 61.

      (Unity Basics) O renderizador Sprite

      10:06

    • 62.

      (Unity Basics) 2D Collider

      14:47

    • 63.

      (Unity Basics Basics) Rigidbody2D

      11:14

    • 64.

      (Unity Basics) Texto básico de IU

      7:08

    • 65.

      (Unity Basics) Ferramentas básicas de depuração

      6:57

    • 66.

      (Clicador de queijo) A ideia de "Clicker de queijo"

      3:24

    • 67.

      (Clicador de queijo) Criando um queijo para clicar

      17:58

    • 68.

      (Clicador de queijo) criando edifícios para construir

      32:32

    • 69.

      (Clicador de queijo) fazendo uma interface básica para edifícios

      44:52

    • 70.

      (Clicador de queijo) criando atualizações

      32:27

    • 71.

      (UI de unidade) Adicionando um Canvas

      15:20

    • 72.

      Painéis e texto

      9:23

    • 73.

      TextMashPro para um melhor texto

      8:24

    • 74.

      (UI de unidade) Adicionando imagens à nossa IU

      5:15

    • 75.

      (UI de unidade) botões de clicar podem ser divertidos

      9:41

    • 76.

      (UI de unidade)

      8:15

    • 77.

      Layout em Unity UI

      12:23

    • 78.

      Barras de rolagem e máscaras

      8:16

    • 79.

      Campos de Dropdown e entrada

      12:05

    • 80.

      (UI da Unidade) Adicionando grupos de layout ao nosso Cheese Clicker

      4:52

    • 81.

      (Unity Intermediate) Adicionando uma fonte de áudio

      9:25

    • 82.

      (Intermediário de unidade) Adicionando partículas

      8:42

    • 83.

      Configurações de projeto (Unity Intermediate)

      9:17

    • 84.

      (Unity Intermediate) Adicionando etiquetas para GameObjects

      6:52

    • 85.

      Raycasting 2D em unidade

      11:35

    • 86.

      (Unity Intermediate) Preparando a cena para salvar dados

      46:48

    • 87.

      (Unity Intermediate) Salvando dados com PlayerPrefs

      9:49

    • 88.

      (Unity Intermediate) Salvando dados (personalizados) com arquivos JSON

      14:33

    • 89.

      (Intermediário de unidade) usando conjuntos de telas

      16:36

    • 90.

      Basics de animação

      23:24

    • 91.

      Objetos com script (Unity Intermediate)

      13:23

  • --
  • 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.

754

Estudantes

--

Sobre este curso

Você sempre quis criar seus próprios jogos, mas não sabia por onde começar? Este é exatamente o curso que você precisa!

Neste curso completo de desenvolvimento de jogos 2D para iniciantes, você vai aprender o básico da linguagem de programação C# e desenvolvimento de jogos com o Unity 2020.3. Nenhuma experiência é necessária para este curso para aprender os entraves e saídas de fazer jogos com Unity.

Este curso é acessível para iniciantes completos. Mesmo que você nunca tenha programado em sua vida. Conhecimento básico de Unity e Desenvolvimento de jogos seria vantajoso, mas não é necessário. Como parte deste curso você também fará jogos 2D totalmente jogáveis do início ao final, que você pode remodelar, modificar ou atualizar conforme quiser e usar como um playground da Unity.

Primeiro, você aprenderá C#, então vamos passar por conceitos básicos de Desenvolvimento de Jogos Unity e depois olhar para conceitos intermediários, bem como o Sistema de IU Unity.

O código fonte inteiro será disponibilizado para que você possa acompanhar tudo o que faço nas palestras.

Se você tiver alguma dúvida ou sugestão, também não hesite em contactar-me aqui. Fico feliz em ajudá-lo a aprender a fazer jogos com Unity.

Conheça seu professor

Teacher Profile Image

Kaupenjoe (Nico)

CS Student, Nerd and Educator

Professor

I am Nico - also known as Kaupenjoe - I have a Master's Degree in Computer Science and teach Game Development through many different classes. Mid-2020, when I became a bit disillusioned with my job, I set my sights to something different. Multiple people have previously told me I was good at teaching things.

With some of my prior YouTube Video making knowledge I was able to make my first courses. The Minecraft Courses in particular made a huge impact on students and myself and allowed me to teach full-time with courses and other supplementary methods.

I hope you will also join me and allow me to help you learn Programming, Modding or Game Development. As a hobby, side-hustle or as a promising career, it is an amazing and fulfilling field and I'm so happy to have y... Visualizar o perfil completo

Level: All Levels

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 ao meu curso de unity: Olá, Eu sou Nico me pegou em estudante muscular para ciência da computação e tudo estranho nerd para tudo o desenvolvimento de jogos relacionados. Por quase oito anos, tenho programado em Unity por razões recreativas e profissionais. O incrível poder do motor Unity te dá de graça ainda me deixa perplexo até hoje. Nesta unidade completa e classe C-Sharp, você aprenderá todas as habilidades necessárias para fazer jogos incríveis em Unity ou de tópicos básicos a mais avançados. Primeiro, você será completamente apresentado à linguagem de programação C-sharp. Esses fundamentos irão ajudá-lo a entender a unidade em toda a sua beleza. E assim mesmo iniciantes absolutos para programação são muito bem-vindos nesta classe. Depois de aprender os fundamentos de C Sharp, passaremos para os conceitos básicos de unidade, como o editor, como os scripts funcionam, texturas e sprites e muito mais. Assim que o básico é feito, você vai criar sua própria primeira marcha, Ela é clicker. Este projeto é inspirado por ele, Cookie Clicker. E usaremos todos os fundamentos da Sharp C, bem como todos os conceitos básicos que você terá aprendido até esse ponto. E então continuaremos com tópicos mais intermediários, como uma seção detalhada sobre o USU I-System,bem como reformulação, bem como reformulação, salvamento e obtenção de dados persistentes, bem como o uso de conjuntos de mosaicos, entre outras coisas. Tudo isso e muito mais espera por você nesta classe completa sobre desenvolvimento de jogos Unity. Então, o que você está esperando para se matricular nesta aula agora? E vamos ser o primeiro passo da incrível jornada para criar incríveis jogos Unity. O poder está em suas mãos. Vejo-te na primeira lição. 2. Instalação na Unity: Muito bem, bem-vindos a esta palestra onde passamos por como baixar o Unity e instalá-lo. Portanto, este URL está disponível como um recurso para que eles possam facilmente ter acesso a ele. É simplesmente armazenado no download de barras unity.com. E então certifique-se de que você está, que você cumpre todos esses critérios aqui. E você poderia simplesmente dizer: “Sim, eu cumpro todos esses critérios. Isto é basicamente se você é simplesmente uma única pessoa e você não está fazendo isso em qualquer tipo de empresa ou algo assim, então você pode usar a licença pessoal Unity aqui e sim, e apenas baixar o Unity Hub. Então vai haver um programa que vai ser útil para todos os tipos de coisas. Vou colocar isso rapidamente dentro desta pasta aqui. Então este é simplesmente um EXE, você pode apenas iniciá-lo. E então você pode ter que fazer isso. Ele tem acesso de administrador e, em seguida, você será recebido pelos termos de serviço. Você simplesmente aceitará esses e, em seguida, dirá onde quer que você queira instalar isso. Agora eu já instalei pessoalmente. Você simplesmente clicará em Instalar e, em seguida, tudo funcionará a partir daí. Depois de instalá-lo, ele provavelmente solicitará que você faça login basicamente se você já tiver uma conta do Unity, isso é ótimo. Se você não fizer isso, então você pode simplesmente fazer um no site do Unity e, em seguida, fazer login com isso depois de fazer login, algo assim deve aparecer. Agora seus projetos provavelmente estarão vazios, mas isso é totalmente normal. Mas a primeira coisa que precisamos fazer é instalar um exemplo específico de unidade. Então, no nosso caso, como podem ver, eu tenho 20 1946, eu tenho 2020 a 0. Esta é uma versão beta. E então eu tenho a versão 2023 0, que é basicamente a que vamos trabalhar principalmente. Agora, se você for para este botão Adicionar, então um novo pop-up será aberto e você pode ver que você pode obter alguns lançamentos recomendados. Então, há na verdade quatro novas versões estrangeiras foram lançadas desde o 2020 ponto três ponteiros 0. E, em seguida, há também outras versões oficiais, bem como pré-lançamentos. Agora, no nosso caso, nós realmente queríamos a versão 2020 0.3, qualquer que seja o número que está depois que geralmente significa que há apenas algumas correções de bugs e algumas pequenas mudanças. Então vamos clicar no próximo ano. E, em seguida, se você não tiver instalado por conta própria. Então, se você não tem o Visual Studio, eu recomendo que você adicione isso à sua instalação, bem como a um módulo. Porque vou usar o Visual Studio e pode haver algumas congruências. Se você usar um outro ambiente de desenvolvimento, basicamente documentação que você precisa ter. E então você também poderia, em teoria, ter alguns pacotes de idiomas diferentes aqui como você pode ver, e todas as plataformas realmente não nos interessam. Talvez se você estiver basicamente em um Mac ou Linux, então eu diria que você definitivamente deve tomar isso também, que você possa realmente construir seu jogo em sua própria máquina. Caso contrário, isso não seria tão inteligente. Hora, no entanto, Eu acredito que a unidade, o hub realmente detecta em que tipo de sistema você é e deve instalar isso automaticamente. Mas sim, então eu definitivamente acho que você deve definitivamente ter este Visual Studio aqui. Eu já tenho isso instalado, então eu não preciso dele, mas eu altamente recomendado. E, em seguida, basta clicar em Concluído. Agora, como você pode ver, isso está baixando agora e, em seguida, também instalando. Isto vai demorar algum tempo dependendo da sua ligação à Internet bem como da sua velocidade do seu computador. Após a conclusão da instalação, podemos voltar aos projetos. E agora vamos realmente criar nosso próprio primeiro grande projeto aqui. Então você vai para New. E normalmente eu vou a este menu suspenso para que você possa escolher qual versão do Unity você gostaria de selecionar. Vamos selecionar a versão mais recente aqui. E então ele vai criar uma nova janela aqui que diz Criar uma nova versão com esta versão específica. Porque este é um curso 2D, nós basicamente só queria D, selecionado como um modelo aqui. Podemos selecionar um local, estou bem com esse local. E então o nome do projeto. Neste caso, vamos apenas usar o exemplo de instalação no nosso caso para você, porque depois disso vamos começar imediatamente na introdução nítida C. Talvez esse seja um nome melhor para você. Então, talvez nomeou o projeto C introdução afiada para você. Vou ficar com o exemplo de instalação, em seguida, clique em Criar, em seguida, o Unity Hub será fechado e uma unidade será aberta. Você pode ter que dizer sim para o Windows Defender real que deseja usar o firewall. Nós só vamos dizer sim, claro, porque tudo bem. E em pouco tempo depois de importar algumas coisas e até baixar mais algumas coisas, então ele será aberto para nós dependendo de quão bom seu PC é. Isso pode demorar um pouco mais ou menos, e aí está. Agora, a primeira coisa que vou fazer é mudar o layout para o meu layout pessoal, que eu uso. Eu salvei isso sob layout KJ. E se eu selecionar isso, então este é o layout que vamos usar durante este curso. Agora eu realmente lhe dei isso como um layout aqui, layout geral de algodão, W LTE. Este é o arquivo disponível como um recurso também. E então você pode basicamente importá-lo indo para kJ, em seguida, vendo Load layout do arquivo e selecionando este arquivo. E então você deve ter exatamente o mesmo layout também. Se você quiser. Você não precisa necessariamente ter isso. É que este é o layout que eu estou acostumado. - Sim. Mais uma coisa que você precisará verificar antes de continuar é ir para Editar e, em seguida, ir para Preferências. E isso abrirá uma janela de preferência aqui. E, em seguida, dentro de ferramentas externas, certifique-se de que você tem o editor de script correto aqui selecionado. Então, para nós, isso para você, provavelmente será Visual Studio Community 2019. I Visual Studio 2019 em si. Então, só para você saber que você tem que selecionar isso. Caso contrário, você usará o editor de scripts padrão, que é o quê? Vai parecer um pouco diferente do que você vai ver comigo. Mas esse seria o fim para este. Esta é a instalação feita. Então, quando você está continuando com este curso, você basicamente tem em alguns desses são algumas das seções. Você tem duas opções. Então você pode obter o pacote completo para algo ou um pacote vazio. Então isso basicamente significa que você pode fazer tudo ou começar com basicamente nada e construí-lo enquanto eu estou fazendo isso. Então, para importar isso, você pode ir para Ativos, pacote de importação, pacote personalizado. Em seguida, ele abrirá uma pasta particular aqui. E nós estamos indo basicamente para ir para a nossa pasta onde eu tenho isso dentro E como você pode ver, existem alguns desses pacotes, todos eles estão disponíveis como um recurso. Então, por exemplo, o que queremos é o C-sharp completo. Então vamos abrir isto. E então, como você pode ver, tudo aqui já está feito para você, de modo que você simplesmente precisa dizer Importar. E então ele vai importar todas essas aulas e todas essas cenas. E então você pode basicamente começar a palestrar 10 tipos de dados. Lá está ele. E então se eu começar isso, então o que você pode ver é que ele funciona imediatamente com, bem, ele vai recarregar e então, como você pode ver, ele funciona e tudo está bem. Então isso seria basicamente, isso é, isso é muito importante. Então você tem que escolher se você quer ou não a versão completa ou se você quer a versão vazia deste. E sim, isso seria basicamente para a instalação. Isso seria tudo o que você realmente precisa para começar a jornada de programação em Unidade. Sim, espero que tenha achado isso útil e a instalação tenha sido bem sucedida. Se alguma pergunta permanecer, é claro, sinta-se à vontade para perguntar e eu responderei. E sim. 3. (C#) criando nosso primeiro projeto Unity: Muito bem, bem-vindos a esta palestra. E isso é apenas uma adição rápida aqui. Então você sabe o que tem que fazer. Porque na próxima palestra vamos começar imediatamente nesta introdução. E basicamente, eu só queria mostrar mais uma vez criando um novo projeto e, em seguida, basicamente, importando o pacote real que eu forneci aqui. Essa foi a palestra antes. Esse foi o pacote completo e vazio. Eles são Unity Package Files. E sim, basicamente quando você tem o Unity Hub aberto, basta clicar nessa pequena seta e escolher a versão mais recente. E quando você clicar nisso, uma nova janela será aberta aqui. Crie um novo projeto com Unity 2020 três, e, em seguida, qualquer que seja a versão atual, ME certifique-se de selecionar o modelo 2D aqui. E então eu sugeriria algo como C introdução afiada como um nome de projeto ou algo assim. Claro, você também terá que especificar sua localização. Onde você quer que isso seja criado? Digamos que estou feliz com isso. E como eu disse, introdução C-Sharp que faz mais sentido. E então ele cria o novo projeto. Então você realmente tem que criar um novo projeto. No geral, eu diria que provavelmente para cada seção. Então C-sharp vem os conceitos básicos. E então nós começamos a basicamente construir nosso primeiro jogo, o clicker bochechas, unidade, DUI e assim por diante. Então, para cada uma dessas seções, eu aconselharia você a fazer um novo projeto para isso, então você sempre será capaz de importar qualquer que seja o conteúdo real do que é. Para a introdução nítida C, você tem a capacidade de escolher entre os dois seguintes. Então, se eu os trouxer aqui, então há o C-afiado. Como podem ver, o pacote completo da unidade e o pacote da unidade vazia. Ambos vêm com um predefinido, então pastas e cenas já estão dispostas e feitas. O Vazio simplesmente são basicamente scripts vazios. E os completos são os scripts completos que já são que basicamente estamos fazendo na introdução nítida C. Então, o que você quiser é melhor para você aprender C-Sharp. Você pode fazer tudo já ou ter isso vazio, mesmo com todas as outras seções. Eles são. Você pode obter os pacotes completos que eles são ou basicamente criar todo o projeto como nós vamos junto com as palestras. Então vamos ver, mais uma vez, geralmente o layout aqui deve ser diferente. Se você olhar para trás para o isolamento unidade, eles são, é o número um um recurso ou número 2, Eu digo a você que vamos mudar o layout para este. E este é também o layout que vamos usar durante todo o curso aqui. E você pode ir para Ativos, importar pacotes ou importar pacote, pacote personalizado. E então ele vai deixar você basicamente abrir esta caixa de diálogo de arquivo. E então você pode escolher o pacote completo ou o pacote vazio. Como eu disse, o pacote MD também conterá tudo. No entanto, os scripts vão estar vazios, exceto possivelmente para os dois primeiros porque isso é, isso é o material mais básico que eu quero explicar algumas coisas que eles são. E no completo, tudo estará dentro dele. Assim, a importação em si terá a mesma aparência tanto para o completo quanto para o vazio. No entanto, no completo são preenchidos, que podemos basicamente verificar apenas por causa do argumento aqui. Então vamos para scripts, por exemplo, e vamos apenas clicar em qualquer coisa aqui. E então, como você pode ver, isso já está preenchido, às vezes com alguns comentários, bem como para que você também possa verificar isso. Mas sim, de agora em diante, vamos começar imediatamente com a palestra, tipos de dados. Espero que você se divirta com o curso e que aprenda algo novo. E verei você na primeira palestra. 4. (C#) Introdução para dados C#: Bem-vindos à introdução do C-sharp para o curso de união. E nesta primeira palestra vamos dar uma olhada em um tipo de dados. Primeiro, certifique-se de que você tem os tipos de dados da Lecture 1 abertos aqui. E, em seguida, basta ir para scripts e clicar duas vezes em tipos de dados e, em seguida, o script de tipo de dados será aberto. Agora, há algumas coisas que eu quero dizer primeiro, a primeira coisa é que nós vamos ignorar a maior parte do que está aqui em cima. Vamos ignorar isso por enquanto. Vamos chegar a isso mais tarde. E vou explicar isso em detalhes. Mas agora, precisamos começar com um pouco de outra fundação primeiro. Então vamos apenas dizer que precisamos de tudo isso para que o programa seja executado. Digamos assim e depois ficaremos bem. E então tudo o resto lá em cima, nós vamos apenas ignorar. E nós vamos olhar para dentro, para este começo aqui, para que vejamos o início. E então temos este colchete encaracolado e tudo o que está escrito dentro daqui. Isto é o que vamos ver. Então, em código, em C Sharp, por exemplo. E também, eu acho que como basicamente qualquer outra linguagem de programação, nós sempre vamos de cima para baixo. Então, cada uma dessas linhas, felizmente há numeradas aqui também. Cada uma dessas linhas é executada em série. Então basicamente, primeiro, a linha 10 é executada e, em seguida, linha 11 e, em seguida, linha 12 e assim por diante e assim por diante. Há algumas coisas em que você pode, por exemplo, agrupar algumas linhas e depois executá-las. Mas agora, vamos pensar nisso como vamos passar de cima para baixo. E tudo aconteceu com cereais, certo? E agora tipos de dados. Então, o que? A primeira pergunta é, quais são os tipos de dados? Tipos de dados são basicamente uma maneira de armazenar informações e há diferentes tipos de informações. Então, em C-Sharp, temos a verdade ou valores booleanos. Temos números. Esses podem ser números inteiros ou números de ponto flutuante. E também temos basicamente texto. Estes são caracteres ou vários caracteres, caracteres próximos uns dos outros, que seriam chamados de strings. Agora, vamos começar com a verdade ou valores booleanos. Algumas coisas para a sintaxe básica também. Então, se quisermos criar uma nova variável, então o que temos é escrever o tipo que queremos. Neste caso, este é um valor booleano. Então escrevemos bool e depois escrevemos o nome da variável, e depois terminamos cada linha com um ponto-e-vírgula. Isto é o que seria chamado de declaração. Vamos olhar para isso novamente na próxima palestra, um pouco mais, a sintaxe de tudo isso. Mas neste momento, esta é a ideia. Então nós criamos agora uma variável, como você pode ver, variável local do tipo bool, que é chamado, é aterrado. E então podemos atribuir essa variável com este operador igual um valor. Neste caso, dizemos que é igual a verdadeiro. Então, neste caso, depois que a linha 12 é aterrada é igual a true. Então esta é a missão. E você pode, por exemplo, imaginar que é por isso que um resfriado está aterrado. A variável está aterrada pode ser algo que mantém o controle de quando você tem como um jogo de plataforma 2D onde Mario, por exemplo, corre para frente e para trás e assim que Mario salta é aterrado seria definido como falso porque agora ele está no ar. E então, assim que ele toca o chão novamente é aterrado seria verdade. Então isso é algo onde você poderia, por exemplo, fazê-lo de modo que você não pode saltar infinitamente alto porque você precisa estar no chão para ser capaz de saltar. Isso é apenas como uma espécie de um exemplo real que você pode usar em um jogo. E então temos a saída específica da Unidade aqui, apenas para que possamos ver o que a variável realmente implica. Vamos olhar para a saída no final quando eu terminar com a explicação aqui. E então esta seria a verdade e valores booleanos úteis para basicamente decidir se algo é verdadeiro ou falso ou não. Porque esses são os valores possíveis lá ou são verdadeiros ou falsos. E é isso. Então vamos olhar para o inteiro. Então inteiros são números inteiros. Neste caso, estamos, nós em fazer uma variável que é chamado de pontos do tipo inteiro e nós imediatamente atribuí-lo um 50. Então, neste caso, declaração e atribuição juntos em uma linha seria chamado de inicialização. E isso imediatamente apenas define a variável pontos 250. E então nós também temos um longo. Um longo simplesmente tem um limite mais alto. Então podemos armazenar números maiores lá. E eu realmente gosto de ter isso aqui apenas para referência. Então o valor máximo de um inteiro normal é 2 bilhões, e então o valor máximo de um longo é cinco quintilhões, eu acredito. Mas no final, é tão grande que raramente é usado. E eu também, em, especialmente em jogos, geralmente o máximo inteiro é suficiente. E sim, os pulmões estão lá. Se você precisar deles, então você pode fazer isso e fazer com que seja basicamente nove quintilhões. E você deve ficar bem nesse ponto, eu acredito. Certo? E então números de ponto flutuante são basicamente números com um ponto decimal. No entanto, eles são salvos com uma notação científica. Então notação científica são coisas como dez. Vamos fazer como 3.5 vezes dez para os quatro, por exemplo, esta é a notação científica e é assim que os números de ponto flutuante são salvos. E há dois tipos de números de ponto flutuante que são interessantes aqui. Um é um carro alegórico e o outro é um duplo. E a diferença entre esses dois é basicamente a precisão dos números que ele pode salvar. Assim, um número de ponto flutuante pode economizar até oito pontos de precisão. Então podemos ter oito números aqui. Então, antes ou depois da vírgula decimal, e ainda seria preciso. E o duplo pode fazer até 16 números. Assim, até 16 números antes e depois do ponto decimal. Então, mas para acertar, então se tivermos algo como Ro, algo louco como isso. Então você contaria 123, e então você contaria aqui 456 e assim por diante. E se isso é 16, então ou é, se é maior que 16, então não seria. Ele iria arredondar para cima ou para baixo. Seria redondo. Então isso é importante saber. Se precisar de precisão. É melhor usar inteiros se você não precisar de pontos decimais. Sim, são números de ponto flutuante. Vamos ver como funcionam em futuras palestras. Mas esses também podem ser muito importantes. E então vamos para os personagens e a primavera. Então, caracteres, há um char, tipo de variável, um tipo de dados e uma string. Um caractere é simplesmente uma única letra e você escreve com estas aspas simples aqui. E uma string é um é vários caracteres ao lado do outro. E você escreve isso com essas aspas duplas. Sim. E a idéia é simplesmente que, como eu disse, a carta é uma única letra. Agora isso pode ser um a, poderia, em teoria, ser um número, mas então não é o número em si também, mas é a representação textual de dois. E então também, por exemplo, caracteres especiais como um I'm Spacebar ou um sublinhado ou algo assim, também seriam caracteres neste caso. E então uma string é simplesmente como eu disse, um múltiplo caracteres ao lado do outro. E ainda assim, uma coisa que eu também queria mencionar, C-sharp tem algo chamado tipos implícitos. Então o que vimos antes é que sempre designamos o tipo, o tipo de dados que ele era. Então char uma corda, um duplo, e assim por diante. No entanto, nós também podemos apenas escrever var, então VAR, e então o nome da variável e, em seguida, colocá-lo como apenas atribuí-lo a algo e, em seguida, ele só vai saber, ok, este é um inteiro agora. E como você pode ver, se eu passar o mouse sobre ele, número inteiro total de pontos. E aqui temos um jogador de cordas para nomear. Então isso funciona também. Pessoalmente, eu não uso isso com muita frequência ou onde quer que seja porque eu não ganho nada com isso. Algumas pessoas usam isso quando você tem nomes de tipos de dados talvez longos porque no futuro podemos, por exemplo, criar nossos próprios tipos de dados. Isso às vezes ajuda. Normalmente eu achei que é melhor ser realmente específico, ou no nosso caso, explícito, certo? Então este é um tipo implícito e, em seguida, este seria typecast explícito. Digitamos explicitamente. Ei, isto é uma corda, este é um personagem que é um flutuador. Então, sim, mas você pode, claro, usar isso. E você pode ver em código que outras pessoas escreveram. Portanto, é sempre importante saber as coisas, mesmo se você não tende a usá-las ou se você não quiser usá-las. Mas tem tudo a ver com estilo e nada a ver com se é ou não melhor ou pior em termos de desempenho ou algo assim. A palavra-chave var não muda nada. Se eu escrever var ou não uma string lá. Depois de tudo ser compilado em tudo, isso, não importa. Não muda nada. É apenas por causa da legibilidade. E isso também é uma das coisas que é importante. O código deve ser legível para pessoas. E ele vai muito facilmente, na verdade, você pode escrever código que funciona. Mas também precisa ser legível para alguém que nunca viu o código antes. E isso é muito difícil, certo? Então vamos ver o que acontece quando realmente executamos isso. Então o que esperaríamos que isso, a primeira coisa a ser colocada é de castigo, verdade. E então os pontos devem ser 50 por nove, quadrilhões ou continuando-os. E então temos um danificado 3.5, grande dano, um 100, então a letra uma UTIN como jogador 1, James jogador 2, e então o total de pontos seria 100. Isto é o que esperaríamos aqui para ser posto para fora, certo? Mais uma vez, certifique-se de que você tem uma palestra aberta. E então podemos apertar o botão play aqui. E como podemos ver, lá vamos nós. Então, se olharmos para baixo aqui, podemos realmente rolar um pouco e, em seguida, é aterrado é verdade. Então temos pontos 59, quintilhões, 3,5 danos. Nós também temos grande dano, um 100, e então personagem, um personagem, um jogador um é James do jogador NICU 2, e, em seguida, ponto gerar um 100. Uma coisa a notar é aqui que o 100, na verdade o ponto decimal é cortado. Neste caso, porque na verdade não contém nenhuma informação útil porque era 0 de qualquer maneira. Então não importava se temos 0,01, por exemplo. E depois deixamos descansar um pouco e depois jogamos de novo. Então vamos ver que ele realmente faz isso. Também é importante notar, estas são vírgulas no meu caso, isso é apenas por causa da localização, porque minha máquina executa a localização alemã para que vírgulas ou nenhum ponto decimal seja convertido em duas vírgulas e vírgulas para os 1000 separadores vão ser convertidos em pontos ou, você sabe. Sim. Então é importante saber isso. Só não se confunda com isso. Está tudo bem. Sim. E isso foi basicamente para a introdução aos tipos de dados. E como eu disse, só uma visão geral. Nas futuras palestras, vamos realmente fazer uso desses tipos diferentes, o que eles podem fazer. E vamos manipulá-los. Nós vamos, por exemplo, os números que vamos para matemática com eles, certo? Então vamos calcular as coisas. Então, isso é tudo por vir. E espero que tenha achado útil. Se houver alguma dúvida. Claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 5. (C#) sintaxE: Muito bem, bem-vindos de volta à introdução C-sharp para o curso de unidade. E nesta palestra vamos dar uma olhada na sintaxe C Sharp. Então vamos abrir o script aqui, o script de sintaxe. E vamos passar e ver o que podemos ver. Então, em primeiro lugar, se tivermos dois cortes aqui, este é um comentário, como diz. E então também podemos ter comentários multi-linha. Se fizermos uma barra e, em seguida, estrelar, e, basicamente, fazer outra estrela e uma barra invertida ou barra. E então cada vez que basicamente pressionamos Enter, criamos uma nova linha, novo peso de linha, ou podemos comentar. Então, isso seria comentários multi-linha. Às vezes pode ser importante explicar pedaços de código. Ou talvez tenhamos algo a fazer e depois podemos escrever algo como fazer e depois adicionar mais coisas. Isso é meio que, às vezes, pode ser importante. Para o Commons. Não vamos entrar no tipo de argumento ideológico se os comuns são bons ou maus. Só estou aqui para dizer que há comentários, basicamente, certo? Já vimos a declaração onde simplesmente colocamos o tipo de variáveis, o tipo de dados no nome da variável. E então a atribuição é simplesmente atribuir um valor a essa variável. Aqui nós realmente colocar saída uma string, digite a variável I. Já vimos isso na última palestra. Agora, esta é simplesmente uma maneira que podemos combinar basicamente uma variável neste caso, bem como uma string e, em seguida, imprime ambos. Depurar log de pontos. Neste momento, não precisamos entrar nos detalhes. O que isso significa? Bem, isso simplesmente significa que nós emitimos algo para o console dentro do Unity. Mas muito importante, isso é específico da unidade. E sim, então se você estiver usando apenas C-sharp, isso não funcionaria. Você precisaria usar outra coisa. É por isso que esta é uma introdução nítida para a unidade. Se quisermos acessar variáveis e métodos de objetos, então podemos fazer isso. Agora, variáveis, sabemos que variáveis são escrever isto como esta é uma variável, inteiro. Eu escrevo que é uma variável que tivemos o booleano está de castigo, que era uma variável certo? Agora, o que são métodos e objetos? Nós vamos entrar nisso também um pouco mais tarde em uma palestra diferente. Mas agora, podemos pensar nisso como um objeto basicamente sendo algo onde podemos armazenar variáveis e métodos. E um método é simplesmente várias linhas de código condensadas em como uma expressão. Pense nisso assim. Então, por exemplo, neste caso, quando temos, queremos o comprimento da corda S, certo? Podemos fazer o comprimento do ponto S. Neste caso, o comprimento é uma variável porque é apenas, é apenas escrito sem os parênteses na parte de trás. E como você pode ver, S ponto normalizado neste caso tem parênteses aqui. E os parênteses indicam que esta é uma chamada de método. Então essa é a diferença lá e nós acessamos coisas dentro de um objeto com o operador ponto. Então, se eu escrever S e depois um ponto, então, como você pode ver, há um monte de coisas que eu posso acessar a urina e fazer. E vamos analisar isso com mais detalhes em futuras palestras. No começo. É um pouco difícil porque se você não tem nenhuma linguagem de programação, e, você sabe, precisamos começar em algum lugar. E no começo estou me referindo cada vez mais a futuras palestras, o que, conforme avançamos, não vai acontecer tanto. É só que, neste momento, estamos a tentar basicamente arrancar a partir do básico e depois continuar, certo? Então essa é a idéia de que podemos acessar algumas coisas dentro de nossas variáveis. Por exemplo, curiosamente, então temos a IA aqui, que podemos, claro, fazer a mesma coisa com os olhos. Então, se o fizermos eu ponto e como você pode ver, há também algumas coisas que podemos fazer, neste caso, menos do que poderíamos fazer com a corda. Porque o inteiro simplesmente não tem, não tem tanta funcionalidade para ele. É assim que você pode pensar nisso, certo? E há também uma outra coisa. Os colchetes são basicamente pode definir blocos de código. Estes também são chamados de escopos. Então este seria um escopo diferente. E a idéia é que dentro disso, então nós declaramos eu aqui no escopo do método de início neste caso. E este é um novo escopo. E agora porque este escopo direito está dentro do escopo do que veio antes dele, onde eu fui declarado em. Podemos acessá-lo. Agora, se declararmos X aqui, podemos colocá-lo totalmente bem. Mas se olharmos para isto, certo? Então, se pudermos fazer isso, e se fizermos isso, e como você pode ver, x é realmente marcado aqui como uma seta. E diz que o nome x não existe no contexto atual porque declaramos dentro deste escopo. E depois que estamos fora do escopo, então, no final deste colchete, ele não existe mais. E é por isso que às vezes isso pode ser útil. Você pode basicamente defini-lo. Defina um novo escopo simplesmente colocando os colchetes. E estes também são usados se definirmos métodos mais tarde abaixo da linha. E então ele vai ficar ainda mais claro. Mas também podemos colocar em escopos como este. E então, por exemplo, podemos simplesmente colapsá-los também. Pode ser útil às vezes para o gerenciamento de código, apenas para torná-lo um pouco mais arrumado ou algo assim. Mas sim, sim, isso é basicamente como uma visão geral da sintaxe aqui. Tendo olhado novamente para a declaração e atribuição, isso é meio importante do que a saída aqui. Muito importante que seja específico para a unidade. E sim, vamos, nós podemos realmente olhar para a saída apenas para o inferno disso. Mais uma vez, certifique-se de que você está na sintaxe. Vamos apenas brincar. E ele vai produzir o único comprimento da string é 11. E depois temos um 0. Esse era o X dentro do escopo diferente, certo? Sim, e foi isso para a sintaxe. Na próxima palestra, vamos fazer alguma coisa. Vamos olhar para o número inteiro e os operadores aritméticos. Então vamos começar a usar algumas das variáveis e alguns dos tipos de dados que aprendemos sobre. E sim, foi isso. E se houver alguma pergunta, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 6. (C#) Inteiros e operadores de (C#): Muito bem, bem-vindos de volta à introdução do curso da unidade. E nesta palestra vamos dar uma olhada em inteiros e operadores aritméticos. Então vamos apenas abrir o script inteiro aqui. E vamos ampliar um pouco. E muito importante que você faça tudo o que você vai fazer dentro deste começo aqui. Então, em vez deste escopo, e sim, vamos começar. Então vamos definir dois inteiros. Vamos chamar o primeiro 1 primeiro e talvez o segundo 1 segundo. Isso funcionaria. Então o primeiro agora, então a variável com o nome primeiro agora tem 100 escritos nele, e segundo tem 200 escritos nele. Agora o que podemos fazer é fazer matemática. Agora. Primeiro, não se preocupe com isso. Nós só vamos fazer, digamos as coisas simples de matemática agora. E sim, então a primeira coisa que vamos fazer é adicionar. Então, vamos juntá-los. Então vamos apenas dizer que a soma inteira é igual ao primeiro mais segundo. E isso seria, claro, 300. Você também pode apenas depurar ponto logout isso. Adição. Note que definitivamente não é isso. Chama-se Diego e depois temos. Então, se dermos uma olhada nisso, então vamos pensar sobre isso. Nós declaramos uma variável chamada soma, e então nós imediatamente atribui-lo primeiro mais segundo. Então este mais, como você pode ver, este é o, este é um operador com dois inteiros. Se eu puder pairar sobre ele, aí vai você. Então, na esquerda e na direita, e isso apenas adiciona esses dois juntos. É tudo o que faz. Acrescenta 100, neste caso, primeiro e depois segundo, 200. E isso vai resultar em 300. E só para você saber, para verificar novamente, vamos ver Vamos apenas executar isso como você pode ver 300. Certifique-se também de que você está na palestra três inteiros. Muito importante. Mas sim, funciona. E eu ficaria surpreso se de repente isso não funcionasse. Eu também era muito interessante. Então, se pudermos, é claro, fazer isso com, por exemplo, primeiro mais, você sabe, nós podemos fazer mais Arno como 500. E depois mais, mais segundos, algo assim. Sabe, isso também funcionaria. Podemos basicamente colocar as variáveis e inteiros diferentes também. Então, como 500 anos, nós também podemos, por exemplo, dizer, Bem, vamos colocar em mais 200 lá, algo assim, que também funciona. E, em seguida, se pudermos apenas copiar este bloqueio de depuração, isto é, às vezes, eu faço isso muito rapidamente. É por isso que eu mencionei isso agora. Então o que eu faço é, basicamente, marcar isso direito. Então eu me certifico de que isso é selecionado. Então eu pressiono Controle C. E então eu coloco, eu vou aqui até o fim da linha e eu pressiono o controle V. E então ele só, então ele vai basicamente colá-lo na próxima linha. Então você provavelmente vai me ver fazer isso em futuras palestras como um pouco. É que, você sabe, quando você está, digamos, programando por um tempo, então tipo de coisas às vezes são automatizadas. Então eu só queria mencionar isso. Eu provavelmente vou mencioná-lo em algumas das futuras palestras também. Eu só queria dizer que é assim que você pode fazer isso. Sabe, marcando algo, certificando-se de que está selecionado Controle C, Controle V, e então será feito. E eu economizo com o Controle S. Ou você também pode ir até aqui para os seguros. E então ele também vai salvar para o, para o banheiro. O que esse disquete escreve? O ícone Salvar. E vamos ver o que sai por aí. Deve ser 1005, se eu estiver correto, eu acredito, sim. Sim. Ok. Isso é bom. Minhas habilidades matemáticas ainda estão boas. Mesmo que possa haver um pouco de lista, mas sim, isso também funciona. E isso é meio legal o que podemos fazer além disso, mas quero dizer, isso é apenas a adição. Vejamos a subtração. Essa vai ser a próxima grande coisa. Então, o que é isso? Então vamos apenas dizer inteiro Sub é um primeiro segundo menos. O que poderia ser isso? Bem, isso seria negativo 100. Isso é interessante, é 100 menos 200 é negativo 100 porque os inteiros também podem ser números negativos. Não há nada a dizer que isso não funcione. Então vamos fazer sub e vamos apenas imprimir isso também. E então vamos ver se isso realmente funciona. Se isso é negativo 100 e, de fato, é negativo 100. Então isso é um tipo de coisa importante notar que inteiros neste caso também podem ser negativos. Há também inteiros que não podem ser negativos. No entanto, eu intencionalmente pulei aqueles carros. Eles geralmente não são necessários em basicamente como 98% das posições políticas. Então, vamos ignorá-los por enquanto. Se houver necessidade, você sempre pode fazer uma pergunta e eu vou ter certeza de dar-lhe mais algumas informações. Agora vamos entrar em algo que também é interessante, que é a multiplicação. Então, digamos que em toupeira é igual a 4 vezes primeiro, isso seria 400. E isso funciona porque não? Vamos imprimir isso. E vamos imprimir verruga aqui. Isto deve funcionar. Então quatro vezes 100 deve ser 400. Parece legítimo. Vamos imprimir isto e ver se também funciona. E, claro, está tudo bem. Então, como você pode ver, o operador de multiplicação é esta estrela aqui. Isso é, sim. E o mais e menos deve ser auto-explicativo. Eu acredito que isso também é uma espécie de estrela padrão. E então se formos mais um para a divisão ou para dividir, então podemos dizer que a div é igual a segundo, dividido primeiro. Isso seria dois porque estamos dividindo 200 por 100. E também podemos imprimir que um fora ou depurado no login com o div, certo. E sim, isto é, então esta é uma barra neste caso, duas barras sendo um comentário, uma barra sendo a divisão. E como sempre com regras matemáticas normais, basicamente, mais ou menos a ordem das operações não importa, certo? Então, segundo mais primeiro é o mesmo que primeiro mais segundo vezes. Alguma multiplicação também não importa. Divisão de subtração, na verdade importa de que maneira, o que vem primeiro e o que vem em segundo. Mas eu acho que isso é eu acho que foi como matemática básica do ensino médio. Isso deve ser descoberto. Certo. E depois temos um 2. Lá vai você. Então isso realmente funciona bem. E há mais uma coisa que você provavelmente vai ser como, o que faz outra embora? Esses foram os quatro que eu conheço, sim, mas há também um que é chamado de módulo ou o restante. Agora, você provavelmente, se você é talvez como Arno, como o nono ano, talvez décimo ano, talvez você já tenha visto isso antes. Esta é a idéia é que se você dividir algo por outra coisa, neste caso, foi perfeitamente uniforme. Então funcionou bem. Mas também pode ser que se você dividir 13 por 213 dividido por dois, isso não vai funcionar, certo? Então isso vai ser, uh, não vai caber perfeitamente. E assim teremos um resto de um neste caso. Então vamos ver um exemplo disso. Então restante, restante é igual a 24, digamos, e então o operador restante, o operador módulo é o sinal de porcentagem 2 e isso seria 0. Então vamos colocar isso aqui também. Então isso vai ser, certo, isso vai ser 0 porque 2 se encaixa uniformemente em 24. Então, se dividirmos 24 por dois, como você pode ver, 0 restante aqui. No entanto, se nós, por exemplo, vamos para isso e dizer dividido por ou módulo 5, então isso não será mais 0. Vamos apenas fazer isso. São quatro porque o número mais próximo que chegamos dividindo por 5 é 20, certo? Então quatro vezes cinco é 20. E então para 24, quatro números são basicamente remanescentes. Então os quatro aqui permanecem. Eu quero fazer isso com um 23 apenas rapidamente porque 4 vezes 5 pode ser talvez um confuso. Haverá três, então chegaremos a 20 e então cinco não cabem em três. Então, três é o restante. Essa é a ideia. Na verdade, é um pouco importante em alguns aspectos. Então, o módulo 2 é ótimo para saber se um número é ou não par ou ímpar. Porque se você tem inteiro modulo operador 2 igual a 0, então você sabe, este é um número par. E se for igual a um, então sabemos que é um número ímpar. Então esse é um dos casos de uso em que o operador modulo ou restante é incrivelmente útil neste caso. E, claro, outros tipos de operadores aritméticos também são úteis em, bem, quero dizer muitas maneiras. Se você já precisou de algo em matemática, isto é, sim, esses são incrivelmente úteis e esse é o primeiro passo para saber ou para reunir algum conhecimento sobre como usar inteiros. Neste caso. Em teoria, tudo aqui. Você também pode substituir tudo aqui por carros alegóricos ou duplos. E tudo funcionaria bem também. Então você pode fazer isso, por exemplo. Experimente um pouco com isso. Eu sempre tento encorajar isso também porque enquanto as palestras aqui são realmente boas para obter uma espécie de vantagem ou para ter uma maneira estruturada de passar por algum material. Eu sempre encorajei e digo que é muito importante que você experimente as coisas por conta própria também. Porque essa é a melhor maneira de solidificar e aprender ainda mais. Então, se por exemplo, você vai olhar para isso com carros alegóricos, basta substituir todos os inteiros por carros alegóricos e ver o que acontece. E então você pode brincar com isso um pouco. E sim, isso é só uma pequena ideia para você. E sim, no geral isto é, que seria para os inteiros e os operadores aritméticos. Da próxima vez vamos dar uma olhada em um pouco mais dos métodos matemáticos que temos em C-Sharp. Então, mais algumas, digamos especializar coisas como uma raiz quadrada ou algo assim, que às vezes podemos precisar para coisas diferentes. Então é isso que vem na próxima palestra. Espero que isso tenha sido útil para você. E se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu responderei. E sim. 7. (C#C#: Muito bem, bem-vindos de volta ao “C Sharp “introdução aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em alguns métodos matemáticos que C-sharp tem para oferecer para nós. Então, mais uma vez, garante que a palestra para métodos de matemática está aberta e então podemos simplesmente abrir o script. E eu já preparei dois inteiros aqui, x e y. E vamos ver que tipo de métodos temos. Agora, a primeira coisa a notar, há dois tipos diferentes de matemática, basicamente bibliotecas que podemos acessar. Podemos acessar a biblioteca de matemática normal com basicamente fazendo matemática de ponto do sistema. E este nos oferece algumas coisas como maxing, max, max e Min métodos, a raiz quadrada e também algumas outras coisas. No entanto, isso é específico para C-sharp. No entanto, vamos usar a matemática F, Basicamente coleção como você pode ver. E este oferece específicas, basicamente quase as mesmas coisas, mas métodos específicos que são para a unidade. Portanto, isso só é acessível se você estiver na Unidade. Se não, então você precisa usar este método de matemática System.Out em, por exemplo, certo? Então, as primeiras coisas primeiro, que tal Max e Min? Eu já meio que estraguei isso. Vamos fazer um log de pontos de depuração. E então dentro dele, vamos fazer matemática F dot Min. E então vamos passar em x, y. e isso deve ser 225. Então a idéia aqui é que isso fazer matemática F ponto Min. E então, como você pode ver, temos um parêntese em torno disso. E então denotando que esta é uma chamada de método. Agora, neste caso, e nós não vimos isso. Na verdade, temos duas coisas lá dentro. E então esses são o que nós chamaríamos de parâmetros. Como eu disse, vamos olhar para como os métodos funcionam de maneira, muito mais detalhes em uma palestra posterior onde falamos sobre métodos e vamos aprofundar sobre como eles funcionam e o que eles são e o que isso é. No entanto, neste momento, podemos ver que temos duas premissas aqui, e elas são separadas por uma vírgula. E isso irá avaliar se nós realmente passar o mouse sobre ele, como você pode ver, retorna o menor de dois ou mais valores. Assim, também podemos colocar em mais valores. No nosso caso, só temos dois. E isso, é claro, isso não está certo. Então isso seria um 100, desculpe. Então, se nós min isso, ele vai retornar o menor desses dois valores. No nosso caso, vai ser 100. E só para estar completamente cheio aqui, vamos mudar isso para o máximo e então isso vai ser 225. Porque o máximo é claro, retorna o maior de dois ou mais valores. Vamos sair e ver se funciona. Então este deve ser um 100 e, em seguida, 225. E como podem ver, os primeiros cem, duzentos e vinte e cinco estão sendo registrados. Então vamos lá ver. Então esses são os métodos Min e max. Também podemos olhar para, por exemplo, uma raiz quadrada, certo? A raiz quadrada, Vamos apenas copiar rapidamente a depuração aqui. E então vamos fazer matemática “F dot raízes quadradas”. Então este é o SQRT. E então dentro daqui, vamos colocar em y. porque você realmente pode ser como um quadrado enraizado imediatamente. Isto vai entrar em ser um 15. Raiz quadrada de 225. E não vamos olhar para a saída ainda. Vamos apenas para o próximo, que vai ser o valor absoluto. Então valor absoluto é basicamente usado se você tem algo que é um negativo. Assim, por exemplo, 2500 negativos. E você quer apenas o valor absoluto e não o negativo. Então você não se importa se é negativo ou positivo ou não, você só se importa com o valor real. Você pode ver retorna o valor absoluto do valor. Então, o que quer que coloquemos aqui, ele vai retornar o valor absoluto. Vamos ver as saídas desses dois. Então o primeiro deve ser 15, que é a raiz quadrada de 225. Exactamente. E o último, é claro. O último não abriu. Oh, porque eu não salvei. É por isso que sim. Eles vão. E, em seguida, se eu entrar aqui novamente e apertar Play, em seguida, ele vai para a saída 2500. Eles vão porque esse é o valor absoluto de 2500 negativos. E depois há mais algumas coisas. Por exemplo, os métodos de vedação e piso, que são interessantes, por exemplo, para teto e piso bem. A idéia é que se você tem números flutuantes específicos, então isso vai ser selo como seus números flutuantes flutuantes. Então, por exemplo, 22.1, 45. Então talvez o que queremos também, na verdade, queremos um arredondado, mas queremos arredondá-lo para cima, independentemente do que está depois do ponto decimal. E então este vai ser um 23. E se fizermos isso rapidamente e depois fizermos andar aqui, e isso vai ser um 22 porque neste caso estamos, estamos arredondando para baixo. Então, como você pode ver, retorna o maior inteiro, menor ou igual a f, ler. E selo vai ser o menor inteiro maior ou igual a f simplesmente significa que estamos basicamente, assim que isto é como 0,0001 aço, nós vamos subir e, em seguida, neste caso, vamos para baixo. Então, neste caso, vamos para o teto. Neste caso, vamos para o chão. Deve fazer sentido nisso dessa forma. Mas sim, esses são basicamente para arredondar para cima e para baixo. Especificamente, também temos uma rodada. Acho que devemos fazer uma rodada. Não tenho 100% de certeza. Sim, temos por perto. Então, uma rodada, ele vai arredondar para o inteiro mais próximo. Isso também deve fazer um como uma saída 822. Porque neste caso, sim. Oh, não, eu não salvei novamente, o inacreditável. Isso é muito incomum, mas também deve abrir um 22 e ele faz. Então o arredondamento segue o normal. As regras normais de arredondamento, eu acho que nós também temos o poder de, então se pudermos ter algo como Math.Pow, isso é tão dez para o poder de dois. Então este seria dez para o poder de 2 é igual a 100. Você poderia, claro, também fazer 10 vezes 10 também iria trabalhar. No entanto, às vezes você precisa colocar algo ao poder de algo. Então é para isso que os poderes. Então retorna F elevado para a potência p. E, em seguida, o último, que pode ser, pode ser interessante, é basicamente apertar a variável variável Val de aperto entre dois valores. Esta é uma coisa muito específica que pode ser usada especificamente para a unidade. E nós realmente não vamos imprimir nada porque isso não é porque, bem, não há nada para imprimir agora. No entanto, a idéia de feixe, e nós vamos olhar para isso em outro exemplo mais tarde na linha também. Mas a idéia é que o grampo, como você pode ver, aperta o valor dado. Então isso seria velocidade Dado o mínimo e o máximo. Então a idéia é que a velocidade agora era de 100. E poderíamos imaginar, talvez, por exemplo, um jogo de corrida onde realmente aceleramos ou desaceleramos. Deve haver, em algum momento, essa velocidade máxima. E se nós só temos algo que é cheque, Hey, é este botão pressionar para baixo e, em seguida, adicionar velocidade em velocidade em velocidade. E então poderíamos imaginar, bem, realmente apertar isso para baixo. Então, ele vai basicamente certificar-se de que esta variável de velocidade está dentro desses dois valores mínimo e máximo. Mas como eu disse, um melhor, nós vamos ver um melhor, Vamos dizer caso de uso para esta laranja, realmente caso de uso para isso mais tarde na linha também. Eu só queria mencionar isso. Existem outros métodos interessantes aqui. Por exemplo, há um seno, seno e tangente. Então há isso basicamente quase todas as coisas que você pode precisar para a matemática. Há infinito, creio eu. Se eu ver, sim, Pi também está lá. Então, há algumas coisas que você pode dar uma olhada e brincar com também. Mas isso é apenas uma espécie de visão geral agora. O poder de selar valor absoluto, raízes quadradas, valores Min e max. Esses são os que na minha experiência são, bem, eu diria que o mais útil, mas mais frequentemente usado, especialmente o minimax, são usados um pouco. Mas sim, isso é uma introdução geral aos inteiros e que os métodos matemáticos. E sim, foi isso para esta palestra. Espero que tenha achado útil. Se houver alguma pergunta, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 8. (C#) Operadores de atribuição: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nos operadores de atribuição. Agora já vimos o operador de atribuição padrão. Foi aí que nós simplesmente atribuímos um valor a uma variável. Mas há alguns casos especiais em alguns operadores de atribuição que tornam um pouco mais fácil calcular basicamente coisas. Então vamos apenas abrir o script de atribuição aqui, e vamos apenas começar com um inteiro simples chamado I. Faça isso igual a um. Agora, se, por exemplo, gostaríamos de adicionar um a isto e depois guardá-lo de volta para I. Poderíamos fazer I igual a I mais um. Isso não deve ser muito louco e deve ser uma espécie de auto-explicativo. Nós simplesmente atribuímos o valor de I mais um porque eu sou um. Neste caso, nós vamos calcular 1 mais 1, e então quando eu salvá-lo de volta na própria variável, então neste caso isso seria 1 mais 1. Vamos escrever assim. Agora. Podemos escrever assim, totalmente bem. Também podemos escrevê-lo assim. I mais é igual a 1. E isso é funcionalmente equivalente a isso. Então nós vamos basicamente adicionar um à variável original I, e então nós vamos atribuir-lhe essa variável. Então, neste caso, isso seria 2 mais 1 é igual a 3. Então, porque depois da linha 13, eu tinha 22 anos e eu vou levar 21 para ele. E depois vamos escrever de volta para mim, por isso, neste caso, seriam três. Agora há outra coisa que podemos fazer e que é eu mais, mais. E isso fará exatamente a mesma coisa também. Então este seria, neste caso, I mais 1. E porque eu tenho três anos, este seria um quatro. Então nós também podemos fazer I menos, menos, e isso iria então se transformar em i negativo um ou menos um e que é então um três. Então esses são alguns básicos, basicamente como você pode condensar a adição de uma variável. Neste caso, você pode, é claro, traçar o plus é igual. Pode escrever o que quiser. Você pode escrever um 12014, outra variável, o que quiser. No mais, mais, isso sempre vai ser um mais um ou um menos um. Isso seria o que é chamado de incrementação ou incremento e decremento. E isso é realmente útil para algum tipo de estruturas que vamos olhar em C-Sharp descendo a linha. Agora isso mais é igual, nós podemos realmente fazer outras atribuições também. Então, como você viu, então tivemos um plus igual. Então, digamos, por exemplo, mais é igual a 5 e 14, certo? Este seria então um 17 igual a 17, algo assim. Então nós poderíamos fazer menos igual a apenas por causa do argumento agora este menos dois vai levar a um 15, certo? Então também podemos fazer menos iguais. Também podemos fazer vezes iguais. Vamos fazer dois de novo. Então este seria um 15 vezes 2 é igual a A3. E então podemos, por exemplo, fazer dividir iguais também, dividir por três. Então este seria 30 dividido por 3 é igual a 10. E então, no final, nós também podemos fazer modulo igual e isso seria um 10. O modelo acima de quatro é igual a 2. Agora, eu raramente vi os modulares iguais na verdade, mas os outros podem ser realmente úteis em algum momento abaixo da linha. E como eu já disse em uma palestra anterior, pode ser o caso que, embora você possa não usar alguns desses operadores, alguns outros podem usá-los. E se você não sabe o que eles são, então você vai ter mais dificuldade em ler o código de outras pessoas. É por isso que eu sempre digo que mesmo que você seja, tendem a não usar algo onde mesmo que você seja como, Bem, talvez eu vou mantê-lo assim porque mais uma vez, isso é completamente o mesmo que este aqui, certo? Então escrever I é igual a I mais 1 é o mesmo que eu igual a 1. Algumas pessoas dizem, bem, isso é mais fácil de ler. Eu entendo isso melhor. Algumas pessoas dizem que eu entendo isso melhor. Isso é definitivamente apenas uma escolha de estilo. E você pode fazer qualquer um deles. Quando se trata de performance. Realmente não há diferença. Então, sim, esses são os diferentes operadores de atribuição também. Espero que tenha achado útil e aprenda algo novo. Se houver alguma dúvida. Claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 9. (C#) Booleans e operadores de comparação (comparação, (de comparação.: Muito bem, bem-vindos de volta à introdução C-sharp para o curso de unidade. E nesta palestra vamos dar uma olhada em Booleans e especificamente comparações e como colocar em como escrevê-las em variáveis booleanas. Então vamos abrir o roteiro Booleans e ver o que podemos ver. Então, lembrando de volta, tivemos a variável é fundamentada e vamos definir isso como falso. E a Áustria, lembre-se, Booleans eram valores de verdade que podemos definir como verdadeiros ou falsos. Então eles podem ser sim ou não, um ou 0. Essa era a essência disso. E talvez, por exemplo, temos um booleano que é chamado x. e então o que queremos realmente atribuí-lo a um cálculo. Então, um cálculo booleano ou apenas uma expressão, uma expressão booleana, por exemplo, dois é menor que cinco. Esta seria uma expressão booleana. Como você pode ver, o a, um operador, o operador menor adicionado isso retorna um booleano. Neste caso, isso seria verdade porque 2 é menor que cinco se fosse o contrário. Então, por exemplo, desta forma, dois seriam maiores que cinco e isso seria falso. Então esta é a idéia de um operador de comparação. Claro que também podemos ter um bully bool. Por quê? Por exemplo, 10 é, 10 é maior que 50. E isso, claro, seria falso, certo? Porque, claro, Sen não é maior que 50. E é por isso que a expressão aqui é falsa. Há uma abundância de diferentes operadores de comparação. Então vimos o menor que, maior que maior ou igual, menor ou igual, igual e não igual ou desigual. Então isso seria, por exemplo, isso é como um 100 é igual a 100. Isso seria verdade, certo? E isso porque, neste caso, um 100 é exatamente igual a um 100. Agora, como você pode ver, isso às vezes pode parecer um pouco confuso porque o operador igual são dois sinais de igual e o operador de atribuição é um sinal de igual. Isso é algo que você definitivamente tem que olhar para fora porque às vezes ou você esquece um dos sinais de igualdade ou talvez você está apenas programando entusiasticamente e então você apenas supervisiona que ou você só colocou em um igual sinal ou dois sinais iguais. São coisas completamente diferentes e não têm nada a ver um com o outro. Uma é a expressão booleana para ver se duas variáveis ou duas coisas são iguais. E o outro atribui um valor a uma variável. Apenas como uma nota rápida. E então, por exemplo, podemos ter algo assim. Então 51, desigual, 50. E isso também seria, naturalmente, verdade. E este é um desigual. Ou o que mais poderia ser, não igual, algo assim. Mas esses são os operadores de comparação. Então eles podem ser incrivelmente úteis para comparar diferentes variáveis entre si. É algo maior ou igual a algo, é simples igual a outra coisa. Incrivelmente útil, aplicações generalizadas que vamos ver nas próximas palestras também. Mas é isso. Assim como uma pequena introdução ao booleano e os operadores de comparação. Se houver alguma pergunta, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 10. (C#) Booleans e operadores lógicos: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em Booleans mais uma vez. Então vamos reabrir o roteiro Booleans aqui. E neste caso, o que vamos olhar não são os operadores de comparação, mas vamos olhar para os operadores lógicos. A idéia é que nós tivemos essas expressões booleanas como menores que cinco ou 10 é maior do que 50, o que pode ser verdadeiro ou falso. Então eram expressões ou declarações que eram verdadeiras ou falsas. Então eram expressões booleanas. E agora nós podemos realmente acorrentá-los juntos. Então, por exemplo, nós fazemos, nós vamos fazer um novo booleano aqui, B2. E então o que podemos fazer é dizer x e y. Então, se fizermos este sinal duplo comercial, então isso vai ser, esta é uma operação final. E a idéia aqui é que vai ser x e y. Agora x é verdadeiro e y é falso. Portanto, toda esta declaração não pneu aqui também é falsa porque este é um operador AND. E o operador basicamente é verdadeiro se ambas as declarações de estado são verdadeiras também, então há outro que é o operador OR. Então isso, por exemplo, podemos tomar é de castigo ou B. E isso neste caso seria verdade. Agora a razão é porque B é verdade, certo? Então sabemos que B é verdade. Seu B era um 100 é igual a 100. E isso é verdade. E o operador OR basicamente é verdadeiro se um dos dados, se um ou ambos os Booleans dado ou declarações é verdadeiro. E há uma última coisa que já vimos antes, e isso é apenas o ponto de exclamação. E isso simplesmente inverte tudo o que é dado. Então, neste caso, este é basicamente o operador NOT. Então, não é verdade é apenas falso, certo? Então isso simplesmente inverte ou inverte o valor booleano. Então, em teoria, o que poderíamos fazer é colocar os parênteses em torno disso. Eu poderia colocar um ponto de exclamação na frente dele e então ele iria negar tudo o que está no ano. E eles também são como matemática extravagante que você pode usar. As palavras que você procuraria, para isso seria ou tabela de verdade ou álgebra booleana. E então você pode imaginar que talvez você tenha algo louco como isso, certo? Você tem que B2 e B4, ou B3 e x ou y, ou que tal ou ver alguém assim, certo? Então não podemos ter algo louco assim. Seria, ele funciona totalmente bem se você, é claro, tem que basicamente avaliar cada um deles separadamente. Mas você também pode simplificar algo como isso para uma versão muito menor da mesma função basicamente que temos aqui. Bem, a mesma expressão e isto foi, isto é o que se chama álgebra booleana. Para que pudéssemos simplificar isto. Eu não vou, se no entanto, há como um monte de interesses nisso, eu posso fazer uma palestra separada para ele. No entanto, eu diria que raramente é realmente necessário. É mais algo teórico e isso é realmente importante na ciência teórica da computação e, claro, às vezes também aplicada ciência da computação. Neste caso, quando você tem incrível, incrivelmente longo como declarações booleanas, então faz sentido olhar para como você pode talvez torná-los um pouco. Ambos mais fáceis de entender e também podem ser mais fáceis de avaliar. No entanto, como eu disse, não é necessariamente a coisa mais importante. No entanto, se houver interesse suficiente na frente das pessoas, quer ver isso, então eu estou feliz em fazer uma nova palestra sobre isso. No entanto, agora este é o, basicamente os operadores lógicos, o operador AND, o operador OR e o operador NOT ou o inverso. Quero dizer, é chamado de operador NOT. E sim, isso é basicamente os três principais operadores lógicos, que com os quais você pode basicamente fazer tudo em lógica. E sim, esses são os dois termos que você, se você quiser, talvez olhar para algumas outras coisas também que têm a ver com isso. Esses são os dois termos que você deve olhar. E se houver alguma dúvida sobre isso, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 11. (C#C#: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas cordas. Então, mais uma vez, certificando-se de que estamos na Lecture 8, cordas aqui em cima. Caso contrário, você pode simplesmente ir para a pasta Cenas e abri-lo. E, em seguida, certificando-se de que dentro de nossa pasta de scripts, nós clicar duas vezes sobre essas strings script. E aqui estamos nós dentro do nosso roteiro. E vamos começar por realmente fazer uma nova corda. Então, a frase da corda, por exemplo, vamos fazer com que diga “Olá Mundo”. Esta, esta palestra é maravilhosa. Bem, vamos esperar que isso seja verdade. Mas antes de tudo, como já vimos, a idéia de uma string é que ela é vários caracteres próximos um do outro. E a primeira coisa que vamos olhar é basicamente mais uma vez, o comprimento. Já vimos isso antes. Então, o comprimento da corda. E isso foi, nós fomos capazes de acessar isso digitando o nome da variável, neste caso frase. E podemos autocompletar isso com tabulação e, em seguida, o comprimento do ponto, o comprimento. E então nós também poderíamos completar automaticamente isso com tabulação. E depois de salvarmos, podemos voltar para a Unidade. E vamos ver. O comprimento é 39. Bem, isso é ótimo. Então, vamos voltar. E vamos ver. Assim, o comprimento da string pode ser útil em muitas partes diferentes. Por exemplo, às vezes, talvez queremos como sub-strings ou certas partes de uma string e, em seguida, precisamos saber o comprimento. Vou ver isso em breve. Em primeiro lugar, vejamos maiúsculas e minúsculas. Isso pode ser útil, por exemplo, se você quiser, independentemente de determinada entrada, verificar se essa entrada é ou não a mesma. Mas neste caso, vamos basicamente converter a sentença em gritos. Então vamos digitar a frase ponto dois superior neste caso. Como você pode ver, isto é, isso termina com parênteses, que significa que esta é uma chamada de método, então isso chama um novo método. E então nós podemos apenas mais uma vez copiar isso basicamente simplesmente selecionando o log de depuração, pressionando Control C e depois Control V para colá-lo. E isso vai ser mais baixo. E isso vai ser, claro, sussurrando. Certo? E então, sim, vamos ver isso. Então tomar banho só para cima vai fazer tudo em maiúsculas. E diminuir é só fazer com que tudo, cada caractere dessa frase seja minúscula. Então, como você pode ver, gritar vai ser maiúscula e depois sussurrar. Tudo é minúsculo. Como eu disse, às vezes o que é interessante uma aplicação para isso é basicamente fazer com que seja o que for, independentemente de maiúsculas ou minúsculas, você possa comparar duas cordas umas com as outras e ver se elas ainda estão o mesmo independentemente de tudo ser ou não maiúsculo ou minúsculo. E, bem, vamos apenas olhar para a frase em si. Então, a própria primavera. Vamos também imprimir essa. Só por causa da discussão. Bem, o que nos respeitamos é tudo lento, pequeno mas minúsculo, mas como você pode ver, o H e o W ainda são maiúsculas. O quê? Por que é isso? Bem, a idéia é que mesmo que tenhamos chamado este método aqui, como você pode ver, ele realmente diz string e então ele diz string dot dois oper. Então, a idéia é que isso realmente tipo de ele, ele retorna uma nova string. Assim é, a sentença em si não está sendo modificada. E isso acontece com alguns dos métodos. Eu acredito que é quase todos esses métodos de string não realmente alterar esta variável original ou o valor mesmo. Eles sempre devolvem uma nova instância desta variável que é então alterada. Neste caso, em maiúsculas viu tudo é grande. E então este, todo minúsculo. Talvez o que queremos é descobrir onde algo está dentro dessa corda. E podemos usar o índice off para isso. Então vamos apenas fazer um bloqueio de depuração novamente. E então vamos encontrar a palestra de palavras. A palestra de palavras encontrada na posição. E, em seguida, vamos colocar a posição aqui em torná-lo fazendo o índice de ponto frase off. E então podemos passar uma corda aqui. E nós vamos dizer palestra, oh, isso não está certo. Lá vai você, palestra. E isso vai retornar o índice de onde os elétrons começam. Então vamos ver o quê, vamos contar primeiro. Então 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 19. Então vamos ver se nós realmente temos 19 ou o que estamos recebendo. Estamos recebendo 18. Bem, isso não é estranho? O IOM gosta de contar errado? Não, não contamos errado. Bem, nós fizemos de alguma forma. Mas não. A idéia é que uma frase, o primeiro caractere aqui, o primeiro caractere aqui é realmente 0. Então nós realmente temos que começar em 0. E se começarmos a contar em 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18. Então vemos que o L de palestra é realmente encontrado na posição 18 porque começamos a contar em 0 e isso é realmente importante, começar a contar em 0. Então isso é uma coisa importante na programação. A maioria das linguagens de programação começam lá, contam tanto de strings quanto de outros tipos de dados em 0. É meio importante saber. Porque às vezes pode levar à estranheza. Há também algumas outras linguagens de programação onde isso não é o caso e a contagem começa em 1. No entanto, é muito confuso alternar entre os dois. É por isso que estou dizendo, ok, comece a contagem em 0. Muito importante. Existe também um método de substituição. Então, neste caso, o método replace substitui todos os, todas as instâncias de uma frase específica, basicamente. Digamos que ele é chamado de método de substituição e queremos substituir o mundo por estudantes. E a idéia é que, oh, eu sei por que o ego, é por isso que o, é preciso duas cordas. A primeira é a string que deve ser substituída e, em seguida, a segunda string é com o que é suposto ser substituído. Então, neste caso, o que vai acontecer é que a saída vai ser Olá alunos. Esta palestra é maravilhosa em vez de olá mundo e esta palestra é maravilhosa. Vamos fazer isto e ver se funciona. Sim, Alunos Olá. Esta palestra é maravilhosa. E mais uma vez, não se esqueça que isso não está modificando as frases originais, na verdade nos dando uma nova. Então o que podemos fazer é que também podemos, quando temos uma nova string, por exemplo, string S, que vai ser apenas uma string vazia. Então esta seria uma string vazia. Também podemos dizer strings.xml para string vazia, mas esses são basicamente os mesmos. Então o que podemos fazer é basicamente ter um booleano. Então podemos chamar string é nulo ou vazio. Passe em uma string, neste caso S. E isso vai retornar verdadeiro se a string aqui é nula ou vazia. E ele vai retornar um falso se a string não é nula, novela, nem vazia, certo? E também podemos ver se como o que uma determinada corda começa com um, o que termina com, pode ser útil em momentos muito diferentes. Vamos apenas levar este. Isto vai ser com Stuart, e esta é frase começa com, começa com retorna um booleano. Então, basicamente, podemos dizer: “ Ei, começa com “H “? E então podemos dizer que termina com. E então nós apenas rapidamente para este aqui, termina com, e vamos dizer que ele termina com um grande A. E isso é claro que não é verdade. Então isso seria verdade. E isso seria falso. Isso está bem formatado. Aí está, isso é ótimo. Certo? Vamos olhar para isso depois de termos olhado para o próximo e o próximo é o método contém. O método contém simplesmente retorna verdadeiro ou falso. Então, um valor booleano se algo está contido nele ou não. Então digamos que queremos saber se a sentença contém ou não mundo. Isso é claro, porque o mundo é a segunda palavra aqui. E mais uma vez, a substituição não substituiu a frase. Ele realmente criou uma nova seqüência de caracteres em segundo plano. Então vamos ver. Sim, começa com um H. Começa com um H, H maiúsculo, e depois termina com um grande A, que era um A maiúsculo e que tem dobras. E então é uma verdade aqui para o contém o mundo das cordas. Há também uma espécie de maneira diferente. O índice aqui era um inteiro. Então basicamente o número onde o L da palestra começa, nós também podemos fazer o contrário para que possamos realmente obter um personagem em posição. Então vamos colocá-la na posição 10. E a maneira como fazemos isso é que estamos basicamente digitando a frase do nome. E então nós fazemos esses colchetes e, em seguida, digitando em qualquer posição é que nós queremos. Então isso retorna um personagem. E neste caso seria, eu acho que o D, eu acredito em um. Então 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. Sim. Então isso devolveria o D aqui no mundo. E algo que também tem a ver com isso é a substring onde também precisamos especificar posições. E agora em sim, então vamos fazer depuração log frase ponto substring e E Uma vez que um índice de início, e então ele quer o comprimento, ele vai. Então, basicamente, a substring, o que ele quer é saber, ok, onde eu começo e depois por quanto tempo eu vou? Então, neste caso, isso deve começar no t e terminar em, eu não tenho certeza, na verdade, 123456789, 10, 11, eu acho. Tour. Bem, nós vamos ver sobre isso. Vejamos, na verdade, esse é o caso. Vamos ver o que isso vai trazer. Então a substring é realmente sim, e que também tem o espaço lá dentro também. E eleger para esta palestra. E como você pode ver aqui, o D também é saída desta perna dois. Então isso seria 12 e não começaria em 13, eu acredito que se quiséssemos, queremos que ele imprima esta palestra, Vamos apenas fazer isso. E eles vão para esta palestra, ótimo. Isso é exatamente o que eu quero, certo? E isso é uma substring neste caso em que temos, quando pegamos uma parte particular da string e criamos outra. Então, mais uma vez, não modificamos a string em si. A maneira como modificaríamos a string poderia ser algo como esta frase, substring de ponto de frase, por exemplo. E então o que aconteceria é que ele iria criar esta substring fazer e, em seguida, salvá-lo de volta na própria frase para que a própria variável, de modo que iria funcionar. No entanto, não vamos fazer isso neste momento. Na verdade, não é bem o que precisamos neste momento. A última coisa que eu quero mostrar é se nós temos uma string e, em seguida, talvez o que nós queremos nesta string é que nós queremos ter aspas. Agora, o problema é que assim que eu digitar entre aspas, a string termina, isso é claro, não é bem o que queremos. E o que podemos fazer é fazer uma dessas barras invertidas. E essa barra invertida é basicamente um caractere de escape para que o programa saiba que, ok, isso agora é realmente destinado a ser aspas que estão na verdade dentro de uma string. Há também algumas outras coisas, como a barra invertida t, barra invertida, barra invertida, barra invertida. Se você quiser digitar uma barra invertida. Esses são basicamente os principais. Então as aspas de barra invertida, barra invertida t, barra invertida n. Então o professor simplesmente MIX guia. Então, se você pressionar tabulação, você guia sobre um certo número de espaços e faz uma nova linha. E a barra invertida, barra invertida simplesmente digita uma nova barra invertida. Então, como um personagem, o mesmo com, o mesmo que com essas aspas, certo? Sim, essas são as principais coisas sobre strings e alguns desses métodos de string. Mais uma vez, eu imploro que olhe para alguns deles você mesmo. Há mais alguns. Então, se olharmos para isso, o que podemos ver, há também comparar iguais, há inserção, hum, há um método de remoção. Então, há algumas outras coisas que podemos fazer também. Como eu disse, imploro que olhe para eles. Isso é apenas uma visão geral das molas, geralmente especialmente no desenvolvimento de jogos em si. Não é a manipulação de cordas não é tão comum como talvez em alguns outros campos. No entanto, às vezes você nunca sabe o que você vai conseguir. Então, é melhor saber sobre essas coisas e ter dado uma boa olhada nelas. Espero que isso tenha sido informativo para você. Se foi, então eu vou, é claro, apreciar uma crítica sua. E se houver alguma pergunta, é claro, como sempre, sinta-se à vontade para perguntar e eu responderei. E sim. 12. (C#) variáveis de fundição: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. E nesta palestra vamos dar uma olhada no elenco. Agora, o elenco pode não dizer nada para você. O termo pode ser bom. O que é elenco? Bem, vamos dar uma olhada abrindo o roteiro aqui. E a idéia é que vamos ver, temos uma variável chamada empréstimo, que é 750, e é um inteiro. Agora, o que também temos é um flutuador chamado taxa de juros. E isso vai ser, digamos, 5,25%. Então isso pode ser escrito como 0,05 a cinco. Agora o que podemos fazer é dizer, bem, o proprietário calcula os interesses. Bem, os juros são simplesmente o empréstimo vezes a taxa de juros, a taxa de juros que você vai, certo? Então isso não vai ser muito louco de um cálculo e deve ser bastante simples. E então vamos nos certificar de que nós apenas registramos o interesse agora. E vamos ver o que podemos ver. O que vai sair disso. Então ele vai sair de que é 39,375, ou vamos dizer 39 pontos, vamos dizer 3, $8, digamos. Agora, como é que isso funciona? Nós acabamos de pegar um inteiro e basicamente multiplicá-lo com um flutuador. Então a pergunta vem, como é que isso funciona? Isso, isso é meio estranho, certo? Por que podemos simplesmente pegar o inteiro e basicamente multiplicá-lo com um flutuador? Bem, isso é o que seria chamado de elenco implícito porque ambos são números e isso funciona. O que não funcionaria é, por exemplo, se eu dissesse, bem o interesse é agora um inteiro, então seria realmente um que não funciona porque como você pode ver lá, ele diz que não pode converter implicitamente para digitar float para int é porque este é um Flutuar. E se temos um inteiro multiplicado com float, então ele é convertido em um flutuador porque um flutuador tem mais informações do que uma interrupção. No entanto, eu posso dizer explicitamente Hey, independentemente, tratar isso como um inteiro. Então eu posso dizer bem int. E então vai ser como Ok, claro, a taxa de juros é agora um inteiro. O grande problema com isso vai ser, bem, o que isso realmente significa? Bem, vamos ver se ainda temos 39. Agora nós temos, nós temos 0. Como é que conseguimos 0? Bem, a idéia é que um inteiro não tem nenhum, nada depois da vírgula decimal, certo? Portanto, um número inteiro é sempre um número inteiro. Portanto, isso é convertido em um inteiro. E o que acontece quando um flutuador é convertido em um inteiro? Tudo depois da vírgula é cortado. Então basicamente o que a taxa de juros depois que ele está sendo convertido em um inteiro vê é 0. Então a taxa de juros é 0, portanto, o empréstimo é 0, o que, claro, não faz nenhum sentido. Ou se o interesse é, portanto, 0, o que não faz nenhum sentido. É por isso que queremos que isto seja um carro alegórico. Também podemos ver isso como outro exemplo. Digamos que temos um inteiro x e vamos apenas dizer algo como 50,5 f mais 20,6 f, certo? E nós estamos indo para agora um log isso para fora. Então vamos olhar para o que esperaríamos. Neste caso, um 71. Sim, 0.171.1. Agora é um inteiro. Então o que devemos ver é um 71, e de fato vemos um 71. Então, mais uma vez, neste caso, isso seria realmente 71.1. E então tudo depois do ponto decimal é cortado, portanto, é 71. E o que também é interessante aqui é quando dividimos algo, se dividirmos, por exemplo, um 100 por 200, F, por exemplo, certo? É gentil, às vezes é importante porque às vezes uma divisão não vai devolver números inteiros. Então, neste caso, é um número inteiro. Mas se nós, por exemplo, fôssemos fazer algo assim e então Claro, por que não dividir isso por duzentos e duzentos F. Então dividindo isso por um flutuador. E então vamos ver o que isso realmente produz. Como você pode ver, isso grita para apontar para 55. Agora, se dividirmos isso por 200, e então também podemos dizer que não flutua, na verdade não importa. problema é que este, então, é um dois. Então, às vezes é melhor se tivermos um flutuador aqui, às vezes é melhor trabalhar com inteiros. Uma nota que eu realmente quero deixar claro só para que nós tenhamos isso fora. Então eu usei este empréstimo e a taxa de juros apenas como um exemplo. Se você estiver trabalhando em um sistema bancário, seja no interior de um jogo ou na vida real, nunca use números de ponto flutuante. Sempre faça tudo com números inteiros. Então salve tanto o, tanto a quantidade total de dólares, bem como centavos em ambos em inteiros. Porque números de ponto flutuante, como eu já disse, são propensos a erros. E especialmente no arredondamento. E você realmente não quer erros de arredondamento quando se trata de dinheiro, isso vai ser um grande problema. Eu só queria mencionar que sempre usar inteiros se você fizer isso apenas como um lado rápido. Quando outra coisa que podemos fazer é que podemos realmente lançar personagens. Então o que podemos fazer é lançar o personagem, por exemplo, das castas superiores, oito, a maiúscula Então vamos fazer y. Agora é realmente ótimo aqui um pouco porque o elenco é redundante porque eu posso realmente apenas dizer, bem, int y é igual a um e que funciona bem. Vamos mantê-lo aqui só para que saibamos, ok, nós realmente fomos castrados. E se, em seguida, apenas executar isso, podemos ver que é um 65. Por que isso é 65? Bem, isso vem da maneira que os caracteres são basicamente codificados. E a codificação em segundo plano é apenas um número. Isso é tudo o que é. Então podemos realmente fazer algo assim. Então podemos dizer, por exemplo, 50, bem, não vamos 50, vamos fazer 12 mais isso, certo? Então, assim. E então nós também podemos converter o inteiro para um caractere e, em seguida, imprimir o que quer que seja. Então nós vamos basicamente ir de um e, em seguida, 12 codificações depois. Vamos ver o que é isso. Isso deve ser um outro. Isto é um “M ”. Então, há também uma quantidade de maneiras que podemos basicamente calcular o material com os personagens também. E essas são algumas das peças fundidas básicas. E também há conceitos um pouco mais avançados que vamos dar uma olhada em uma futura palestra. Mas agora nós não temos as ferramentas ou o conhecimento para isso realmente saber como isso funciona onde quer que esta seja uma visão geral básica agora. Então, podemos realmente converter alguns tipos de dados em outros tipos de dados. Na maior parte do tempo, implícito. Fundição implícita funciona. Se você passar de um tipo de dados que tem menos informações para um tipo de dados que tem mais informações. Então, de um inteiro para um flutuador funciona implicitamente. De um flutuador para um int não funciona implicitamente porque você perde informações, principalmente neste caso sendo o, tudo depois do ponto decimal, certo? Foi isso para a palestra de elenco. Espero que isso tenha sido informativo para você. Se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu responderei. E sim. 13. (C#) declarações condicionais (Se e mais): Muito bem, bem-vindos de volta à introdução C-sharp para o curso de unidade. E nesta palestra vamos dar uma olhada nos operadores condicionais. O que são operadores condicionais? Bem, são basicamente algumas palavras-chave que podemos usar para ver se algo é verdadeiro ou falso ou não. E então, dependendo se neste trofozoítos fazer certas ações diferentes ou executar revestimento diferente. Então vamos começar o script condicional aqui. E vamos ver o que podemos ver. Então, como você pode ver, vai ser o se e as outras declarações que nós vamos dar uma olhada. Mas antes de tudo, precisamos de algumas variáveis, então vamos ter um x e um porquê assim como um bool é bom curso. E isso é, claro que vai ser verdade. Esperemos que isso também seja verdade, mas tenho certeza que é. Bem, o que podemos fazer? Bem, vamos apenas digitar se esta é a declaração if. Agora o que podemos fazer é que podemos pressionar Tab duas vezes e, em seguida, ele vai gerar para nós a maneira em se declaração olha, como você pode ver, ele tem parênteses após o if. Então, dentro desses parênteses, há uma expressão booleana. Agora isso pode ser tão complicado ou tão fácil quanto você quer saber. Pode ser apenas um valor booleano, como verdadeiro. Pode ser uma variável booleana ou como vimos em palestras anteriores, uh, os operadores de comparação booleanos loucos ou algo assim. Então vamos apenas digitar x é maior que y. e então se esse for o caso, então tudo dentro deste escopo aqui é executado. Então vamos apenas dizer log de pontos de depuração. E então vamos dizer que X é maior do que porque eles vão, bam. E então, se esse for o caso, então isso é executado. Agora, é claro, nós já podemos ver que x é um 100 e y é 1000. Portanto, isso é definitivamente falso. O que podemos fazer então? Bem, então podemos apenas adicionar uma outra declaração. A instrução else, em seguida, é executado. Se isto for falso. Então, se isso é verdade, então isso é executado. Senão. Então, se isso não for verdade, então isso é executado. E neste caso, x não é maior que y. Vamos apenas executar isso e ver o que acontece. Mais uma vez, certificando-se de que você está em Lecture 10. E então, como você pode ver, x não é maior que y. e essa é a única coisa que é executada. Em vez disso, o que vimos aqui, o que vimos antes foi que vamos direto de cima para baixo e tudo, cada linha é executada. Neste caso, nós realmente temos um condicional. Então isso é uma espécie de coisa de ramificação. Neste caso. Depende do que acontece aqui. Interessante. De que outra forma podemos fazer isto ou o que mais podemos fazer com isto? Bem, em primeiro lugar, uma coisa a notar é que, por exemplo, se temos este é um bom vídeo, É bom curso aqui. O que podemos usar é que não precisamos realmente ter esses colchetes. Nós também podemos apenas pressionar Enter e, em seguida, ter uma linha que queremos fazer. Então, sim, é muito bom, por exemplo. E isso então é executado. Se isso for verdade. Também podemos, se copiarmos isto. E, neste caso, colocamos o Booleano. Também podemos dizer explicitamente: “ Ei, isso precisa ser verdade. Agora isso não é necessário porque tudo isso já faz isso. No entanto, algumas pessoas preferem isso porque torna um pouco mais explícito para o que isso realmente significa. Então, o que eu quero com isso? Eu, pessoalmente, prefiro usar esta versão. No entanto, se você acha que isso é mais legível para você, você pode, naturalmente, usá-lo também. O que eu também queria dizer é que, se você usar o M dessa maneira de escrevê-lo, então a declaração if e, em seguida, com a próxima linha recuada, eu diria que não é a melhor coisa a fazer. Porque se quisermos adicionar uma nova linha que também está dentro deste, se então precisaríamos adicionar os colchetes de qualquer maneira. Portanto, na verdade, é sempre a melhor coisa a fazer para adicionar os colchetes. Só queria mencionar essa, certo? Então vamos ver uma última coisa. Então, por exemplo, temos uma nota, por exemplo, certo? Vamos dizer algo como 99. Então talvez você, acabamos de escrever um exame e a nota é 99%. E então o que você pode imaginar é que talvez o que nós queremos é que nós também queremos coisas diferentes. A, B saída dependendo do que acontece com o grande. Então, por exemplo, se a nota for menor que 50, bem, então o que gostaríamos de imprimir é que você falhou na classe. Porque isso faz sentido, certo? Se você tem menos de 50, então isso faz você reprovar uma aula. Agora, se talvez quisermos, certo? E então você teve sucesso na aula, então você passou, certo? Você passou na aula. Se não são 50, no entanto, bem, talvez o que eu quero é que eu realmente quero ter isso, certo, porque você passou a classe, mas não quieto com, quieto com 100 pontos. Então talvez o que eu quero é realmente eu quero que isso seja chamado se a pessoa não tem um 100 pontos, mas já passou. E depois quero que outra coisa seja fria. Então o que podemos então fazer é que podemos fazer a declaração else if, simplesmente mudando o, outro if declaração aqui dizendo, por exemplo, a nota é maior ou igual a 50. Então este é exatamente o inverso desta extremidade direita. A nota é menor que 100. Então é entre 50 e 100. E então isso é chamado. Então você passou a classe, mas não completamente com um 100 pontos. E se então dissermos outra coisa, podemos então olhar para, por exemplo, fazer isso e depois ter isso. Você passou na aula, vamos ver, com em nós algo assim. E isso funcionaria. Então, agora temos 99. Então o que deve ser impresso é que você passou a classe, mas não completamente com 100 pontos. Vamos ver se é esse o caso. Você passou a classe, mas não exatamente com 100 pontos, exatamente. E então, se tivermos 100 pontos, então deve funcionar. Vamos ver. Na verdade, você tem classe, a classe passar a largura da classe em nós. Certo? Agora, há um pequeno fluxo lá dentro que você pode olhar para si mesmo. Talvez você possa descobrir e adicionar a isso no seu tempo livre. Porque se eu tiver 101% no ano, ainda passo na aula com honras. Como pode ver, ainda funciona. Talvez você possa adicionar uma nova expressão aqui ou talvez oito, outra declaração if. Mas isso é genuinamente apenas uma idéia para você. Se quiser brincar com isso, um pouco mais. Muito importante se e else declarações são um bloco de construção crucial da programação. Eles são basicamente uma das coisas mais importantes para descer. Portanto, esta é uma área de conhecimento muito importante que você precisa ter para programar. Então é por isso que eu realmente quero enfatizar, experimentar algumas coisas com as afirmações if e else. Brincar um pouco com ele. E se houver alguma dúvida neste caso, neste tópico, muito importante, Duke, faça qualquer pergunta que você tenha que talvez não seja completamente clara se houver algo incerto, por favor, faça uma pergunta. Eu vou ter certeza de responder como sempre. E sim. 14. (C#) operator ternário: Muito bem, bem-vindos de volta à introdução do curso da unidade. E nesta palestra vamos dar uma olhada no operador ternário. Primeiro, o operador ternário parece que é incrivelmente complicado e algo muito louco. Não é de todo louco. Na verdade, é bastante fácil de entender e vamos passar por isso agora. Mais uma vez, certificando-se de que estamos na Lecture 11, ternary, e então apenas abrindo o roteiro ternário. Como podem ver, já há algo aqui dentro. Temos uma ótima nota e uma bool que apenas expressam se este grande passado passou ou não. Vimos nas últimas palestras como podemos manipular isso um pouco. E agora só vai mostrar uma abreviação rápida basicamente. Então podemos dizer que passado é igual a. E então, por exemplo, podemos dizer nota, eu sou maior ou igual a 50. E isso só funciona porque podemos, é claro, salvar as expressões booleanas. Neste caso, com o operador de comparação apenas no lado de um booleano também. Em vez de, em vez de sempre avaliar isso dentro de uma declaração if, nós também podemos apenas salvá-lo em um booleano e, em seguida, basicamente, olhar para ele assim. Agora o operador ternário tem algo. Basicamente funciona quase como uma declaração if. Então podemos, por exemplo, dizer que passado é igual a e então dizemos que nota é, digamos, menor que 50. Vamos fazer uma soma parênteses em vez de o operador ternário é um ponto de interrogação. E então o que deve ser devolvido. Se isso for verdade, vai ser um pouco. Estamos agora. Isso pode ser falso e, em seguida, fazemos cólon através. Então, como você pode ver agora ele não está mostrando mais erros. A idéia é que na frente do ponto de interrogação, você coloca uma expressão booleana. E o primeiro elemento aqui é o que é devolvido. Neste caso, escrito na variável anterior. Se a expressão aqui for verdadeira. E então o que vem depois que o cólon é devolvido? Se a expressão aqui for falsa. Então esta, esta expressão aqui é basicamente a mesma se eu fizesse o seguinte. Então este passado é igual a falso. Else passado é igual a verdadeiro. Então, esses são completamente equivalentes. Neste caso. O mesmo aconteceria aqui como acontece aqui. Talvez um, outro exemplo possa ser um pouco melhor, por exemplo, com uma string. Então, digamos, por exemplo, a frase e então vamos dizer que nota é igual a 100. Então vamos dizer parabéns por 100. E então se não for um 100, então isso, isso será devolvido se for um 100, e isso será devolvido se não for um 100, não um 100. Mas ainda é bom. Algo assim. Por exemplo. Como você pode ver, isso funciona. E este pode ser um exemplo um pouco melhor do que o último ano, porque estamos usando Booleans aqui também. Este operador ternário, como eu disse, pode ser substituído por normal se declarações também, ou se declarações podem substituir com um operador ternário. Depende muito da situação. Algo que eu definitivamente não faria é ter múltiplos operadores ternários, como dentro um do outro. Então, em teoria, podemos dizer, bem, ok, este é outro diário mais brilhante, então podemos dizer maior, maior ou igual a 50. E então outro ponto de interrogação, e então podemos retornar passado e então podemos, por exemplo, retornar falhou, certo? Então podemos fazer isso. Neste ponto, começa a ficar um pouco mais complicado de ler. Acho que isso pode ficar bem. Se você tem dois níveis de profundidade, talvez isso funcione. Mas eu realmente não aconselharia você a fazer mais do que isso. Sim. Mas também é um tipo de coisa que você sente se você começar a programar um pouco. Sim, então esse é o operador ternário. É só uma pequena introdução a ele. Não há nada muito extravagante nisso. E é importante que você tenha visto isso é tudo. Então, sim, sim, foi isso para esta palestra. Espero que você achou útil se houver alguma pergunta, como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 15. (C#) Switch: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas declarações do switch. A última vez que vimos o operador ternário. Há outro operador ou uma declaração que podemos usar que eu não diria substituir as instruções if, mas que podemos usar em vez das instruções if se assim escolhermos. Então vamos apenas abrir o script de instrução switch aqui. E é pode ver que eu já preparei um valor inteiro ou variável inteira x com valor 75. E vamos olhar para a palavra-chave switch. Então é só mudar. E então entre parênteses dentro dele, queremos colocar uma variável que queremos avaliar, neste caso x, e então precisamos dos colchetes. E isso é basicamente o que precisamos para a instrução switch. Em seguida, dentro da instrução switch, nós estamos realmente indo para definir casos específicos. Então, se por exemplo, x é 10, então vamos escrever caso 10, então dois pontos, e então o que queremos que aconteça. Então aqui nós podemos realmente escrever como um monte de código, chamada de método, o que quisermos. Neste caso, vamos apenas imprimir ou depurar log x é 10. E no final disso, então depois do ponto e vírgula, nós realmente queremos outra palavra-chave e que é tijolo. E isso significa simplesmente que, ok, este caso está feito agora. Então, obviamente, o, IT, há uma maneira mais fácil de produzir o que x é neste caso. Isto é apenas para fins de demonstração neste caso. E assim podemos ter outro caso, por exemplo, caso 20. E então vamos dizer log de depuração x é x é 20. E outra pausa. E vamos apenas copiar isso. Então nós vamos basicamente garantir que nós marcá-los e tê-los selecionados. Então vamos pressionar Controle C para copiar o controle V para colar. E então teremos mais cinquenta e cento e cinquenta e cem. E sim, tudo bem. Agora, como você pode ver, a desvantagem digamos aqui é que nós realmente temos que especificar cada caso específico em vez de uma declaração if onde nós tivemos o tipo de habilidade onde nós passamos o booleano para ter intervalos. Aqui ele realmente precisa ser explícito em cada caso. Então pode ser um pouco tedioso. E há um caso específico que acontece se x é algo que não pensamos ou se não queremos definir um caso para isso, e isso é chamado padrão. E o padrão acontece. Então, por exemplo, diga log de depuração. Não sei o que é “x”. Meio estranho. E depois uma pausa, você também está, certo? Então, neste caso, obviamente padrão seria, o caso seria padrão porque x 75 cai em nenhum desses quatro casos. E podemos verificar isso. Certificando-se de que estamos na palestra do switch. E vamos brincar e ver se isso funciona. Eu não sei o que X é meio estranho. Lá vai você. Porque x era algo onde nenhum caso foi definido. Então sim, isso é basicamente a instrução switch. Tem alguns usos em casos específicos. No entanto, geralmente é reservado para talvez onde você tem três ou quatro casos predefinidos, onde isso não dura por muito tempo. E também geralmente inteiros e também flutua. Então nunca use casos de troca se você tiver carros alegóricos ou duplos porque isso, quero dizer, literalmente não funciona. Ou a Minha pista para o desastre. Integers r pode ser bom. No entanto, geralmente casos de switch são reservados para coisas como enums, que vamos dar uma olhada um pouco mais tarde, onde basicamente têm valores predefinidos. Então essa é uma espécie de idéia. Mas eu queria mostrar a declaração do switch. Ele pode ser útil e pode ser basicamente trocado com uma declaração if. E sim, foi isso para esta palestra. Espero que você tenha achado útil se não houver perguntas, como sempre, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 16. (C#) enquanto Loop: Muito bem, bem-vindos de volta à introdução C-sharp aqui para o curso de unidade. E nesta palestra, vamos dar uma olhada no loop while. Então estamos indo para a próxima seção, digamos, que é loops. E vamos ver o que podemos ver abrindo o script de loop while. Então eu já defini um inteiro x igual a cinco. E agora o que queremos, talvez, o que queremos é trancar este X, talvez muitas vezes, certo? Então, queremos trancar isso. Então agora nós olhamos para 6 vezes, mas na verdade eu quero registrá-lo 100 vezes, certo? Então eu tenho que copiar e copiar novamente e copiar isso. Quer dizer, isso é ridículo, certo? Obviamente isso é demais. E talvez o que eu quero entre essas fechaduras, eu realmente quero aumentar isso. Então eu quero parecer cinco e depois eu quero parecer seis e depois 78. E quero dizer, isso é, isso é taxa de loucura. Claro que isso é loucura. É por isso que temos loops. Um loop simplesmente repete uma seção específica do código. Digamos que o número de vezes que definimos. E neste caso, um loop while faz algo enquanto uma determinada expressão booleana é verdadeira. Então vamos apenas escrever o while, um loop, a palavra-chave while aqui, e vamos apenas tocar duas vezes e como você pode ver, ele gera um parênteses, parênteses aqui e colchetes. Então, tudo dentro dos colchetes é executado desde que o que está dentro dos parênteses é verdadeiro. Neste caso, enquanto true sempre será executado e continuar correndo. E basicamente vai quebrar a unidade se fizermos isso. Então essa é uma das coisas que precisamos cuidar. Deve haver sempre uma ótima condição em vez de um loop while. Caso contrário, ele pode se transformar em um loop infinito. E isso, então, por sua vez, se transformará em Unity batendo. Acredite em mim, isso vai acontecer com você em algum momento. Enquanto você programa algo com loops while. Aconteceu comigo. E quem sabe? No final desta palestra, talvez isso aconteça também. Duvido muito, mas nunca se sabe. Então vamos colocar em x é menor ou igual a 10. E enquanto isso é verdade, nós vamos depurar ponto log x log, e então nós vamos aumentar x. Então, se nós não tivéssemos esse aumento aqui, então ele iria continuar logout 55, 55. Mas seria com isso To Eternity, o que, naturalmente, não funciona, e portanto a unidade iria falhar. Não é isso que queremos. Portanto, vamos aumentar X cada vez que o loop while é executado. Então ele vai ser executado como qualquer outro tipo de código de cima para baixo. Então ele vai imprimir isso ou aumentá-lo. Verificar um ainda é uma coisa. Se ele está resolvendo um log-lo para fora, aumentá-lo, verificar novamente e assim por diante, assim por diante até que terminemos. E vamos apenas adicionar uma depuração depois daqui. Vai dizer fora do circuito. O loop, não, fora do loop. Lá vai você. E sim, vamos fazer isso para o que esperamos. Então, uma coisa que é sempre uma boa idéia de olhar, o que estamos esperando ver no console. Então eu estou esperando ver 5, 6, 7, 8, 9, 10. Sim. Eu acredito. Eu vou ver 10? Sim, eu vou ver 10, eu acredito. E, em seguida, fora do circuito. Então, cinco a dez. E então fora disso é o que eu estou pensando sobre sênior e ter certeza de que estamos na Palestra 13. Vamos ver se esse é o caso. 05678910. E fora do circuito, não é ótimo? Isso também é apenas uma parte rápida, muito importante. Pense no que você deseja ver no console. Então pense na sua expectativa e veja o que sai. E se sua expectativa e o que quer que seja produzido ou bloqueado for atendida, ótimo, você tem um pensamento sobre isso da maneira certa. Se houver uma discrepância, tente descobrir, bem, o que eu fiz de errado? Ou, por exemplo, um fácil, digamos erro ou, ou uma coisa fácil de fazer é em vez de ter x menor igual a 10, nós temos, é menor 10. Estamos tipo, bem, ele ainda vai produzir o 10, certo? Ele ainda vai ir de cinco para 10 porque enquanto for menor que 10, e claro que não produz o 10, porque assim que for 10, não é mais menor que 10. Portanto, ele não vai, ele não vai executar o que está no, nos colchetes. Então isso é algo para cuidar. Isso não é específico para o loop while em si, mas apenas conselhos gerais. E há um segundo, digamos. Outro eu faço com um loop while que tipo de laços com o menor, menor ou igual. E esse é o loop do “fazer while”. Então, podemos apenas colocar em fazer e, em seguida, pressionar Tab duas vezes. E como você pode ver, neste caso, nós vamos ter uma palavra-chave do aqui, seguida pelos colchetes e, em seguida, o wireless na parte de trás. Vamos colocar em x é menor que 10. E então podemos realmente fazer a mesma coisa. Então vamos fazer exatamente a mesma coisa. E não vamos fazer isso como não vamos fazer este ano. Certo? Vamos, vamos realmente rapidamente tirar isso daqui. E o loop do “faz-while”. Bem, vamos ver o que acontece. Então vimos anteriormente que o loop while com x menor que 10 que imprimiu cinco a nove. E neste caso, vai imprimir cinco a nove mais uma vez. Interessante, não é? Bem, o que também é interessante? Se ficarmos com isto, vamos passar o nosso X em dez. Então esta função é exatamente da mesma maneira, certo? Então isso também vai avaliar isso. E então vamos colocar isso aqui. Vamos dizer, ok, x é, assim que estamos fora do loop, x vai ser igual a 10. Então o tempo não é, nunca é uma coisa. Então X sempre será maior que 10, nunca menor que 10. No entanto, se olharmos para isto, na verdade vai imprimir 11 aqui. E se clicar duas vezes aqui, vamos realmente ver isso é o que é impresso. Isso é meio estranho, não é? Por que isso aconteceria? Porque x nunca é menor que 10 naquele momento. E quero dizer, é, é bastante evidente porque na verdade está impresso 11. Bem, faz enquanto faz este, então há o comando DO, por assim dizer. Eles fazem palavra-chave, vai executar as coisas dentro dos colchetes uma vez. E então ele vai avaliar a condição “while”. E então ele basicamente funciona como um loop while normal poderia ser útil em algum momento. Pessoalmente, raramente uso isso. E também pessoalmente, eu também raramente usei enquanto loops também, porque eles fazem, pelo menos quando eu usá-los tendem a falhar unidade. Então, esteja avisado, mas não fique, não vai ser tão ruim porque normalmente, desde que você economize vezes o suficiente, então vai ficar tudo bem. Mas sim, na verdade não é tão ruim. Eu só queria mencionar isso. E sim, isso é basicamente uma breve visão geral do loop while. Espero que você tenha achado útil e eu realmente apreciaria uma revisão de você. E se houver perguntas como sempre, taxas para tarefa e eu vou ter certeza de responder. E sim. 17. (C#) para Loop: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em loops. Então, vimos um loop selvagem. Então, o que é o loop for? Bem, vamos dar uma olhada abrindo o script for-loops. Bem, vamos dar uma olhada no loop for sem mais nada. Então vamos apenas digitar quatro e vamos fazer isso manualmente primeiro. Assim, o primeiro componente dentro de um loop for é um inteiro. Neste caso, vamos chamar este inteiro I igual a 0. Vou colocar um ponto-e-vírgula. Então temos que escolher uma expressão. Então digamos que eu seja menor que cinco e então eu mais, mais. E, em seguida, coloque os colchetes encaracolados também. Então, o que isso significa? Bem, isso significa que eu começo às 0. Está indo para cinco. E está aumentando, aumentando eu em um. Essa é a ideia porque, como aprendemos, eu mais aumentos. Neste caso, eu por um. Começo às 0. E enquanto isso for verdade, o loop continua. Então este estaria contando de 0 a 2, 1, 5, 4, 5 a 4. Vamos apenas olhar para isto. Então debug dot log e depois eu. E então nós vamos passar por isso. Como isto parece. Então vamos fechar isso e ver o que o console tem para nós. Ele deve bloquear 0 a quatro. E como você pode ver, 0, 1, 2, 3, 4. Ótimo, isso é muito bom. E então vamos pensar sobre isso. Então começamos em 0, isso é fácil de ver. Então vamos imprimir 0. Ok? Então vamos aumentar eu em um. E então vamos avaliar: “Ei, eu sou menor que cinco? Sim, é. Tudo bem. Vamos imprimi-lo. E então ele vai ser 2 é menor. Sim. Então serão três pequenas áreas para sim. E depois vai ser 55. Eu não sei se você ouviu, mas isso não é menor que 5. Na verdade, é igual a 5. Portanto, estamos fora do circuito nesse ponto. E é por isso que cinco realmente não são incluídos no olho, por assim dizer. Então, assim que eu for igual a cinco, ele, nós vamos saltar para fora do loop. Então isso é realmente útil para a contagem, e também é útil para algumas outras coisas que vamos dar uma olhada nisso muito em breve na próxima palestra já. No entanto, o for-loops, definitivamente ótimo. Também podemos contar para trás. Então vamos fazer isso. Então vamos fazer um inteiro 10. E digamos, bem, eu deveria ser maior que 0. E depois vamos dizer “Eu menos”. E vamos imprimir esta. E isso deve estar contando de, bem 10, definitivamente escrever 200. Saiba mais uma vez, pense nisso. Se nós não temos em, digamos maior ou igual ou menor ou igual sinal lá dentro. Então, normalmente, o número aqui não é incluído. Se tivermos um maior ou igual do que o 0 seria incluído. Neste caso, vai ser um. E então vamos dizer também para trás, porque isso conta para trás. Então nós estamos indo para, a saída deve ser de 0 a quatro e, em seguida, 10 para um. Então vamos ver se esse é realmente o caso. Vamos começar. Então, 0 a quatro e depois dez a um, vai. Ótima. Certo? Então esse é o for-loop. Na minha opinião pessoal, geralmente mais versátil do que o loop while. Mas eu acho que isso também tem que fazer um pouco com preferência. Eu acho que existem aplicáveis em diferentes situações também, então, bem, isso é para o loop for, uma parte muito importante da programação, definitivamente. Então, se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 18. (C#) quebre e continuar palavras-chave: Bem-vindos de volta à introdução do C3b para o curso da unidade. E nesta palestra vamos dar uma olhada em duas palavras-chave. Esses vão ser quebrados e continuar. Agora já vimos um pouco da palavra-chave break na palestra instrução switch. No entanto, este é realmente o aplicativo FOR loops. Neste caso, vamos dar uma olhada na quebra e continuar palavras-chave dentro do for-loop. No entanto, especialmente a palavra-chave break também pode ser usado em um loop while. Então vamos abrir o intervalo e continuar o script aqui. E como você pode ver, nós realmente temos 24 loops que fazem exatamente o mesmo. Na verdade, vamos contar de 0 a 9 em ambos. E, no entanto, isso vai funcionar. No entanto, o que podemos fazer é usar uma dessas palavras-chave, palavras-chave. Então vamos, por exemplo, dizer que se eu for igual a quatro, então o que vamos fazer é continuar. Então, o que isso faz? Bem, a palavra-chave continuar basicamente diz, tudo bem, vamos passar para o próximo I. Então vamos pular a impressão ou registrar os quatro. E vamos pular direto de três para cinco. Então vamos apenas ver, Vamos copiar rapidamente isso para fora daqui para que o console não ficar confuso. E mais uma vez, certifique-se de que estamos em Palestra 15 pausa e continuar. Como você pode ver, saltamos de três direto para cinco. Porque em um quatro, então eu é igual a 4. O que temos feito é que temos continuado, Continuar, basicamente apenas salta para o loop novamente, ignorando tudo o que vem depois dele dentro do loop. Então, basicamente, fica frio novamente e todas as linhas depois são ignoradas. Sim, essa é a palavra-chave “continuar”. Agora, vamos para o segundo loop. E digamos, por exemplo, se eu for igual a cinco, então o que queremos fazer é quebrar. Vamos realmente fazê-lo corretamente para que fique bonito. Sim, pausa. Nós já vimos isso antes em, como eu disse na instrução switch dentro daqui, a quebra simplesmente significa em vez de um loop, break significa loop stops. Então break diz, Ok, vamos imediatamente saltar para a parte de trás da organização, para o final do loop é o mesmo que se a expressão booleana aqui em cima seria falsa. Então, portanto, saímos do loop imediatamente. Vamos ver isto. Então o que devemos ver é que devemos ver 0, 2, 3, cinco a nove. E depois devemos ver 0, 2, 4 porque assim que eu tiver cinco anos, vamos sair desta forma. Certo? Então vamos ver se isso é realmente o que vamos ver. O que estou bastante confiante é. Então é 0 para três e vamos saltar de cinco para 901234 e então foi isso. Sim, então essa é basicamente a idéia de continuar e quebrar palavra-chave. Há algumas pessoas que dizem que não é necessariamente a melhor prática porque às vezes pode ser confuso, especialmente se você talvez tem um loop FOR longo e você tem um monte de continua e quebra lá com talvez ainda mais se declarações e tudo isso, então ele pode às vezes ser um pouco confuso para simples para loops. E enquanto loops quebrar ou continuar palavra-chave não vai ser muito ruim. Eu acho que não. Mas sim, então é isso para o intervalo e continuar palavras-chave. Também partes importantes para ter visto pelo menos e saber para loops. Então, se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu serei breve responder. E sim. 19. (C#) arrays C#: Muito bem, bem-vindos de volta à introdução do curso da unidade. E nesta palestra, vamos falar sobre matrizes. Agora, arrays são uma parte vital da programação. E o primeiro tópico que é um pouco mais complexo e complicado. Então eu definitivamente imploro que talvez até assista esta palestra duas vezes, porque isso tem um pouco mais nele. E, claro, se houver alguma pergunta, sinta-se à vontade para perguntar. Mas vamos pular direto. Abrindo o script. Já preparei três cordas aqui. Como podem ver, alunos 0, aluno 1 e aluno 2, John, July e Ryan. Esses são, digamos, endereços de e-mail dos meus alunos, por exemplo aqui. E agora o que eu quero é que eu quero enviar os e-mails ou eu quero enviar os e-mails, vamos apenas dizer, então é claro que nós podemos fazer o log de pontos de depuração e então nós podemos dizer estudante, estudante 0, e então nós podemos dizer estudante um. E então nós podemos dizer estudante hoje você vai, agora eu produzi-los. Isso não é ótimo? Bem, isso é bom. Mas digamos que eu tenho 100 desses e-mails que vai ser um pouco mais difícil do que, bem, nós aprendemos algo que podemos fazer. Podemos pegar este loop de quatro e podemos dizer, bem, vamos apenas passar por isso e então podemos talvez dizer log de depuração e então talvez colocar o I aqui são alguns, não, isso não funciona. Obviamente isso não funciona, certo? Então isso, infelizmente, isso não funciona. Então não podemos apenas produzi-los com um loop for e não podemos, podemos iterar sobre eles, certo? Então isso é basicamente o que queremos. Nós queremos, tipo, nós queremos listar algo como uma lista. E é aí que entra a teoria. Então podemos, digamos init, um array, certo? Então a idéia é que um array é basicamente uma lista de certo tipo. Neste caso, vamos fazer um, uma área de corda. Então vamos escrever string, apenas a palavra-chave string normal como faríamos com qualquer outra variável, variável string. E então vamos digitar esses colchetes e, em seguida, o nome da variável, estudante, machos, digamos. E então podemos fazer um, podemos inicializar este novo array, colocando-o entre colchetes. E então podemos colocar, por exemplo, John em gmail.com. E então o segundo será julho no gmail.com. E, em seguida, o terceiro será Maria no Gmail para exemplo.com. E então também teremos Ryan no gmail.com. Vamos apenas diminuir um pouco. E depois, no final, um ponto-e-vírgula. E agora isso é, como você pode ver, sem erros, tudo está bem. E agora temos realmente inicializar esta matriz é também outra maneira que podemos inicializar esta matriz. Então isso é explícito com quatro cadeias específicas. Neste caso. Podemos também dizer, por exemplo, uma matriz inteira de alguns números como esse. Vai ser igual a novo int. E então desta forma, então os colchetes, em seguida, dentro desses colchetes nós realmente temos que escrever quantos. Números, ou neste caso, então quantos inteiros estão lá? Então vamos colocar em 5. Então este seria, pode ter cinco entradas. E então podemos atribuir algo a isso. E como atribuímos algo a ele? Bem, podemos pegar o nome da variável. Então, alguns números. Mais uma vez colocamos os suportes. E dentro desses colchetes que pegamos, colocamos um número que é o índice da entrada. Então 0 significa a primeira entrada. Então isso, digamos 10, e então vamos copiar isso rapidamente sobre 1, 2, 34. Então vamos dizer algo como 2054421337, algo assim, certo? Muito importante. Arrays começam lá, contam em 0. Já vimos isso antes com as cordas. E eu queria mencionar isso aqui novamente. Se olharmos para estudantes do sexo masculino, por exemplo , temos quatro elementos. Então o tamanho ou o comprimento desta matriz de cordas, estudantes machos são quatro. Tudo bem, tudo bem. Isso é compreensível. No entanto, o primeiro elemento aqui, John editar gmail.com. Na verdade, está no índice 0. Então, mais uma vez, começamos a contar em 0. Então isto é 0, 1, 2, 3. Em suma, ainda existem quatro elementos. No entanto, nós apenas começar no início contando em 0. Então agora olhando para trás, bem, nós queríamos imprimir ou registrar todos os nossos endereços de e-mail, e agora podemos fazer isso. Então vamos fazer um novo “for-loop”. E já provém o comprimento aqui. Bem, o que podemos fazer é podemos, bem, vamos apenas fazer quatro, porque sabemos que temos e-mails para estudantes que é fácil o suficiente. E podemos dizer que os alunos de registro de pontos de depuração são homens. E então aqui nós atribuímos valores. Nós também podemos apenas obter os valores de volta apenas chamando o fazendo os colchetes. E então dentro daqui, colocamos o olho porque esse é o número que muda. Então ele vai ir de 0, 1, 2, 3, e o 4 nunca é alcançado. Já vimos isso antes. Então nossa saída deve ser, primeiro lugar, John, julho e depois Ryan Gmail e, em seguida, junho, julho Maria Ryan. Porque primeiro aqueles vão ser saída aqui aparecem. Em seguida, o loop for vai para a saída. Então vamos ver certificando-se de que estamos em Lecture 16 matrizes. Vamos começar isso e como podemos ver, junho e julho, Ryan, esses são os três que fizemos manualmente e então temos John, July, Maria e Ryan. Ótima. Bem, quero dizer, isso é incrível. Então vamos adicionar mais um. Você sabe, a Nuvem também está unida. Quero dizer, isso é muito legal, certo? Então, isso é muito bom. Vamos, vamos nos certificar de que todos estão lá e todos estão incluídos aqui também. Vamos começar isso e tudo funciona totalmente bem como você pode ver claramente. Mas agora, bem, em primeiro lugar. Sim, mas as nuvens na verdade não eram produzidas. Então está tudo bem, isso é meio estranho. Mas agora, oh não, olha para isto. Estamos perdendo três de nossos alunos se conheceram. Então só John e July permanecerão por este semestre. Quero dizer, isso, você sabe, pode acontecer. Pode acontecer, mas não há nenhum problema que é sim, há um índice de emissão fora do alcance. Então, o que é isso? Bem, o que acontece aqui é que, de repente, estamos tentando acessar algo que não existe. Neste caso, os estudantes do sexo masculino têm apenas dois elementos. Então, na verdade, só podemos contar de, então 0 e 1, dois elementos. Mas aqui, estamos realmente tentando acessar os elementos 3, 4, 5, e assim por diante. Isso não funciona porque, bem, não existe. Então, o que podemos fazer sobre isso? Porque nós explicitamente dissemos para, ok, eu vou mudar isso para dois. Mas cada vez que o aluno muda, temos que entrar manualmente e mudar isso. Bem, isso não funciona. Claro que há algo para isso e então podemos ir estudantes homens desse comprimento. E esse é sempre o comprimento dos estudantes do sexo masculino. E agora vai passar por isso. Então Maria, Ryan e Klaus se juntaram a nós novamente. E agora Klaus também será libertado porque nós o levamos em conta. Vamos ver, lá vai você. Feche em gmail.com, também é saída. Então sim, isto é, essa é a idéia de matrizes. É basicamente uma lista. Ele pode ser de qualquer tipo de variável, então qualquer tipo de dados, desde que você coloque os colchetes depois dele, pode ser um array. E neste caso, explícito. Lee colocou as cordas. Aqui estão alguns números inteiros. A atribuição funciona muito semelhante a realmente obter a saída de tudo o que está lá dentro. O que também é importante é que quando você definiu quantas entradas estão em uma matriz, você não pode alterar o número de entradas, modo que permaneça o mesmo. Você pode alterar o que quer que esteja escrito nessa posição, mas você não pode alterar o número de entradas em uma matriz. Agora há algumas outras coisas que podemos usar que realmente têm esse tipo de lista dinâmica nele. Essas são algumas outras estruturas de dados que vamos olhar mais tarde. No entanto, as matrizes neste momento no tempo são pelo menos um pouco importantes. Isso é algo que podemos usar mais tarde que é um pouco mais fácil de entender na minha opinião. No entanto, agora, arrays são a coisa. Eu definitivamente encorajaria você a dar uma boa olhada nisso para realmente tentar entender o que está acontecendo. Se houver alguma dúvida, pergunte. Porque este é como um dos, eu diria um dos temas mais importantes, mas este é definitivamente um tópico importante. E só por um pouco de lado aqui, eu realmente posso contar uma pequena história divertida sobre isso. Então, quando eu estava começando a aprender programação e era surgiu, eu, no começo eu não os entendia. É por isso que eu preparo isso dizendo, ok, isso é talvez um pouco mais difícil e um pouco mais complexo. E então eu não os entendia no começo. E eu não conseguia perceber o que estava a fazer de errado. E então eu pensei, eu nunca vou usar áreas de qualquer maneira. Eu não preciso deles em tudo. Isso não importa. Eu sempre vou fazer isso assim. E claro, quero dizer, em primeiro lugar, essa é a maneira errada de abordar isso de qualquer maneira. Você nunca deve fazer isso. Se você está tentando aprender algo novo. Esta não é definitivamente a forma correcta de abordar esta questão. Mas neste especificamente, há apenas algumas coisas que você não pode fazer se você não usar um array ou como nós temos mais tarde que como nós vamos ver mais tarde uma lista ou algum tipo de estrutura de dados diferente. Às vezes você tem que usar essas estruturas de dados que são diferentes de apenas estupidamente escrever linha por linha. Funciona, mas em algum momento fica muito, muito desagradável, ruim, simplesmente não é bom. Então é por isso que eu realmente quero encorajá-los a tentar entender isso. Talvez olhar para ele uma ou duas vezes. E se houver alguma pergunta, sinta-se à vontade para perguntar. E como sempre, vou ter a certeza de responder. E espero que tenha achado isso útil. E sim. 20. (C#) matrizes (C#) em C#: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada rápida em matrizes multidimensionais. Agora, depois de olharmos para matrizes, agora vamos dar uma olhada em matrizes multidimensionais. Agora, eu mencionei que esta é apenas uma visão muito, muito rápida, apenas um olhar rápido sobre como eles, como eles se parecem, e apenas um pouco de como eles funcionam. E vamos abrir o script de várias dimensões aqui. E eu já defini uma matriz multidimensional. Como pode ver, colocamos uma vírgula nos suportes. E, em seguida, dentro dela, nós realmente definir uma matriz e, em seguida, a próxima área também é definida. E, em seguida, outro colchetes em torno de lá. Então, basicamente, há duas áreas. Em vez de um array, você pode pensar nele como um array de arrays. Em teoria, isso é algo que você pode pensar. Ou você pode pensar sobre isso como uma tabela onde você tem linhas diferentes. Então, se nós escrevêssemos assim, por exemplo, dizer algo assim, então você poderia imaginar que esta é a primeira venda, segunda célula e assim por diante. E então, de repente, faz muito mais sentido quando pensamos nisso. Então você pode ter, você tem duas coordenadas para descrever essas células. E então isso seria simplesmente 0, 0. E isso faz sentido absoluto. E então isso é algo como 0, 3 por exemplo, e assim por diante e assim por diante. E vamos apenas, eu vou copiar uma coisa. Então, se olharmos para isso, que possamos mais uma vez obter o conteúdo ou os elementos da matriz simplesmente colocando o colchete e, em seguida, escrevendo para nos índices agora porque é claro que precisamos de dois índices neste caso . E 03 produzirá algo da primeira matriz. Então este 0 notifica a primeira matriz. Mais uma vez, começamos a contar de 0 e, em seguida, os três simplesmente significam 0123. Portanto, ele está indo para a saída 25. E o segundo, vai ser o segundo array ou o outro na posição um, vez de um índice. E então com o índice dois, então vamos ter 1, 0, 1, 2. Isto vai abrir 5 mil. Então vamos ver se esse é realmente o caso. Certificando-se de que estamos sob a Palestra 17. E a saída é de 25 e 50 mil, exatamente como imaginamos. E há duas coisas que vimos o comprimento e agora há outra coisa que é o posto. Então isso é basicamente quantas linhas existem. Então, como você pode ver que essas são basicamente as linhas. Isso tem quantas matrizes internas de vias aéreas você poderia descrevê-lo assim. Neste caso, Rose, eu acho que a abstração de pensar sobre uma matriz multidimensional como uma espécie de talvez até mesmo uma planilha do Excel é realmente bastante útil. E o que também podemos fazer é fazer para loops. E eu vou rapidamente também copiar isso sobre m. E isso seria um dois para loops dentro um do outro. Um que passa pelas linhas basicamente, e depois um que passa por cada um dos elementos em si. Claro, neste caso, os elementos são o comprimento. Então o comprimento é a totalidade de todos os elementos, certo? Temos oito elementos aqui divididos por quantas linhas lá. Tudo bem, então cada linha tem quatro elementos, como você pode ver claramente. Então temos que dividir o número de elementos pelo número de linhas. Isto é o que este cálculo faz aqui. E então ele funciona também foi muito importante é que cada uma das matrizes internas, onde cada uma das linhas tem que ter exatamente o mesmo número de elementos que os outros. Então, se eu fizer isso, então, como você pode ver, um inicializador de matriz de comprimento 4 é esperado. Então nós realmente precisamos de quatro elementos em cada uma das matrizes. Então, se eu fosse adicionar outro array, nós também precisaríamos de quatro. Isso é apenas mencionado rapidamente. Vamos ver a saída para isso também. E então somos basicamente feitos com matrizes multidimensionais. Eu só queria mostrar isso para você rapidamente. Então, como você pode ver, 10, 15, 20 e 25. Então a primeira, a primeira linha é impressa e depois 5500, cinco mil e cinquenta mil, e depois a segunda é impressa. Então isso é meio legal. Na minha estimativa. E minha experiência, é muito raro que matrizes multidimensionais sejam usadas. No entanto, eu queria mostrá-los para você porque eles têm alguma aplicação algumas vezes. No entanto, eu realmente não me preocuparia com isso se há certas coisas que você não entende muito sobre este tópico, Isso não é tão ruim, como isso não é tão importante. Áreas em si são muito mais importantes do que entender matrizes multidimensionais. Eles são como uma espécie de bônus. É bom saber, É bom ter realmente não necessário. Mas de qualquer forma, se você achar isso útil, eu realmente apreciaria uma revisão sua. E se houver alguma pergunta, é claro, você sempre pode perguntar, eu vou ter certeza de responder. E sim. 21. (C#C#: Muito bem, bem-vindos de volta à introdução em C para o curso. E nesta palestra vamos dar uma olhada nas listas. Então, depois de dar uma olhada em matrizes e, em seguida, apenas uma rápida olhada em matrizes multidimensionais. Agora vamos olhar para listas que vão tornar nossas vidas cerca de 120% mais fácil. E então vamos dar uma olhada no script de listas bem aqui. E antes de tudo, vamos lembrar as matrizes. Em vez das áreas. Nós tínhamos endereços de e-mail diferentes dos alunos como um exemplo aqui, definido. E foi tão fácil quanto colocar o, o tipo de dados e, em seguida, os colchetes. E então tivemos uma série de uma lista é um pouco mais complicada ou um pouco mais estranha, talvez. Mas vamos definir uma lista. Vamos, vamos inicializar uma lista. Então, vamos apenas escrever na lista. Então vamos fazer esses suportes angulares. E dentro desses colchetes angulares, vamos escrever o tipo de dados que queremos salvar lá. Então, neste caso, uma corda e vamos chamar isso de machos. Em seguida, indo para igual nova lista de tipo string e, em seguida, parênteses e um ponto-e-vírgula para terminá-lo. É assim que você basicamente inicializa uma lista. Certo? Então agora temos uma nova lista como o nome nova lista sugere do tipo string, então agora podemos adicionar a ele. Então vamos olhar para alguns métodos que podemos chamar para esta lista. Então podemos, por exemplo, dizer machos ponto adicionar, como você pode ver. E então podemos escrever, por exemplo, talvez Jonah não esteja mais no Google, talvez ele esteja no Yahoo neste momento. Não sei porquê, mas quem sabe? E então vamos apenas copiar isso algumas vezes e depois adicionar alguns tipos de julho e então nós vamos adicionar Ryan novamente e depois Maria. Então esse é o método add, como você pode ver claramente. Agora, a primeira coisa que você deve pensar sobre volta era, espere um segundo. Nós tínhamos, nós tivemos que definir quantos elementos eles estavam em uma matriz. Exactamente. Não temos de fazer isso numa lista. Uma lista é dinâmica. Então você pode ter 0 elementos e você pode adicionar vários elementos e, em seguida, você pode mais tarde para baixo a linha, você também pode remover elementos. E sim, essa é uma das coisas boas, são ótimas coisas sobre listas. Então vamos apenas sair, em primeiro lugar, apenas machos e, em seguida, também fazer logout e-mails 0. Então, mais uma vez, o mesmo acesso, o mesmo operador de eixo que vimos com o array, certo? Apenas os colchetes e, em seguida, o número que indica o índice do que queremos. Neste caso, ele será desenhado em yahoo.com. E depois vamos ver o que acontece se sairmos dos machos, só para ver. Então, vamos apertar o botão “play” e ver. Ok, então nós vamos sistema de coleções genéricas lista. Então algo que não é realmente útil para nós, não realmente. No entanto, aqui podemos realmente ver John no yahoo.com recebe. O logado. Quando nós logout o primeiro elemento da lista, ou o 0 elemento da lista. Acho que sim. Também podemos reatribuir valores. Então reatribuir valores, isso é muito semelhante ao, na verdade é exatamente o mesmo quando fizemos com a matriz. Então vamos ver, na verdade John trocou de volta. Então John está no Gmail de novo. Então, neste caso, o elemento John no yahoo.com muda para John em gmail.com. Também podemos remover um item. Então remova eles vão remover um item. E isso seria se chamássemos os machos de ponto remover. E então podemos remover. Para que possamos passar uma corda. Então podemos dizer, ok, eu quero que uma string específica seja removida. Então, por exemplo, julho em yahoo.com. Agora, para que isso funcione, é claro que precisamos saber que elemento queremos remover de quem não sabe disso, mas sabemos o lugar onde ele está. Nós também podemos dizer machos ponto remover em e, em seguida, colocar em um. Então isso é equivalente. Agora é claro que eu não posso fazer isso um após o outro porque depois que nós removemos o julho, Ryan de repente se torna a coisa que está no lugar um. Portanto, isso não funciona. Se quisermos o tamanho de uma lista, podemos conseguir isso também. Então isso seria, por exemplo, importante para, para loops ou alguém assim. Então usamos a contagem. Então a variável count é o que precisamos. Então este é o comprimento. Comprimento. Às vezes, algumas pessoas também chamam de tamanho ou contagem da lista. E em diferentes, em diferentes linguagens de programação, isso é quase intercambiável comprimento, tamanho e contagem. Mas no nosso caso, é a contagem neste momento, neste, neste script, deve ser três porque nós removemos um dos elementos aqui, ou seja, julho no yahoo.com. E então nós também podemos limpar a lista. Então os machos ponto-ponto claro. Esta vontade, esta chamada irá literalmente limpar a lista. Então, vai acabar completamente com tudo o que está lá dentro. E vamos imprimir a contagem depois disso também. Então vamos ver o que vai acontecer aqui. Nós vamos ter isso. Bem, não precisamos mais disso. Vamos imprimir John no yahoo.com. Então vamos reescrever o primeiro. Então nós vamos dizer, Ei, quanto, quantos elementos estão lá dentro? Este deve ser três. E depois vamos limpar a lista. Então, nada deve estar mais na lista e então devemos ter 0. Em vez disso. Vamos ver se é esse o caso. Mas estou bastante confiante aqui eles vão. Então, em primeiro lugar, imprimimos John no yahoo.com. Então temos três elementos na lista. Depois de ter removido o elemento um, e depois de limpar a lista temos 0 elementos lá eles vão. Então essas são algumas das coisas que podemos fazer com listas. Se você olhar, então se fizermos e-mail stat, como você pode ver, existem alguns mais alguns métodos que poderíamos chamar. Neste caso. Só queria dar-lhe uma breve visão geral da lista. É se você entender matrizes, você basicamente entende listas. E o melhor é que as listas são melhores em quase todos os sentidos do que em uma área. Porque eles são dinâmicos. Você pode adicionar a eles. E seu geral, eu acho que um muito mais agradável para usar as matrizes normalmente, certo? Então, no geral, eu diria que geralmente é melhor usar sempre listas. Porque liberar não. Digamos que o impacto positivo do uso de arrays versus listas. Pode haver algumas coisas muito especializadas, mas é como em quase tudo. Sabe, se você perguntar a 100 pessoas, então você vai ter 100 opiniões. Então, às vezes, é assim que é. De qualquer forma, essa é uma breve visão geral da lista em Dó afiado. Espero que isso tenha sido útil para você. E se houver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 22. (C#) Dictionaries de C#: Muito bem, bem-vindos de volta à introdução de C-sharp para o curso de unidade e esta palestra vamos dar uma olhada em dicionários. Agora, dicionários são basicamente listas com um pouco de torção para eles. Então vamos abrir o script do dicionário e ver o que podemos ver. Então, em primeiro lugar, como definimos ou inicializamos um dicionário? Bem, nós só vamos escrever dicionário. E, mais uma vez, os suportes angulares. E agora nós realmente temos que especificar dois tipos diferentes, ou não dois tipos diferentes, mas dois tipos de tipos de dados. No nosso caso, vamos fazer uma corda e uma corda. Então estes são separados por uma vírgula. Agora vamos chamar isso de capitais. Tenho as minhas razões para isso, o que será evidente em breve. E então é igual a novo. E então, como você pode ver, ele já basicamente nos dá uma sugestão aqui que nós podemos apenas preencher automaticamente clicando ou pressionando o botão Tab, adicionando os parênteses e o ponto-e-vírgula. E então nós vamos, temos um novo dicionário. Agora, um dicionário funciona da seguinte maneira. Então, basicamente mapeia. Então vamos anotar isso. Um dicionário mapeia uma chave. No nosso caso, isto é uma corda, certo? Porque este é o primeiro tipo de dados que demos ao dicionário para um valor específico, que também é uma string. Agora, isso é basicamente o, o valor chave. A dinâmica é chamada de par de valor chave porque eles vêm em pares, certo? E isso agora será mostrado com maiúsculas. A idéia é que, bem, se você tem um país, que seria a chave, que você sempre terá um certo valor para o seu capital. Isso é bonito, muito facilmente compreensível. E então podemos apenas adicionar novas entradas aqui. Por exemplo, se colocarmos no México, então podemos colocar na Cidade do México como a capital. E depois vamos copiar isto. Algumas vezes. A Alemanha seria Berlim, e depois temos a França com Paris. E por último, mas não menos importante, EUA com Washington DC. Então, esses são agora alguns exemplos que adicionamos a isso. Temos visto anteriormente no, tanto a matriz e a lista que podemos obter certos elementos lá usando os colchetes e, em seguida, colocando agora qualquer índice que queremos. Neste caso, isso não funciona. Como você pode ver claramente, 0 não funciona porque ele realmente quer uma chave específica, não o índice. Então, se colocarmos uma corda dentro daqui e dissermos Alemanha, por exemplo, então o que vamos conseguir é Berlim, porque a Alemanha é a chave para o valor Berlim, z. Sem mais erros. E se voltarmos aqui certificando-se de que estamos na Palestra 19 e nos dicionários. Então podemos ver Berlim é desconectado porque é de fato o valor para a Alemanha chave. Então isso não é diferente de ter uma lista. Mas ao invés de ter as chaves sendo a posição na lista, nós realmente temos algo diferente. Também podemos remover um item. Então, por exemplo, porque eu as maiúsculas ponto remover, e então nós podemos apenas remover a França, certo? E isso na verdade, basicamente, excluirá essa entrada aqui. Então, não podemos realmente obter o, recebe um valor Paris fora dele porque ele realmente tem. Em seguida, remova todo o ano de entrada. E se, em seguida, ir para maiúsculas dot count, que seria o número de elementos dentro do dicionário. Este deve ser então 3 depois de termos removido a França. Como você pode ver, isso é tão fácil quanto é. Sim, e isso é basicamente um, no dicionário. Um dicionário incrivelmente útil de muitas maneiras diferentes. Ele pode basicamente mapear algum tipo de dados para outro tipo de dados. No nosso caso, colocamos uma corda em uma corda. Claro que pode haver outra coisa. Por exemplo, podemos ter a string para um inteiro, e então isso seria, por exemplo, o número de pessoas que vivem no país ou o PIB ou qualquer outra coisa. Então podemos fazer, podemos fazer todo tipo de coisas com o dicionário. Eu definitivamente posso dizer que é melhor brincar com ele um pouco também. Existem mais alguns métodos que você pode chamar também. Bem, sim, isso é uma breve visão geral dos dicionários. E espero que tenha achado isso útil. Se houver alguma pergunta, como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 23. (C#) loop de foreach: Muito bem, bem-vindos de volta à introdução C-sharp para o curso de unidade. E nesta palestra vamos dar uma olhada no loop for-cada. Então esta vai ser uma palestra muito rápida apenas em breve olhando para o, para outro tipo de loop. Então, depois de termos visto que podemos usar listas e temos visto como podemos basicamente passar por elas com um for-loop normal. Agora vamos realmente olhar para um, outro loop. Isso é chamado de loop for-each. Então podemos apenas digitar um foreach como uma palavra-chave. E dentro dos parênteses, vamos definir uma nova variável, neste caso uma string chamada macho. Então nós vamos escrever na palavra-chave em assim i n, e então nós vamos digitar a coleção. Isto vai ser machos. E então dentro daqui, você vai estar certo, depurar ponto log macho e eles vão. E essa é a idéia para cada loop é, você pode basicamente apenas ler em voz alta e vai fazer sentido para cada macho cordante em machos. E então vamos fazer o que estiver dentro dos colchetes. Então, neste caso, vamos apenas desconectá-lo. Também pode haver outras coisas que talvez queiramos fazer. Uma coisa que é mencionada em para cada loops, podemos realmente mudar a coleção. Podemos mudar os elementos em si, mas não a coleção na sua totalidade. Então não podemos simplesmente remover algo da coleção, então o loop for-cada vai quebrar que só podemos fazer no normal para loops, digamos. E mesmo isso, não é bem o que você diria? Não é aconselhado. Certo. Mas vamos ver se isto funciona. Na verdade, não precisamos especificar nenhum item específico no loop for-each. Certificando-se de que estamos na Palestra 20 para cada loop. Vamos chamar isto. Então o primeiro, John July Ryan, Maria, e depois temos o separador, John July, Ryan e Maria. Então tudo fica trancado como esperávamos. E isso é o para cada loop. Isso, claro, também funciona para dicionários ou outras coleções. Não vamos olhar para outras coleções em detalhes. Nesta introdução. No entanto, há também outros e isso também funcionaria para dicionários em teoria, certo? Isso é apenas um olhar rápido e curto. Estou no para cada loop. Espero que tenha aprendido algo novo. E se houver alguma pergunta, como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 24. (C#) Namespaces: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida em um namespaces. Então, o que são namespaces? Bem, vamos apenas abri-lo, o script namespaces e vamos ver. Então eu lhe disse desde o início que nós vamos ignorar a maioria das coisas aqui em cima, a maior parte do que está escrito aqui. Mas agora vamos dar uma olhada nessas três coisas. Primeiro de tudo, a palavra-chave usando e, em seguida, o que é escrito depois deles. Então, esses são namespaces. E a idéia de namespaces é basicamente deles como diretórios onde certas classes são mantidas em, certos scripts são mantidos em. Essa é a maneira mais fácil de conceituá-los. E podemos então acessar essas funcionalidades e essas classes se estamos usando-as. Assim, por exemplo, há um namespace específico para a interface do usuário da unidade. Então, por exemplo, há algo chamado botão, que é obviamente um botão que podemos usar no Unity. Mas como você pode ver, não é, não existe. Se eu colocar o botão aqui , não mostra nada. No entanto, se eu subir aqui e eu digo usando o motor Unity, wi, então de repente este botão aqui gira, gira esta cor de azul-petróleo. E isso me diz, haha, eu posso realmente usá-lo. E eu posso usá-lo porque eu tenho o motor Unity com um namespace aqui. E se passarmos o mouse sobre ele, como você pode ver, namespace, Unity engine wi. E nós podemos realmente usar namespaces em para nós mesmos também. Então, isso também funciona. Podemos adicionar um para o script existente. Por exemplo, assim, nós apenas escrevemos namespace. Em seguida, colocamos o nome do namespace. Normalmente, o que eu diria é que agora que você tem um nome para o seu projeto, então isso é uma espécie de convenção. Você tem um nome para o projeto. Isso, nós vamos apenas chamar nosso projeto, neste caso tutorial. E então você também pode dividir isso com namespaces abaixo basicamente. Assim, você pode criar um namespace de diretórios dentro de um namespace. Mas não precisamos fazer isso assim onde aterrissamos, por exemplo, fazer alguns como namespaces. Namespaces, certo? Não precisamos fazer isso. Isso também funciona, certo? E então o que eu faço é copiar isso rapidamente e eles vão embora. Então temos a classe em vez de um namespace. Agora, não precisamos necessariamente fazer isso. No entanto, eu vou mostrar a vocês logo depois feito com isso, como você pode realmente automatizá-lo lá para que ele adicione automaticamente cada nova classe que você criar em um namespace. Então você não precisa fazer essa marcação aqui, então você não precisa selecionar tudo isso, você sabe, controlar X4 para cortá-lo, Control V para colá-lo, salvar tudo e então você não precisa fazer isso. Podemos realmente automatizar isso. Só quero te mostrar como você pode fazer isso se você não tem um namespace aqui. Mas geralmente eu realmente recomendaria começar com um namespace de qualquer maneira. Uh, mas sim, nós realmente não precisamos definir dois namespaces. Então, neste caso, esta classe namespaces seria acessível se fôssemos como, se estivéssemos em outra classe, então teríamos que colocar em espaços de nomes de ponto tutorial, e então podemos usá-lo. Agora, obviamente, estamos agora neste diretório de sangue negrito específico, digamos que podemos usá-lo de qualquer maneira, mas porque temos dois namespaces aqui, nós também podemos apenas fazer este namespaces. E isso realmente vai nos poupar um pouco de, um pouco de espaço aqui porque então nós podemos realmente fazer tudo assim e então ele não é recuado muito porque se fôssemos ter, então, por exemplo, eu não tenho certeza se Unity UI tem ainda mais namespaces abaixo dele, ele não tem. Mas alguns deles, como você pode ver. Então sistema que a coleção de genéricos tem como três já. Bem genérico não tem nada mais, mas pode ser, talvez seja como em algum momento e, em seguida, é genérico W2 e em util dot core ou o que seja. Assim, você pode ter vários namespaces dentro um do outro. Portanto, é melhor, no entanto, todos tê-lo em uma linha. A ideia é que você quer separar sua base de código. Então, se você tem 100 scripts, então você simplesmente não tem voando em suas pastas, então isso pode, bem, antes de tudo, vai levar a todo meu Deus, onde está o meu roteiro? Onde foi isso? Eu não sei o que isso faz. E com os namespaces, você pode basicamente criar certos grupos de scripts e classes que trabalham juntos e têm um propósito específico. Então, por exemplo, talvez você queira colocar todos os scripts de seus inimigos em um namespace específico. Então, isso seria, por exemplo, inimigos de ponto tutorial. Ou você quer colocar todo o seu combate em coisas nas classes de combate, em seu namespace específico que, por exemplo, poderia ser tutorial.com, algo assim. E talvez você tenha algumas interfaces que vamos ver em um vídeo posterior, o que é em uma palestra posterior. Algumas coisas que você vai usar em todo o código. Você pode, por exemplo, colocar isso na classe YouTube tutorial dot util. Essas seriam coisas que ajudariam com tudo. Assim como a matemática, matemática F era uma espécie de classe util em alguns aspectos. E onde você tem certas outras coisas que você pode querer colocar em um namespace principal. Então, há muitas aplicações para eles. No entanto, agora, o que eu diria é que o mais importante é apenas que eu aconselharia definitivamente usá-los. E quando eu também aconselharia no nosso caso, porque este é basicamente um tipo C-sharp de aula tutorial sobre isso. Eu não, eu não tenho uma boa estrutura aqui dentro da pasta de scripts. No entanto, o que eu pessoalmente aconselharia o que você faz é que sua pasta de script. Portanto, o script deve ser sempre o namespace raiz. Então, tudo, cada script que estaria dentro do roteiro. Então, se eu criar um novo escopo, só para o inferno, leia este aqui. Em teoria ou este script de teste. Eu gostaria que isso fosse no tutorial namespace. E, em seguida, se eu tiver outra pasta aqui, então, por exemplo, namespaces, então eu gostaria que cada classe que está dentro dessa pasta para ser os namespaces de ponto de folha. Então, basicamente, reflita sua estrutura de pastas com sua estrutura de namespace. Mas não vamos nos preocupar com isso agora. Isso é só um aviso que não precisamos nos preocupar. E agora nós podemos realmente também torná-lo para que cada novo script que criamos já obtenha um namespace atribuído. E podemos fazer isso indo para Editar configurações do projeto. E então dentro do editor desce um pouco. E então, como você pode ver, geração de projeto C-sharp, namespace raiz. E nós vamos apenas dizer tutorial. E é isso. Vou salvar isso pressionando o Controle S. e então vamos criar um novo script aqui. Vamos chamar isso, vamos chamá-lo de festivo. - Claro. E se, em seguida, abrir este script, então você pode ver gera com o tutorial namespace. E isso é basicamente tudo o que há para este momento no tempo. Eu não acho que há mais nada para namespaces é apenas uma coisinha curta. E não é a coisa mais importante, mas ainda é algo que, especialmente quando você realmente quer fazer um projeto em realmente não faria um jogo, então eu recomendo olhar para o, também o convenções de namespaces. Nós vamos dar uma olhada nisso no final da introdução C-sharp. Mais uma vez também. No entanto, eu apenas algo para pensar e tipo de importante para a capacidade de expansão e também para entender o código vermelho compreensível do código, a fim de basicamente ter é semi separado funções novidades do código em uma espécie de lugares diferentes, certo ? Foi isso por esta palestra. Espero que tenha achado útil. Se houver alguma pergunta, como sempre, sinta-se à vontade para me perguntar, eu responderei. E sim. 25. Métodos de C#: Muito bem, bem-vindos de volta à introdução do “C sharp “para os núcleos cinéticos. E nesta palestra vamos dar uma olhada nos métodos. Agora os métodos são uma grande parte da programação e C afiado em geral. Então, bem, não vamos perder tempo e ver o que podemos ver abrindo o script de métodos. Também certificando-se de que estamos em Lecture 22 métodos. E vamos abrir e ver o que podemos ver. Então temos visto, digamos, métodos em um pouco no abstrato, onde tínhamos alguns métodos para strings, por exemplo, nós vimos esses. Também vimos que podemos acessar métodos pelo operador ponto. E sim, foram algumas coisas de métodos que vimos. E agora vamos olhar para um exemplo de, por exemplo, uma vez por que métodos seriam realmente bons e muito bons de usar em determinadas circunstâncias. E também, vamos começar por aqui. Vamos só dar uma olhada. Então agora o que queremos fazer é calcular o fatorial. Então podemos fazer isso muito facilmente, na verdade, apenas eles fazendo algo assim e, em seguida, definindo-o para o que queríamos que o fatorial dois calculasse. Factorial é tudo. Então, se quiséssemos fatorial cinco, por exemplo, isso seria exatamente isso cinco vezes quatro vezes três vezes dois vezes um. Então este é o fatorial, é assim que ele é definido. E isso é simplesmente o que queríamos calcular agora. Então, definimos o número fatorial, e então temos um loop for que vamos de um menos um até que eu seja maior ou igual a um. E então nós realmente contamos isso. E então dizemos que os tempos fatoriais são iguais a I. E isso é exatamente o que isso faz porque o fatorial começa aos cinco, eu começo como cinco menos um. Então, às quatro, portanto, nós passamos e nós vezes que assim 5 vezes 4. E então o próximo será 5 vezes 4 vezes 3, e assim por diante até chegarmos a um, e então terminamos. Então, se agora fizermos um log de ponto de depuração fatorial é, e então fazer isso em torno de um movimento. E então salvamos fatorial. E nós podemos realmente imprimi-lo ou log-lo para fora no console. E vamos começar em C. O que é isso, fatorial é 2, 120. Então o fatorial 5 é 120. Agora. E agora a minha coisa é, bem, na verdade, o que eu quero é que eu realmente quero fatorial para oito números diferentes. Eu fui fatorial, por exemplo, para sete e eu também queria para a noite, e eu também quero para D. E eu estava pensando em tê-lo para 11 também. E agora entramos em um problema porque agora temos que pegar isso e talvez copiado umas oito vezes ou algo assim. E isso é claro. Isso é absolutamente ridículo. Não faz nenhum sentido. Isto é o que métodos de guerra. Então nós podemos basicamente pegar a coisa toda aqui e colocá-lo em um método e, em seguida, chamá-lo quantas vezes quisermos. E para fazer isso, o que vamos fazer é ir para fora deste método armazenado porque este também é um método a propósito. E este método é chamado quando um certo, uh, quando o jogo basicamente começa. Vamos a maneira mais fácil de conceituar isso agora. Então nós estamos indo para ir fora do colchete aqui, e nós vamos digitar o seguinte. Vamos digitar int público e, em seguida, o nome do método fatorial. Dentro dele, vamos escrever número int, e eu vou explicar rapidamente o que isso significa. Agora, vamos ter uma flecha aqui por enquanto. A preocupação com isso, vamos resolver isso em breve. Eu só vou explicar rapidamente, explicar como a idéia deste método e o que, o que tudo isso, isso é chamado de modificador de acesso. Vamos dar uma olhada nisso um pouco mais tarde também. Então basicamente o que os modificadores de acesso são e o que exatamente eles fazem. Público, neste caso, significa simplesmente que podemos acessá-lo de qualquer lugar. Nós também temos o tipo de retorno. Portanto, este é o tipo de dados que é retornado de chamar este método. Neste caso, é um inteiro. Como você pode ver aqui no método de início, é realmente nulo. E vazio significa que não retorna nada. Integer neste caso obviamente retorna um inteiro. Então temos o nome do método, então temos os parênteses. E dentro de lá há parâmetros e o tipo de parâmetro é primeiro dado e, em seguida, o nome do parâmetro. Neste caso, queremos dar-lhe um, um número inteiro chamado. E esse número é basicamente esse número aqui que usamos aqui. Então vamos pegar isso e copiá-lo. Agora, algumas coisas que realmente não precisamos. Só precisamos de ser fatoriais aqui. E nós não precisamos fazer isso. E nós não precisamos fazer isso de qualquer maneira. Deixe-me apenas fazer na verdade nós podemos até torná-lo um pouco mais fácil fazendo número, eles vão. E então aqui só precisamos substituir isso com o número e então é isso. E então também retornar, retornar fatorial, o ego. E esse é o método fatorial agora feito. E o que podemos fazer agora é se copiarmos isso rapidamente e dissermos com um método, então podemos dizer fatorial que 25, algo como método é. E então chamamos fatorial. E como você pode ver, na verdade está aqui com esse tipo de cubo lá dentro. E então passamos, por exemplo, seis. E então vamos apenas copiá-lo sobre ele e deixá-lo fazer cinco bem, apenas para que possamos ter certeza de que ele realmente funciona. Mas tenho a certeza que sim. E você pode ver, nós também podemos ver que este é um, tem duas referências porque neste caso, nosso método é chamado 2 vezes 1, 0, 1, 1 aqui. E vamos ver se isso realmente faz alguma coisa, mas tenho certeza que faz, sim. Um 120. E então com o método também é um 120 quando passamos para o cinco e o seis é 720. Então os métodos são uma ferramenta incrível e algo que é realmente, muito importante. Existem alguns princípios fundamentais de métodos, por exemplo, que cada método deve fazer apenas uma coisa e uma coisa sozinha. Os nomes não devem ser muito longos, algo assim. Mas essas são algumas convenções que, como eu disse. Oh, então nós vamos dar uma olhada no final da introdução C-sharp também. Neste momento, os métodos são simplesmente uma forma de basicamente conter certas instruções que queremos fazer. Muitas vezes. É uma maneira de nós de reutilizar código sem copiá-lo. Isso também é uma forma de conceituar métodos. Então é uma maneira de reutilizar código sem copiá-lo. E isso é sempre uma boa indicação se você copiou. Então, se precisarmos desse código fatorial oito vezes R, como eu disse, seria um candidato principal para ter certeza de que há um método fora disso porque, faz sentido se assim que você começar, talvez se Você começa a usar algo duas vezes, você pode debater sobre, bem, eu realmente não preciso de um método para isso. Mas quando você começa a usar uma determinada linha de código, como pela terceira vez, é hora de fazer um método fora dele. Eu acho que isso é uma boa regra de ouro. Sim. Mas esses são os métodos C Sharp. Eu também queria mencionar que às vezes as pessoas podem se referir a eles como funções. É basicamente a mesma coisa. Normalmente, na minha estimativa pelo que ouvi, um método está ligado a objetos e funções são como flutuação livre. Mas geralmente você pode, há sinônimos um para o outro. Então eu posso dizer que isso é funções C-sharp ou métodos C-Sharp. Normalmente qualquer um deve entendê-los como sendo o mesmo. Mas poderia haver algumas pessoas que são como realmente pedantes eram como. Isso não está correto. Escritores como eu estou bem, sim. Correto. Este seria um método. Uma função é algo ligeiramente diferente. No entanto, você pode usar os termos de forma intercambiável, certo? Foi isso para a palestra de métodos. Espero que tenha achado útil. E como sempre, se houver alguma pergunta, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 26. (C#) Exposição: Muito bem, bem-vindos de volta à interrupção em C para o curso de unidade. E nesta palestra vamos dar uma olhada em métodos de sobrecarga, ou também chamado de sobrecarga de método. Então isso é basicamente uma continuação do que podemos fazer com os métodos e ainda assim tão pouco, algo que é semi importante saber o que você pode fazer. Então vamos abrir o script de sobrecarga aqui e ver o que podemos fazer. Então, a primeira coisa que vamos fazer é criar um novo método e vamos fazê-lo retornar um inteiro e chamá-lo multiplicar com dois parâmetros, a e b. E como o nome sugere, ele vai retornar um vezes B. Agora, é claro, definir esse método é absurdo no sentido de que, bem, é bastante fácil apenas escrever um vezes b. E mesmo se tivermos vários parâmetros aqui, então a, B, C, D, E, F, G em talvez o todo alfabeto. Podemos sempre escrevê-lo como um vezes b vezes c e assim por diante. Normalmente esse tipo de método não é algo que realmente precisamos. No entanto, é fácil demonstrar com este método, o conceito de sobrecarga de método. Então o que podemos fazer é registrar, então depurar log ponto. E então podemos multiplicar e então, por exemplo, algo como 10 e três. Então isso retornaria 30. Então vamos ver se isso realmente funciona. Certificando-se de que o método está correto. Palestra 23, sobrecarregando como cena e vamos ver, sim, são 30, então isso é muito bom. E agora você pode fazer é que podemos definir um segundo método, também chamado Multiply. Agora é aqui que fica interessante. Então ele tem que ter exatamente o mesmo nome que este aqui. Assim, o nome tem que ser o mesmo também com maiúsculas e minúsculas como será o mesmo. No entanto, o que podemos fazer é mudar o número de metros e, em seguida, este é um, um método sobrecarregado. Então, por exemplo, se adicionarmos o inteiro c aqui como um parâmetro, e então nós fazemos isso, e então nós podemos retornar, por exemplo, um vezes B vezes C. Nós também poderíamos retornar, a propósito, isso é apenas como um exemplo. Nós também podemos retornar multiplicar AB vezes C. Por exemplo, nós poderíamos, nós poderíamos retornar isso, certo? Então podemos chamar o outro método. E como você pode ver agora, não há erros. Mesmo que eu tenha dois métodos com o mesmo nome. Como, como é que o programa sabe o que levar? Um tem três parâmetros e um tem que ser permanente. Então, se copiarmos isso com o Controle C e depois o Controle V colando, o que podemos ver é se começarmos com a multiplicação, podemos realmente ver que há, eu escrevi isso errado? Eu não nego NÃO. Multiplicar. Estou enlouquecendo? Eu não estou enlouquecendo bem. Por um segundo, eu estava pensando que isso é multiplicado. Agora o que temos que fazer é sim, temos que começar isso. Desculpe, Exatamente. Então, como podem ver, um de dois. Então lá ele percebe que existem dois métodos chamados multiplicá-lo. E ele é como, Ok, um deles tem int a e b e a, uh, pegue essa seta, clique nessa seta, então podemos ver em a em B e C. Então, podemos pegar isso por exemplo, podemos dizer 524 por exemplo. E então também feche o log de pontos de depuração. Então isso funciona também. E então a última coisa que podemos fazer, por exemplo, é multiplicar com carros alegóricos. Então vamos retornar um carro alegórico e vamos multiplicar os carros alegóricos mais uma vez, retornar a vezes b não é nada louco neste caso. E então nós também podemos copiar isso. E então, por exemplo, diga algo como 3.512 para F, por exemplo. E isto é, é o mesmo, é o mesmo nome para todos os três métodos. A única diferença é que parte da assinatura do método. Então este seria o, o modificador de acesso, o tipo de retorno, o nome e os parâmetros. Eles são. Algumas dessas coisas são diferentes, ou seja, os perímetros e também talvez o tipo de retorno. E isso é sobrecarga de método. Pode acontecer às vezes, às vezes há alguns métodos que têm um número diferente de parâmetros porque talvez haja algo que pode, você sabe, um método pode ser chamado de um ou dois ou três parâmetros diferentes, e qualquer um deles está bem. Então, podemos chamar o método com um ou, neste caso, com 23. E então, claro, poderíamos acrescentar a isso, certo? Nós também poderíamos ter uma multiplicação com a, B, C, D, e assim por diante e assim por diante. Mas apenas, apenas mostra que você pode ter métodos que são definidos várias vezes com o mesmo nome, mas assinaturas diferentes, como o número diferente de parâmetros ou diferentes tipos de parâmetros. E isso permite que você sobrecarregue esses métodos. É um conceito importante para definitivamente ter visto. E a melhor coisa a fazer aqui é apenas brincar com ele um pouco, especialmente depois dos métodos. É uma espécie de um próximo grande passo. E então a sobrecarga do método é um pouco em cima disso. Então eu definitivamente sugeriria apenas brincar com ele um pouco, apenas definindo alguns métodos usando algumas das palavras-chave anteriores e estruturas e declarações que aprendemos a brincar com isso um pouco e apenas ver o que você pode ver. E essa é a melhor coisa que posso. Basicamente conselhos neste momento, certo? Espero que tenha achado isso útil. Se houver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 27. (C#) cursos e objetos: Tudo bem, vamos continuar com a introdução de C-sharp aqui para o curso de unidade. E nesta palestra vamos dar uma olhada em classes e objetos. Provavelmente um dos tópicos mais importantes em C-Sharp neste caso. Porque C sharp, como você deve saber, é uma linguagem de programação orientada a objetos. E classes e objetos são uma espécie de um dos blocos de construção mais básicos deste tipo de abstração. Então programação orientada a objetos é apenas uma abstração. Então dizemos que tudo é um objeto. E certos objetos têm membros e métodos. E podemos criar novos objetos e novas classes. E sim, vamos dar uma olhada nisso. Então, em vez de abrir nosso script de classes e objetos, nós estamos realmente indo para criar um novo script clicando com o botão direito do mouse na pasta de objetos 24, 25 classes e, em seguida, indo para criar e, em seguida, C sharp script. E vamos chamar esse arquivo de fruta. Logo depois de termos criado o arquivo de frutas, pode receber um aviso aqui. Não se preocupe com isso. Isso não importa agora. O que importa é que criamos esta classe de frutas e este arquivo de frutas. E eu vou clicar duas vezes nele e então vamos abri-lo. Como podem ver, há um monte de coisas aqui, e nós realmente não queremos isso. Também para notar, agora temos dois arquivos abertos. Então, se você também abrir os objetos de classes, você vai ter ambos abertos e você pode alterá-los. Eles são apenas guias simples como em um navegador basicamente. E essas são as diferentes classes que temos em aberto agora. Agora, vamos fazer é apagar tudo dentro daqui. Então vamos marcar tudo. E então vamos pressionar Enter para que tudo seja excluído. E este comportamento modelo e este dois-pontos também irá apagar de modo que nós só escrevemos aqui frutas de classe pública, e então os colchetes, e é isso. É tudo o que queremos dentro daqui. E, em seguida, dentro de nossas classes e objetos, estamos mais uma vez em vez do método inicial e nós poderíamos realmente já fazer alguma coisa, mas vamos pensar em uma fruta. Por isso, queremos criar uma nova fruta. Agora, quando pensamos em uma fruta, bem, o que faz uma metade de fruta? Então, estamos pensando em um tipo de atributos de uma fruta, certo? Então, uma das coisas que uma fruta em particular pode ter é um número, um nome, certo? Então manga, isso é um nome para uma fruta e uma banana. E também teria uma maçã, certo? Então isso seria um nome para uma fruta. Então, todas as frutas têm um nome. Eu diria que faz sentido. Agora podemos pensar, bem, que atributos diferentes uma fruta também tem? Bem, talvez tenha um teor de açúcar, certo? Talvez você e eu vivamos de forma saudável e você quer saber, eu quero saber o teor de açúcar, você sabe, vamos apenas estar seguros sobre isso. Então é melhor saber isso, certo? Então esse é o teor de açúcar. E então talvez uma outra coisa poderia ser uma cor, por exemplo. Então vamos fazer uma nova string chamada cor. Certo? Agora esses três atributos, isto é o que nós chamaríamos de campos. Então, esses são campos desta classe em particular, frutas. E você pode pensar neles como basicamente os atributos que cada fruta tem, certo? Então, cada fruta tem um certo teor de açúcar, cada fruta tem uma certa cor, e cada fruta tem um certo nome. Agora, pode haver muito mais atributos do que temos agora. Então há muito mais do que estes três. No entanto, vamos ficar com estes três só para tornar as coisas simples, certo? E agora nós podemos realmente usar isso e nós podemos realmente já fazer algo com raízes para que possamos realmente criar uma nova fruta aqui. Então o que vamos fazer é digitar frutas. E como você pode ver, na verdade já sugere isso para nós e vamos criar uma nova fruta e vamos chamá-la de banana. E então vamos dizer que é igual a fruta nova, e depois terminamos com os parênteses. Então, como se estivéssemos chamando um método, como você pode ver, não há erro aqui. E isso não deve ser muito louco. Então esta parte da construção é simplesmente mais uma vez uma declaração de uma variável. Então isso não é nada como não há diferença entre este ano e em x. Basicamente, esta é simplesmente uma nova variável que criamos. E esta variável, neste caso, é do tipo de fruta. Então a única coisa que mudou aqui é que não estamos usando os tipos de dados primitivos. Assim, os tipos de dados primitivos para string e inteiro e assim por diante e assim por diante. Agora nós criamos um tipo de dados complexo, mas nós criamos nossa própria classe e isso é chamado de Fruit. E este ano, basicamente, a tarefa. E nós temos o Mu, nós temos a nova palavra-chave que nós vimos com as listas antes. E agora, no entanto, criamos um novo fruto. E isso pode parecer um pouco estranho no começo. No entanto, isso é basicamente apenas o, uh, como, uh, é basicamente apenas como uma chamada de método. No entanto, neste caso, codificamos o construtor. Então, este é um método muito especial que está relacionado a classes e objetos. Desta forma, nós realmente criar uma nova instância desta classe. E sim, então vamos ver o que podemos realmente fazer é usar isso uma banana e podemos fazer com o operador de pontos. Nós podemos realmente, como você pode ver, você ir e acessar a cor e podemos acessar o nome e o eixo, o teor de açúcar. Então nós podemos realmente acessar todos esses campos como você pode ver, como eles são chamados. E, no entanto, eles podem ser acessados. Então, por exemplo, poderíamos dizer, bem, um nome de banana dot é igual a banana, por exemplo. O que faria sentido. No entanto, na questão aqui sendo nós realmente teríamos que passar por cada um deles e criar um novo nome de um ponto de banana e, em seguida, 80 nano um banana dot teor de açúcar igual, eu não sei, como 15 e assim por diante e assim por diante. Bem, isso parece meio tedioso. No entanto, podemos realmente torná-lo um pouco mais fácil usando este construtor e realmente fazendo nossa própria construção. Portanto, há uma maneira fácil com que podemos fazer o nosso próprio construtor. E isso é pressionando Alt. Entrar. Como você pode ver, então você tem esta sugestão Gerar Construtor aqui, e nós vamos fazer isso e agora podemos escolher quais membros queremos. Então, podemos ter que definir o carrapato aqui. Temos que dizer, ok, quais membros queremos ter como parâmetros no construtor? Nós vamos apenas deixar, ter tudo selecionado e dizer, ok, e então como você pode ver, ele criou um novo construtor para nós com parâmetros aqui e também as atribuições. Então o, esta palavra-chave simplesmente se refere ao objeto que está sendo criado. Então você tem que separar basicamente duas coisas. A classe em si é basicamente um modelo a partir do qual nós, em seguida, criar um objeto e que, em seguida, existe. E então nós também temos os parâmetros que passamos através do construtor aqui, e esses também são separados. No entanto, eles são salvos no objeto. Como você pode ver aqui agora, nós estamos realmente recebendo um, um erro porque não há nenhum argumento dado um que corresponde ao nome do parâmetro formal exigido, e assim por diante e assim por diante. O que isso significa é que não temos parâmetros suficientes aqui e então podemos consertar isso. Bem, poderíamos consertá-lo colocando em banana e depois um conteúdo de frutas e depois uma cor. Ou porque o que acontece é que antes de funcionar e então por que não funciona agora? Bem, nós realmente substituímos o construtor normal, o, o, o construtor básico. E isso é simplesmente, isso foi isso. Então fruta. Oh, lá vai você. E então este, nós substituímos isso porque e nós criamos o nosso próprio. E isso basicamente quando você tem uma nova classe, isso normalmente é gerado. Então isso está sempre lá, mesmo que você não veja. No entanto, assim que você criar seu próprio construtor, isso basicamente não funciona mais. E agora temos que explicitamente digitá-lo e dizer, Ok, este é agora também construtor e, em seguida, isso funciona. Como você pode ver agora, não há mais erros. Mas o que podemos fazer agora é criar um novo fruto. Então, por exemplo, podemos dizer uma, uma maçã. Uma maçã é uma fruta nova. E este tem o nome de maçã. E tem um teor de açúcar de 10, por exemplo, e uma cor de vermelho. E desta forma, criamos agora uma maçã com o nome teor de açúcar de maçã de 10 e, em seguida, a cor vermelha. Então, por exemplo, podemos dizer log de ponto de depuração, e então poderíamos dizer um nome de ponto de maçã. E então vamos apenas imprimir ou registrar tudo, o teor de açúcar e também a cor. Certo? Então vamos ver se isso funciona. Garantir que estamos em palestras 24, 25 aulas e objetos. E vamos apenas executar esta maçã 10 e ler, bem, isso não é ótimo? Isso é muito bom. Isso funciona muito bem. E vamos voltar rapidamente uma vez, mais uma vez para a fruta aqui. E uma das coisas que é notar que vamos olhar em, eu acho, duas palestras. É a palavra-chave pública aqui. Vamos descobrir o que é isso. Vimos isso muito em breve com o modificador de acesso, desculpe, com os métodos. Então este era o modificador de acesso. E vimos isso com os métodos que também os tornamos públicos. Isso significa simplesmente que temos permissão para acessar essas variáveis neste caso. E sim, essa é basicamente a idéia que eu vou colocar rapidamente dentro Então este é, então este é o construtor muito importante e usado para criar novas instâncias. Então isso é basicamente classe desta classe. Então você pode dizer, bem, esta é uma nova instância. Então aqui o, uma maçã é uma nova instância, ou você pode dizer que este é um novo objeto. Este tipo de intercambiável. Mas sim, essa é a visão geral básica do de classes e objetos e também como criá-los. Mais um exemplo, só para que eu os deixe com, é, você poderia pensar em, por exemplo, um, você poderia pensar em um inimigo. E um inimigo pode ser uma classe. Então teríamos uma classe inimiga. E, em seguida, uma classe Emmy, por exemplo, tem pontos de hit inteiros, e assim por diante e assim por diante. E isso é talvez uma coisa que é um pouco mais intimamente relacionado com o desenvolvimento de jogos em si. No entanto, eu acho que há exemplo de frutas também mostra um pouco, Eu definitivamente sugeriria para olhar para as próximas palestras antes de experimentar algumas coisas. Então eu diria que provavelmente até que estamos na Palestra 28 através de onde falamos sobre as propriedades. Eu acho que você deve olhar através deles e então quando terminarmos com eles, então eu, então eu acho que então você pode brincar com as classes e objetos. Há mais algumas coisas que precisamos olhar antes que você possa, antes que eu sugira que você realmente mergulhe, é claro, você pode mergulhar em qualquer momento e experimentar coisas novas assim que quiser. Mas isso é apenas uma simples sugestão minha. Mas sim, foi isso para as aulas e os objetos palestras aqui. Muito importante. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 28. (C#) cursos Membros do curso: Tudo bem, vamos continuar com a introdução em C para o curso de unidade. E nesta palestra, vamos dar uma olhada nos alunos. E isso é basicamente um pouco de aprofundamento da compreensão das classes. Então vamos dar uma olhada em nossa aula de frutas e pensar em volta. Então nós tivemos as, essas variáveis que declaramos. E esses são campos, certo? No entanto, eles também são membros. Então os membros são basicamente uma maneira chique de dizer, bem, isso é parte de uma classe e um campo simplesmente significa que esta é uma variável. Agora, outros membros incluem, por exemplo, um método. Então vamos apenas criar um novo método. Assim, por exemplo, um vazio público, comer frutas, que simplesmente vai fazer o seguinte. Então isto é, temos a formatação correta. Lá vai você. Isso simplesmente vai depurar frutas de log de pontos. E então vamos dizer, esse nome foi comido, certo? Então, neste caso, nós realmente não precisamos do, esta palavra-chave aqui nome pode ser simplificado. Então, nós também podemos apenas escrever nome porque o programa sabe bem, isso significa este nome. No entanto, pessoalmente, às vezes usar o, esta palavra-chave, mesmo que não seja necessário. No meu caso, eu acho que às vezes isso torna um pouco mais claro e você pode ver um pouco mais de perto, ok , isso, com a, esta palavra-chave significa um, basicamente um membro ou um campo desta classe particular. Mas isso é uma escolha estilística. Você não tem que fazer isso. Gostaria apenas de mencionar, no entanto, agora temos um novo método chamado comer frutas. Agora, o que podemos fazer com isso? Quero dizer, é tão fácil como chamar, por exemplo, fruta de maçã? E sim, na verdade é assim que é fácil. Então, um ponto de maçã come frutas como você pode ver, e você também pode ver agora que existem alguns outros métodos que poderíamos chamar. Essas são simplesmente coisas da classe de objeto que cada objeto é, é basicamente uma parte de. No entanto, nós criamos isso, comemos frutas, e vamos chamar isso, e vamos ver o que acontece. Então, se fizermos isso, depois da saída vermelha, devemos ver que frutas, maçã foi comido. Isso é o que a saída deve dizer. Então vamos embora. Isso realmente funciona. Bem, uma vez que começamos eles vão e frutas, maçã foi comido. Bem, isso é muito bom. Isso é muito bom. Sim, e podemos fazer todo tipo de coisas com esses métodos basicamente. Então, neste caso, é um vazio para que não devolva nada. No entanto, podemos, é claro, também fazer outras coisas e pode criar métodos diferentes que retornam coisas diferentes. Então vamos ver, por exemplo, nas próximas palestras é quando treinamos nosso modificador de acesso, talvez tenhamos que fazer alguma coisa. Eles são algo assim. E isso é muito legal. Assim, podemos criar as novas classes que não só têm diferentes variáveis nelas, mas também têm diferentes funcionalidades onde podemos usar essas variáveis, possivelmente manipulá-las. E sim, então esta é uma dessas coisas. Então, em suma, os membros são basicamente apenas partes da classe. Então, neste caso, campos que são basicamente apenas variáveis. E então há também novos métodos que podemos chamar para o nesses objetos e nessas classes, mas em objetos podemos chamá-los na instância específica. Neste caso, uma maçã. Poderíamos dizer também que um ponto de banana come frutas. Isso também funcionaria. Sim, e isso é, eu só queria te mostrar. Então, principalmente o método. Isso é muito legal. E, em seguida, apenas certificando-se que você entende basicamente a terminologia, pelo menos um pouco. Não é absolutamente necessário, mas eu só queria dar a você, o solo que você conhece. Então, esses são campos. E então este é um método e este é um membro e campos também são membros. Sim, então é isso para os alunos. Um pequeno sermão. Espero que tenha achado útil. Se houver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 29. (C#) membros estáticos: Tudo bem, vamos continuar com a introdução de C-sharp aqui para o curso de unidade. E nesta palestra vamos dar uma olhada na palavra-chave estática. Já vimos algumas palavras-chave antes, mas agora a palavra-chave estática também faz parte de classes e objetos. Então ainda vamos precisar da aula de frutas. Mas também precisamos oralmente dessa classe de gripe e o script de frutas neste caso, e o script de palavra-chave estático também. certificar-me de que estamos na Palestra 26, estática neste caso. E vamos apenas abrir o script de palavra-chave estática. E antes que possamos fazer qualquer coisa aqui, nós realmente temos que modificar o script de frutas novamente. E nós vamos criar um novo campo, e isso vai ser um campos estáticos. Então vamos fazer um novo int estático público. Podemos chamar esse número de frutas. Então este é um novo campo estático chamado um numero de frutas. Por isso, neste momento, não faz nada. É apenas sentado lá como você pode ver, se eu pairar sobre ele, você pode ver que ele diz campo, estático, int fruit, número de frutas. Então não há nada realmente especial acontecendo aqui. Agora o que vamos fazer é cada vez que este construtor é chamado, nós vamos dizer um número de raízes mais, mais. Agora isso vai ter um problema porque isso é realmente agora não realmente inicializado. Então vamos dizer, bem, isso é igual a 0 porque agora não há frutas, certo? Então este número de frutas é número de frutas. Vamos apenas, você sabe o que, vamos ser, vamos ser bons programadores e então realmente chamá-lo de número de frutas porque o BER, isso realmente não muda muito quando se trata do nome. Então o número de raízes é igual a 0. E, em seguida, cada vez que um construtor é chamado, nós vamos chamar este número de soquete. Tudo bem, tudo bem. E depois comemos a fruta. Nós também podemos dizer, bem, tal então nós estamos realmente indo para menos isso porque ele foi comido. Então, o fruto é Deus, mesmo que não tenha desaparecido, de modo que tecnicamente não tenha desaparecido. Vamos pensar nisso assim. Bem, ok, mas isso não nos leva a lugar nenhum porque se uma fruta tem isso, então podemos criar uma nova fruta, por exemplo, uma banana de novo. E vamos dizer “fruta nova”. E não vai dizer nada. Amino k é. Então podemos dizer, bem, uma banana pontos um número de, bem, número de Froude, número Froude. Por que você não pode acessá-lo? Bem, isso é estranho. Bem, se olharmos para isto, isto não é chamável porque este é um membro estático ou um campo estático neste caso. Mas também membro estático não poderia ser resfriado a partir do um objeto banana. Bem, na verdade temos que chamá-lo através da aula. Então nós realmente temos que digitar o número de frutos ponto de frutas. E esta é a coisa louca sobre, bem, vamos realmente apenas depurar ponto log isso. Porque então nós podemos realmente ver que isso deve ser um depois que nós criamos este novo alimento, vamos apenas salvar isso. Na verdade, é o caso. E então eu vou explicar para vocês por que a palavra-chave estática é tão incrível. Interessante, Então isso é um 0. Podemos, tenho certeza que podemos descobrir o porquê. Então vamos pensar sobre isso. Bem, porque nós colocamos isso neste construtor e sobre este construtor. Bem, é claro que isso é um problema real. Então vamos copiar isso e colocá-lo aqui também. Então, se chamarmos esse construtor, também vamos aumentar o número de raízes. Então tenho quase certeza de que teremos um dia atrás e há um. Agora, por que a palavra-chave estática é tão grande. Bem, chamamos isso usando a própria classe. Então dizemos número de frutos de ponto de frutas. Por que isso de alguma forma é especial ou algo assim? Bem, esta variável, este campo neste caso, é na verdade completamente independente de cada fruta em particular. Então, no caso do número de frutas, realmente não faz sentido armazenar quantas frutas estão com cada fruta. Porque antes de tudo, realmente não faz sentido porque uma banana saberia quantas frutas existem nesta parede do mundo, como uma banana em particular. Aquela grelha não faz sentido nenhum. Mas também que cada fruta em particular saberia quantos alimentos existem. Você sabe, isso é, isso não faz nenhum sentido. Então você também pode chamar esse tipo de variável global. Eu digo isso com, você sabe, com cautela, mas você pode pensar nisso como uma variável global que existe para a classe de fruta, não uma vez para cada um dos objetos que são criados a partir do fruto. Por isso, só existe uma vez. Você pode pensar na estática, também pode ser, você também pode ter métodos estáticos neste caso. Então, digamos estática. E então poderíamos apenas dizer evite, por exemplo, e então apenas obter o número. Vamos fazer isso. Sim, recebe o número de frutas. Neste caso. Nós estamos, na verdade, vamos fazer isso um inteiro e então ter esse número de retorno de frutos deste. Claro que, neste caso, não é realmente necessário, no entanto, apenas para ilustrar o fato de que também podemos ter métodos estáticos. Métodos estáticos na maior parte do tempo eu não diria a maior parte do tempo, mas algumas das vezes podem ser, por exemplo, uma espécie de métodos auxiliares. Eles podem ser uma espécie de geração de métodos geradores. Então você poderia ter algo como um público buscar frutas, gerar frutas. Então, geraria uma fruta aleatória. Então, por exemplo. Sim, no entanto, a idéia de estática é apenas que ele não está ligado a um objeto específico, ele está ligado à classe específica. Então isso é muito importante. Às vezes, especialmente no começo. A diferença pode ser um pouco incompreendido, talvez, ou talvez um pouco mais difícil de entender. No entanto, eu acho que uma vez que você, uma vez que nós começamos e vemos mais alguns exemplos disso, eu tenho certeza que nós vamos descobrir como um pouco mais rápido. Certo, o que é isso? Como é que isto funciona? O que é isso exatamente? Mas agora, o que diz que a palavra-chave estática realmente útil? E você também pode ver esta última coisa. Então, se eu fizer esse número de frutos, como você pode ver, isso não funciona porque isso é exatamente a mesma coisa que fizemos antes, onde um número de banana dot de raízes não funciona porque o número de frutas não está ligado a um objeto de um fruto ou como exemplo de prensas de frutas ligadas à categoria. Isso é tudo para a palavra-chave estática. Sim, é incrivelmente útil. Ele pode ser realmente útil e há, há uma abundância de aplicações reais para ele. E no futuro, definitivamente vamos ver mais e mais disso à medida que continuamos através da introdução do C3b, bem como entrar na parte da unidade do curso, porque eles são, vamos ter muitas métodos estáticos e também campos. Então, sim, se houver alguma pergunta no entanto, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 30. (C#) modificadores de acesso: Tudo bem, vamos continuar com a introdução de C-sharp para o curso de unidade. E nesta palestra vamos dar uma olhada nos modificadores de acesso. Então modificadores de acesso, já vimos o modificador de acesso público antes quando estávamos falando sobre métodos e também quando falamos sobre classes. E agora vamos basicamente mergulhar ainda mais fundo nelas e ver quais são os diferentes tipos e o que podemos fazer acontecer com elas. Então, por exemplo, Vamos apenas abrir nosso script de acesso e também certifique-se de que abrimos o script da pessoa que está aqui. Isto é, nós vamos usar a classe Pessoa neste caso, e nós não vamos continuar com a, uh, com a classe de frutas muito agradável. Vamos ficar com a pessoa agora mesmo. Então, o que a pessoa tem? Bem, vamos apenas dizer que uma pessoa tem um primeiro nome e uma pessoa tem um sobrenome. E ambos serão públicos. E esses agora estariam acessíveis em todos os lugares. Agora em todos os lugares, é claro, não significa literalmente em todos os lugares. No entanto, dentro do nosso programa, em todos os lugares do programa, se você criar uma nova pessoa, nome e o sobrenome podem ser lidos. Ok, isso é justo, isso não é muito louco. Também podemos pensar, bem, talvez tenhamos um número inteiro h e queremos que isso seja protegido. Tão protegido idade int. E isso agora é um pouco mais complexo. E isso basicamente é acessível para a classe em si. Então tudo o que eu escrevo dentro dos colchetes aqui entre para esta classe, certo? Então, se eu tiver um método aqui, eu posso ir para a idade, mudá-lo e usá-lo. O que eu termino. Isso também pode ser acessado, tão acessível, tão acessível para todos por si só, certo? Então isso é pela própria classe, classes finais derivadas disso. Isso é um pouco estranho. Ok, o que é isso? Bem, isso é frio em herança e isso vai ser falado em uma palestra futura, muito importante. No entanto, eu queria mostrar-lhe a palavra-chave protegida, neste caso, é utilizável na classe pessoa, mas não, não fora dela. Então, enquanto eu poderia usar, eu poderia fazer , por exemplo, agora vamos fazer o último e então vamos ver um exemplo disso. Então o último seria privado. E isso é, por exemplo, uma string. Então, por exemplo, um número de Seguridade Social. Isso parece algo que provavelmente seria melhor ser apenas acessível. Acessível somente por esta classe. Porque não queremos ser lidos, nem queremos que isso seja mutável do lado de fora. Então, se criarmos o construtor pressionando mais uma vez Alt e, em seguida, em Gerar Construtor, vamos ter todos os quatro campos como perímetros. E nós vamos ficar com isso. Eu gosto disso. Graça. Então poderíamos, por exemplo, pensar em algo assim. Assim, poderíamos também fazer um método privado ou público. Então vamos fazer um bool privado é da idade de beber, por exemplo, nós poderíamos fazer isso e isso poderia então retornar uma idade booleana maior ou igual a 21 anos se estamos nos Estados Unidos, se somos obstáculo na Alemanha, por exemplo, este seriam 16. Dependendo do tipo de licor. Vamos deixar isso fora da equação. Vamos ficar com 21 neste caso. Como você pode ver, idade, nenhum problema. Posso acessá-lo aqui. Eu posso mudá-lo. Também a segurança social, o meu eu mudei aqui. Não é um problema se você entrar agora em nosso script de acesso e nós vamos criar uma nova pessoa. Então vamos criar uma pessoa de Frederick. Então cale-se com você. E vamos criar uma nova pessoa. E, claro, FirstName é retórica, e então o sobrenome vai ser Johnson. Se eu puder datilografar, eles vão e ele vai ter 26 anos. E o número do seguro social, quero dizer, não faço ideia. Então vamos colocar algo assim lá dentro. Eu gosto, certo? Então, isso é ótimo. Agora temos um novo objeto chamado Frederick, então nova variável chamada fosfórico. E nós vamos dizer log de pontos de depuração. E então podemos, por exemplo, dizer Frederick, esse primeiro nome. Isso é totalmente bom. Podemos imprimir FirstName. Podemos também, se olharmos para as sugestões, imprimir o sobrenome. Como você pode ver, quero dizer que tanto a idade o número de segurança social ausente e também estava faltando é o método que criamos. Então, podemos gostar de fazer isso, mas tanto h e número de segurança social e não acessível. Isso é exatamente certo. Então temos porque o protegido gostaria de dizer, só acessível na própria classe. Então, enquanto isso agora é um privado, talvez digamos, ok, você sabe o que, isso pode ser público, na verdade, como. Isso é algo que talvez seja importante para as pessoas saberem. Como se eu saísse da idade da bebida. Podemos também dizer, ter um método chamado é uma idade de voto, por exemplo, certo? E então, é claro, dependendo do país, isso muda. Vamos resumir isto e dizer: “ Está bem, ou a idade para beber é agora 21 anos. E podemos fazer isso e nem temos que revelar a idade dele em teoria, certo? Então podemos apenas fazer algo como e vamos apenas dizer algo como Ken, pessoa, beber. E então podemos dizer boo ponto retórico é da idade da bebida e depois chamar isso, e isso agora retornará um booleano e B. Podemos acessar isso. Então vamos ver, é claro, com um 26, a pessoa não pode beber. Então vamos ver quando temos Lecture 27, acesso aberto. Frederick Johnson, alguém pode beber, é verdade? Vamos ver se mudamos isso. Então, se mudarmos o nome aqui, ou melhor, a idade para, digamos 20. O que, claro, no nosso caso, seria. Menos de 21, então o anel da pessoa Ken deve virar falso. Lá vai você. Isso é exatamente o que eu queria ver. E o melhor disso é que nem temos que abrir a idade, certo? Então isso é muito bom. Então, no nosso caso, é claro que não saberíamos. Está bem. É a pessoa acima de 21 ou abaixo de 21 anos , no entanto, não saberíamos a idade da pessoa diretamente. Isso é parcialmente útil no nosso caso porque não há nenhum caso de uso real aqui. Isso, claro, só para ilustrar. Mas sim, estes são os três modificadores de acesso, público, protegido e privado. Normalmente, isso é apenas algo que é uma prática muito boa. Tudo deve ser privado, exceto se há uma boa razão para não tê-lo privado ou precisa ser acessível de fora. Isso muda um pouco quando falamos em trabalhar especificamente no Unity. Porque, na verdade, temos um benefício adicional. Eles são porque nós podemos usar alguma maneira interessante em que ainda podemos tipo de ver o que os valores privados mantêm sem torná-los públicos. O que nós vamos olhar para isso, quando nós realmente chegar à unidade agora em C afiado, eu diria usar variáveis privadas, o que você pode então. Além disso, se realmente precisarmos usá-los, podemos alterá-los adicionando uma guitarra ou uma configuração. Agora, um getter ou uma configuração são basicamente maneiras em que ainda podemos acessar variáveis, mas tê-las ainda ser privadas. Então eu acredito que se formos aqui, nós deveríamos realmente saber que não podemos realmente fazer isso. Talvez possamos fazer isso com isso. Nós realmente não podemos bem, que eu pensei que poderíamos gerá-los automaticamente. Acredito que há uma maneira de gerá-los automaticamente. Na verdade. Ele realmente diz que devemos usar uma propriedade. Isto vai ser o que vamos usar da próxima vez. Então, neste caso, uma configuração seria, ou uma guitarra seria uma corda pública. Obter social. Vou ligar para este número só por um momento. E então vamos devolver esse número do Seguro Social. E então um cetera simplesmente significa definir isso. Este seria um vazio e como um número de seg social string. E então este não devolve, mas este é especificamente este. Então vamos fazer isso e depois colocar isso, eles vão, certo? Então isso seria uma guitarra e uma armação. No nosso caso, é claro, não é realmente o que queremos porque nós realmente não queremos de qualquer lugar no tipo de número de segurança para ser obtido ou mesmo para ser definido. No entanto, no nosso caso, apenas como exemplo, isso às vezes é útil. No entanto, eu só vou deletar novamente porque geralmente, e nós não usamos getters e setters em C-Sharp. Normalmente, em C Sharp usamos propriedades. E isso é exatamente o que vamos olhar na próxima palestra. Então foi isso para esta palestra com, para os modificadores de acesso. Espero que isso tenha sido útil para você. E eu, é claro, realmente apreciaria uma revisão sua se você achasse útil até, até este ponto. E como sempre, se houver alguma pergunta, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 31. (C#) C#: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em um C propriedades afiadas. Então temos visto um monte de coisas sobre as classes e objetos, alguns modificadores de acesso. E agora vamos dar uma olhada nas propriedades. Então, para isso, temos o script de propriedade e um script de estudante. Sim. E o script dos alunos, mais uma vez, é apenas uma aula em branco sem nenhuma das coisas Unity e o script de propriedades neste caso tem o nosso método inicial. Mas vamos começar aqui no roteiro do aluno. Então, podemos, por exemplo, dizer que um aluno tem um nome público String, certo? Isso, isso faria sentido. Que um aluno tem um primeiro nome e vamos copiar isso e também fazer um sobrenome fora disso. Agora, isto funciona. Mas antes de tudo, ele diz: “Ei, você sabe, talvez o que você queira fazer é encapsular este campo usando uma propriedade, e é isso que realmente vamos fazer. Então, primeiro as coisas que vamos realmente fazer a convenção de nomes aqui para uma propriedade é uma letra maiúscula. E então, como você pode ver, o que vamos começar é que vamos ter esses colchetes. Vamos remover o ponto-e-vírgula no final. E dentro desses colchetes, vamos escrever “Get and Set”. E com isso, já declaramos um campo. E você pode ver que agora temos, em vez de ter a caixa lenta aqui, nós realmente temos essa chave inglesa e este registro simplesmente significa que este é um campo ou uma propriedade em vez disso. E vamos fazer isso. Vamos fazer o sobrenome também. Eles vão. E vamos também fazer, e esta é uma das coisas legais que podemos fazer. Então, por exemplo, agora temos essas duas propriedades. E isso está tudo bem e bem, e é tipo, ok, o que isso significa? O que é que isso faz? Bem, obviamente o que podemos fazer agora, vamos fazer um novo aluno também. Vamos, sim, vamos fazer novos alunos. Então vamos fazer uma aluna. Vamos chamá-los Sim, claro estudantes, por que ou por que não? E a nova aluna. Então, por exemplo, podemos realmente chamar o primeiro nome do ponto do aluno como você pode ver, e o sobrenome do ponto do aluno. E como você pode ver aqui também, nós temos oh, lá vai você. Bem, espere um segundo. Vamos fazer isso de novo. Lá vai você. Então, por último temos obter e definir para que possamos ver que podemos ou obter esta variável, neste caso, esta propriedade, ou podemos configurá-la. Agora o que nós também podemos fazer é fazer isso bem, você sabe, então talvez possamos mudar nosso botão FirstName. Você tem o sobrenome que está definido em pedra. Então vamos fazer disso um conjunto privado. E se eu for, como podem ver, ainda posso acessar o primeiro nome e o sobrenome, mas diz conjunto privado. E se eu disser agora, por exemplo, algo como Arnold Smith, então ele vai dizer a propriedade ou índice, nosso sobrenome não pode ser usado neste contexto porque é definido X é inacessível, simplesmente significa que temos um set. No entanto, um bem público. E essa é uma das coisas muito fáceis, ou maneiras fáceis de definir a variável como privada ou pública. E o que também podemos fazer, por exemplo, é que podemos definir uma nova string chamada FullName. E usando as propriedades que podemos dizer obter. E em vez de colocar um ponto e vírgula normal aqui, podemos basicamente retornar algo que queremos ter retornado. Então, por exemplo, podemos retornar este ponto FirstName mais, e, em seguida, um espaço, este sobrenome ponto. E com isso nós temos, isso também pode ser um método, mas também podemos colocá-lo em uma propriedade como esta. E não há nenhum conjunto nisso em tudo porque o nome completo nunca é dito que isso nunca é ter variável que mudamos. Só conseguimos através do primeiro e último nome. E como apenas adicionar rapidamente um público. Agora vamos realmente adicionar uma, uma idade também. Então, em idade com um público e uma instalação privada, certo? E isso é tão fácil quanto adicionar isso. Isso também tem o bônus adicional que, claro, quando nós, por exemplo, definir algo, nós podemos realmente, em vez de apenas enviar uma variável, podemos fazer uma chamada de método ou algo assim, certo? Podemos, por exemplo, em teoria, ter uma variável privada por trás de tudo. Então podemos ter uma variável privada, idade, por exemplo, digamos, bem, vamos dizer nada. E então o que podemos fazer é em vez de ter o tipo de coisa não visível que é como invisível com essas cordas. Podemos fazer isso e, em seguida, dizer retorno H aqui, e então este e o conjunto privado por exemplo, nós também podemos fazer e isso seria então aij é igual ao valor. Então o valor é simplesmente o que passaríamos lá. E isso também funcionaria. Eu só queria mostrar rapidamente que podemos basicamente ter um excesso de para esta variável que é então privada. E, em seguida, por último, mas não menos importante, vamos apenas fazer um construtor Student rápido aqui com string firstname. Vamos fazer isso corretamente. Firstname, o ego, string, LastName, e um número inteiro h. E então vamos apenas dizer FirstName é igual a FirstName, Sobrenome é igual a sobrenome, e idade é igual a h. Agora, mais uma vez, podemos definir essa idade porque nós são mesmo que o centro é privado, porque estamos na sala de aula. E podemos, por exemplo, se agora realmente dermos um nome a este aluno. Digamos que Jordan Smith, 31 anos, algo assim. Então, é claro, podemos depurar log algumas coisas interessantes. Então, por exemplo, podemos depurar bloqueio de Student dot FirstName. Podemos bloquear o sobrenome do aluno. Também podemos olhar o nome completo, certo? Essa foi a coisa interessante. E podemos bloquear a idade. No entanto, não podemos mudar a idade porque, como você pode ver, o setter é privado. Você nem tem uma armadilha. Aqui. O vendedor também ficaria orgulhoso e poderíamos mudar o FirstName, mas não escolhemos escrever. Então vamos ver rapidamente a saída disso agora isso não deve ser muito louco, é claro que vai apenas para Jordan, Jordan Smith. E, em seguida, o nome completo e, em seguida, idade como dissemos. E apenas para mencionar rapidamente, por que, por que nós usaríamos propriedades C Sharp? Bem, quero dizer um do lago, vejamos. Realmente boas razões é que podemos dissociar a obtenção e a configuração, a acessibilidade basicamente, certo? Então isso é uma coisa que realmente não podemos fazer com campos normais e variáveis normais dentro das classes. Isso não funciona. E também com ter o, ter isso, então ter o getter e o setter e ser capaz de basicamente ter adicionado funcionalidade nele. Isso pode realmente funcionar para que, em primeiro lugar, se quisermos mudar algo, podemos fazê-lo com muita facilidade. E em segundo lugar, poderíamos, por exemplo, manter uma contagem. Quantas vezes algo é definido, quantas vezes algo é obter se isso pode ou não ser o melhor exemplo. Mas podemos basicamente adicionar funcionalidade para a obtenção na configuração de uma variável específica que pode ser útil. Então, para a configuração pode ser algo como nós sempre queremos salvar a configuração anterior para que possamos mudar de volta ou algo assim. Então podemos sempre salvar isso em uma variável diferente que pode não ser acessível fora ou o que quer que seja. Então, existem algumas aplicações, mas o principal takeaway, eu acho que é muito legal é que a entrada na configuração pode ter diferentes configurações de acessibilidade basicamente, certo? Já era isso para as propriedades. É um papel relativamente importante em C-Sharp. Mas uma vez que você vê, é bastante óbvio. Normalmente dentro do Unity é um pouco complicado trabalhar com propriedades porque Unity realmente não é um grande fã de propriedades, considerando todas as coisas. Mas podemos nos livrar de usá-los se também tivermos esses campos únicos neste caso. Então, se temos os campos privados, então podemos basicamente contornar isso. Mas sim, isso foi apenas uma introdução rápida para o para as propriedades aqui. Como sempre, se houver alguma pergunta, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 32. (C#) vigília: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada na herança. Então, continuando junto com ele, as classes e objetos que agora vamos olhar para basicamente subclasses e herança. E para isso temos para as aulas no ano pronto animal, gato, cão e herança. Se abrirmos todos eles, então podemos ver que a herança é apenas deve estar vazia. Quero dizer, todas as aulas devem estar vazias ou estão cheias dependendo do que você escolheu olhar. No entanto, o importante aqui é que o animal, o cão e o gato não têm nada chique aqui. Então eles não têm um método inicial, eles não têm nenhuma herança. Eles estão basicamente vazios. E no script de herança aqui tem o método de início onde queremos implementar coisas. Bem, vamos começar na aula de animais. E vamos pensar, quero dizer, um animal tem um monte de coisas diferentes que, como atributos que ele pode ter e campo. Pode ter sido. A única coisa que realmente nos interessa agora é uma cadeia protegida. Vamos chamar isto de espécie. E lembre-se de volta, portanto variáveis protegidas apenas acessíveis por subclasses. E está certo. Lembramos que tivemos isso na palestra modificadores de acesso onde vimos que havia público, protegido e privado e protegido tipo de senta-se entre aqueles. E vamos ver como podemos usar isso a nosso favor agora em herança. Então vamos criar dois métodos aqui, public void run, que simplesmente vai depurar dot log o seguinte. Então ele vai fazer com que esta espécie de ponto está agora em execução. E depois vamos copiar isto. E vamos manter o outro método, comer. E então nós vamos apenas dizer que esta espécie está comendo agora. E isso é tudo para o animal agora. Agora vamos pensar sobre isso. O que são alguns animais agora, é claro, Eu já tenho o cão eo gato. No entanto, você também pode ter um BVA ou movimentos ou flecha, grande tubarão branco, por exemplo, há um monte de animais. E, claro, o que todos eles têm em comum é que eles são um animal, mas eles também têm coisas diferentes que podem fazer. Então talvez haja algo interessante aqui. Mas a primeira coisa que vamos fazer é dentro da aula de cães, vamos fazer com que ele herde de animais. Como é que fazemos isto? Nós vamos atrás do cão de classe pública e, em seguida, nós digitamos um cólon, e em seguida, a classe que ele deriva, então, neste caso, animal. E o que isso traz agora, como podem ver, nada aconteceu aqui. Parece que funciona. Nada interessante acontecendo aqui. O que podemos fazer é que podemos agora, que tal fazermos um novo cão público? Então este é um novo construtor aqui. E bem, nós sabemos que este é um cão, então nós realmente não precisamos mudar o nós não precisamos dar nenhum parâmetro a eles. E quanto às Espécies? Então, como, Ok, bem, esta espécie de ponto. Bem, como posso acessar a espécie? Isto não é, eu, eu não declarei nada bem, porque nós temos derivado esta porta de animais. E dentro do animal temos uma espécie de chamada de cordas protegidas. É por isso que podemos mudá-lo aqui e podemos, por exemplo, dizer cão. E agora o, cada vez que criarmos um cão que é um objeto, terá espécies, o campo, basicamente definido para cães. Agora vamos também fazer um método público chamado casca. Depurar log de pontos. Não é uma flecha, mas normal. Vamos fazer a certeza. Vamos latir, latir. Por que não? Eles vão. Quer dizer, pode ser qualquer coisa, mas vamos fazer assim. E então vamos também para o catalisador. Na verdade, basta copiar isso rapidamente porque isso vai tornar isso um pouco mais fácil. E então também fazer este animal. Então isso herda do animal. Isto é um gato. Você vai fazer um gato e ele vai realmente miar, por favor. Que tal aquele? E então vamos miar uma vez porque isso é ótimo, certo? E agora temos um gato, um cão, e ambos são animais. Mas agora vem a questão, bem, quero dizer, o que podemos fazer agora? Gosta mesmo de onde? Onde está a coisa interessante aqui? E a coisa interessante vem disso. Digamos que temos um cão chamado Fluffy. E este é um novo médico só por causa da discussão. Agora fofinho, agora. Fofo. Se eu puder escrever corretamente, o ego pode latir. Ele pode comer, e ele pode correr. Mas se olharmos para trás, então se eu disser que ele vai correr, se pensarmos nesta largura em segundo lugar, isto é um cão. Quero dizer, nós não dissemos especificamente que um cão pode correr, um animal pode correr, mas nós não temos como redefinir este método dentro do cão. No entanto, ainda funciona. E se olharmos para as definições aqui, então se eu colocar em fofo e eu pairar sobre tão selecionado como você pode ver, latir é de cães. Então este era o método em uma espécie de cão comer é um método dentro do animal. O mesmo com correr. Esses são os dois métodos que têm, nós criamos na classe animal e na classe do cão. E digamos que pela última coisa que vamos fazer, uma casca fofa, certo? E vamos ver. Então o que esperaríamos aqui é que gostaríamos de ver o cão agora está correndo, então atracamos não é comer e depois latir, latir, acredito que é o que queremos ver. Então vamos ver se isso funciona. Então vamos fazer este. Sim. Como você vê, o cão está agora correndo, log, agora está comendo e latido, latir. Tudo funciona totalmente bem. Poderíamos fazer o mesmo com a câmera agora. Então vamos fazer isso. Gato inteiro ele bigodes. Claro, é um ótimo nome. Bigodes, ponto correr. Apenas o mesmo. E bigodes também podem comer. E também miau neste caso porque bigodes é gato. Agora, uma coisa interessante, muito interessante. Porque ambos, vamos considerar isso um pouco, Diego. Porque ambos são animais. Também pode ter um animal chamado Henry. E isso é, por exemplo, em novo gato, certo? Agora, isto funciona. Anteriormente. Nós sempre vimos que o tipo de dados que demos uma variável deve ser o mesmo que, digamos, o construtor que criamos. No entanto, porque o gato é um animal, também podemos salvar este novo gato dentro de um animal. Uma variável que funciona. E quando chamamos Henry dot-dot-dot comer e Henry dot run, por exemplo, vamos mudar isso para que tenhamos em todos os lugares corretamente. E então eu também vou colocar em um pequeno ano divisor para que nós saibamos qual é qual. Então, depois da divisória, então devemos ver os bigodes. Então cão corre cão comer do que latir, boné executar gato comer Meow, e então gato e gato correr novamente. Sim, exatamente. Então nós temos cachorro latido, nós temos gato gato, miau, nós continuamos correndo gato ED. Mesmo que Henry aqui seja um animal. Então o M, Este é um animal. Pode fazer tudo o que um animal pode, mas não pode fazer o quê? Um gato. Então Henry, Henry. Me. É uma enxerga que não funciona. Vai lançar um erro porque animal, não contém definição para miau porque não sabemos atualmente que Henry é um animal, um gato. Sabemos que é um animal e razão animal definitivamente. Mas Katas como Mao não funciona. Henri que o macho não trabalha. Seja como for, podemos lançar Henry para um gato. Se sabemos que é um gato, não necessariamente, mas neste caso, este é um daqueles momentos em que podemos ter um custo mais complexo, digamos. Então, há duas maneiras de fazer isso. Podemos, por exemplo, digitar, desculpe, podemos digitar Henry como gato, miau, como você pode ver. Isso funciona. Então esta é a palavra-chave como simplesmente é quase a mesma que custar. E também podemos fazer basicamente dois parênteses, colocando gato, como já vimos antes, então fazer Henry e depois fazer miau. Então, essas seriam duas maneiras de lançar Henry para um gato. Sabemos que Henry é um gato. É por isso que isto funciona. Se nós, por exemplo, fizermos algo assim. Então cão e depois diz latir. Eu não faria. Quero dizer, vamos ver o que acontece. Você está certo. Quer dizer, isso é porque podemos fazer isso também e ver o que acontece aqui. E você pode ver que temos uma referência nula porque isso, claro, não funciona porque Henry não é um gato. Henry é um, Henry não é um cão. Henry é um gato. Já disse gato e cachorro tantas vezes. Eu nem sei mais onde adicionar. Então lá vai você, miau e outro miau. Como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 33. (C#) Polymorphism: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. E nesta palestra vamos dar uma olhada no polimorfismo. Agora, esta é uma palavra gigante para um conceito tão fácil. Quando você realmente pensa sobre isso, na verdade é ridículo. Então vamos dar uma olhada em nossa aula de herança e nossas cláusulas de animais, cães e gatos. Agora o que nós fizemos é que tivemos na última palestra um método chamado Comer, que basicamente apenas saída esta espécie de ponto está comendo agora. E o que vamos fazer é dizer, bem, você sabe, cães e gatos podem comer coisas diferentes. Portanto, o que vamos fazer é, na verdade, substituir esses métodos. Mesmo que eles sejam uma chamada de método, uma citação da classe Animal, agora vamos fazer uma nova funcionalidade neles e vamos digitar em público conhecido, vazio, comer. Então, sem os sete, de preferência eles vão. Ideia aqui ser que o, que toda a assinatura do método é o mesmo, exceto para este novo. E este novo basicamente significa um, este vai ser um novo método com o mesmo nome. E nós vamos dizer esta espécie de ponto. Agora está comendo um pouco de bife, por exemplo, para o cachorro. Certo? Então vamos colocar isso e então vamos copiar isso rapidamente para o gato. E então este está talvez bebendo um pouco de leite. E eles vão, nós criamos agora para comer métodos dentro de nossas classes herdadas. E o que vamos ver é que todas as instruções, por assim dizer, vão se transformar em exatamente o que o cão ou gato específico é, você sabe, o que eles estão comendo. Então vamos fazer isso e ver o que acontece aqui. Se descermos, como podem ver, cão está comendo um pouco de bife, boné, agora está bebendo um pouco de leite. E agora a coisa muito interessante, porque aqui, Kant está comendo agora. Por que isso é legal, mesmo sendo um gato? Bem, vamos lembrar aqui atrás, Henry realmente é um animal. Portanto, o animal que come fica frio. E aqui o gato ponto-ponto fica frio, eles vêem. Então essa é também uma das coisas interessantes que você pode ter várias definições ou implementações diferentes, neste caso, uma implementações diferentes do mesmo método. E dependendo do que a subclasse é, podemos ter implementações diferentes específicas dela. E mesmo quando o chamamos no animal, ele pode ter uma implementação diferente, diferente das classes derivadas. Um outro exemplo disso que eu vi algumas vezes é que você pode ter uma espécie de área, então uma classe de área. E então isso pode ter getArea como o método. E então a classe de álgebra pode ser herdada por, por exemplo, um quadrado e um círculo. E enquanto a área de, você sabe como obter a área ou a área é a mesma no sentido de que é, digamos, por exemplo, metros quadrados, essa é sempre a área. Mas a maneira de chegar à área para um quadrado é diferente de um círculo. É por isso que você precisa de implementações diferentes para basicamente a mesma coisa que você quer acabar com quatro subclasses diferentes como um exemplo, certo? Na verdade, é isso. Se para polimorfismo não é a maior coisa. E eu também não aconselharia a me debruçar muito sobre isso. É uma palavra grande para um conceito muito simples. E eu acho que mesmo no iene, uma última coisa é que o método de sobrecarga que já vimos na maneira Lecture, maneira um objetivo que é basicamente também polimorfismo. Isso simplesmente significa que você tem vários métodos com o mesmo nome ou várias implementações de um método, e todos eles têm o mesmo nome. Então, isso também seria considerado polimorfismo. Eu diria que isso foi realmente uma coisa muito fácil de entender. Muito mais fácil do que o nome de polimorfismo sugere. E sim, é basicamente isso para esta palestra. Espero que você tenha achado útil se houver alguma pergunta como sempre, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 34. (C#) abstratos e métodos em C#: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em métodos abstratos, classes abstratas. A idéia é que vamos continuar junto com as classes, herança, as coisas lado de C Sharp. E temos três roteiros aqui, o abstrato, o animal abstrato, e o castor. Número um, agora o castor primeiro, ou vamos olhar para o castor, ficar vazios. A classe animal abstrata deve estar vazia. E então o resumo é mais uma vez aquele com o método da estrela, mas também vazio. E a primeira coisa que vamos fazer é o animal abstrato vai obter uma nova palavra-chave aqui, e essa é a palavra-chave abstrata. Então vamos torná-lo nesta classe específica abstrato. O que isso significa, vamos ver em alguns instantes. Mas antes de tudo, vamos preencher esta classe com algumas coisas familiares, como uma string protegida por preditor, espécies, espécies e, em seguida, também um método de execução de vazio público. log de pontos de depuração com esta espécie de ponto agora está em execução. Agora já vimos isso na herança normal antes que tínhamos um método de execução. E agora vamos definir um método abstrato também. Agora o método abstrato vai ser muito interessante. Então isso vai ser um vazio abstrato público. E vamos chamar isso de método de som animal. E então vamos fechar isso com um ponto-e-vírgula. E como você pode ver, é isso porque, e essas são as coisas interessantes. Então métodos abstratos não têm implementação, implementação dentro de classes abstratas. Certo? Isso é o muito interessante. E o interessante é que o derivado ou as subclasses, certo? Eles precisam, eles devem implementar isso individualmente. Isso também é muito interessante de se ver. E a palavra-chave abstrata para métodos específicos, para métodos específicos só pode ser usada dentro de classes abstratas. Então, se não fizermos este abstrato, então em breve vamos ver é abstrato, mas contém em uma classe não-abstrata que não funciona. Portanto, precisamos fazer esta classe abstrata para que possamos usar esta palavra-chave abstrata para um método específico. Agora, o castor, em vez de derivar de animal, vai ser um animal abstrato. A ideia é praticamente a mesma. A diferença aqui só é que, bem, eu queria mostrar a palavra-chave abstrata com um exemplo semelhante que mostramos herança com. E o castor agora tem uma flecha aqui e diz, não implementa os métodos abstratos herdados, animal abstrato, som animal. Agora o que podemos fazer é que podemos realmente corrigi-lo com as várias maneiras que podemos ir para o, na verdade, é mais fácil ir aqui e dizer implementar classe abstrata. E então ele vai fazer isso por conta própria. Então vamos sobrescrever o método dos sons dos animais. E então ele vai ser como lançar uma nova exceção aqui. Nós realmente não precisamos disso porque nós. Bem, quero dizer, não sei o que o castor diz, mas digamos que diz algo como “OK”. E então também podemos fazer um Vivre público. E então vamos dizer que esta espécie de ponto é igual a Beaver. E sim, essa é basicamente a idéia de um método abstrato. Então precisamos usar a palavra-chave override aqui, a fim de tipo de substituir o método abstrato e deixar claro que esta é basicamente a implementação do castor. Nós também podemos pensar, pensar de volta para o gato e o cão. Se eles tivessem o animal abstrato como lá, a superclasse, então poderíamos imaginar que faríamos exatamente o mesmo. E então a amostra animal, basicamente o lobo e o miau que temos anteriormente no animal normal e o exemplo do gato e o exemplo do cão que implementamos basicamente como um como por conta própria, no, nas próprias subclasses. Neste caso, no entanto, nós realmente implementamos isso bem aqui. Na classe abstrata, foi a, bem, basicamente a idéia. E, em seguida, a implementação é para baixo para cada uma das classes derivadas. Agora o que podemos fazer, bem, vamos enterrar o castor. Por que não? Sou Barry, o castor e a baga. Bem, em primeiro lugar, corra porque isso é o que ele poderia fazer. E então ele vai saber que não vai comer. Na verdade, ele não pode comer agora. Mas o que podemos fazer, e isso é o melhor. Barry pode fazer som animal. Então muito pode fazer som animal. E há mais uma coisa que eu queria mostrar a vocês quando se trata de classes abstratas. Um animal abstrato, certo? Podemos dizer animal abstrato, como fizemos com o animal. E digamos, por exemplo, que temos Mary, o castor, e então temos um novo castor. Mas isto funciona. Agora, Mary é um animal abstrato. Mas se quisermos fazer o seguinte, então queríamos fazer o animal abstrato Larry, porque vamos com ele é um novo animal abstrato. O que vamos ver é que isso não funciona porque não podemos criar uma instância da classe abstrata ou da interface animal abstrata. Então a idéia aqui é que não podemos criar instâncias de uma classe abstrata. Isso é o que é realmente importante aqui. Então, uma classe abstrata, é por isso que é abstrata. Não pode ter, você não pode ter um animal abstrato neste caso. Agora, quando nós realmente pensamos sobre isso, faz sentido que algumas coisas. Então, por exemplo, mesmo no caso de um animal, poderíamos imaginar, bem, quero dizer, ter apenas um novo animal realmente não faz muito sentido quando você realmente pensa sobre isso. Precisamos de ter uma coisa mais específica. Até um castor que é mais específico do que um animal. Então podemos imaginar, bem, fazer animal igual a novo animal não faz, realmente não faz sentido. Então, neste caso, isso ainda é, então não podemos realmente criar novas instâncias de classes abstratas. E eles, no entanto, têm o benefício adicional de ter o som animal aqui. E então também, se tivermos Mary, por exemplo, ainda podemos dizer Mary dot som animal. E Mary ainda vai dizer, Ah, então vamos ver. Nós primeiro teríamos castor agora está correndo e depois, e depois em diante. O primeiro, claro, é de enterrar o castor e, em seguida, o casado o castor fez no segundo. E podemos, claro, chamar isso porque lembre-se quando não tivemos isso implementado, nós realmente tivemos um erro na classe viva porque esses métodos abstratos devem ser implementados, certo? Então, como podem ver, escolhi a palavra “deve ano”. Eles têm de ser implementados. Não há outra maneira. E sim, essa é a introdução básica à classe abstrata e ao método abstrato. Também em todo este ecossistema de programação orientada a objetos, incrivelmente útil e incrivelmente interessante. Mas, por enquanto, acredito que vamos deixar assim. Como sempre. Se houver alguma dúvida, não se esqueça de perguntar e eu responderei. E sim. 35. (C#) métodos virtuais: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nos métodos virtuais. Agora os métodos virtuais, assim como os abstratos, os contrapartes abstratos, eles são muito semelhantes. Eles podem ser algo que tem a ver mais uma vez com a implementação em subclasses e não. Então vamos dar uma olhada no animal abstrato novamente. E vamos adicionar o nosso bom e velho favorito, o público evitar o método de comer. E vamos também adicionar o log de depuração. Digamos que esta espécie agora está comendo. Isso é algo que temos visto muitas vezes, não exatamente, mas já vimos isso antes. E agora, em vez de apenas ter este um método normal, vamos fazer deste um método virtual. Agora, à primeira vista, nada mudou porque a idéia deste método virtual é que um, este é basicamente um membro que pode ser substituído pelo derivado ou a subclasse. Então, no caso do castor, podemos optar por substituí-la ou não. Agora, no nosso caso, vamos sobrescrevê-lo. E o que fazemos é simplesmente fazer a mesma coisa que fizemos com o método abstrato só porque isso não é uma, não é uma obrigação. Então não precisamos fazer isso sobrescrever. E então, como você pode ver, na verdade já é apresentado aqui. E neste caso, se chamarmos base ponto-ponto, isto é o que acontece. Ele realmente esfria o método virtual aqui. Mas no nosso caso, não queremos chamar isso. Às vezes, pode ser o caso que sabemos que queremos chamar isso. Mas na maioria das vezes, eu descobri que você realmente não quer chamar isso também. E então vamos fazer isso. Espécies de ponto agora está comendo um pouco de madeira. Por exemplo, porque, claro, estamos lidando com castores. E agora podemos, se voltarmos ao roteiro abstrato, por exemplo, tanto Barry ponto-ponto quanto Mary ponto-ponto. Seremos felizes. Então, como você pode ver agora, também é muito importante é mais uma vez, porque Mary é um animal abstrato aqui. Barry ganha ponto castor, Marie fica, tem animal abstrato, ponto-ponto. Isto é basicamente a mesma coisa que vimos com o polimorfismo. No entanto, neste caso, porque temos um método substituído, ambos os carvões são para o sobrescrito do que o BVA fez. Mesmo que Mary seja um animal abstrato. Ela também é um castor. E é por isso que na implementação castor é chamado, neste caso, para o método virtual, certo? Na verdade, é isso. Para os métodos virtuais, não há nada de extravagante nisso. Como você pode ver, há muita sobreposição em muitas dessas coisas. No entanto, existem algumas diferenças bastante sutis. Como eu disse, um método abstrato deve ser implementado por uma subclasse ou classe Dr. Um método virtual pode ser substituído, muito importante. Também é muito importante. Um método virtual pode existir em qualquer classe. Um método abstrato só pode existir em classes abstratas com, e foi isso para esta palestra. Espero que você tenha achado útil se houver alguma pergunta como sempre sinta-se livre para perguntar agora certifique-se de responder. E sim. 36. Interface (C#) C#: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas interfaces. Então interfaces são algo que é muito semelhante às classes abstratas, mas de alguma forma ainda um pouco diferente. Como podem ver, temos as interfaces de um avião e um roteiro de pássaro aqui. E vamos criar um novo script também. E vai haver um novo código de script C-sharp que eu pilotei. E vamos ignorar este e o erro aqui, ou melhor, o aviso. E nós vamos apenas clicar duas vezes sobre a IA flable. Livre-se de tudo o que está dentro daqui, também disso, e em vez de uma aula pública, isso vai ser uma interface pública. Ele, agora o nome vai virar uma espécie de cor amarela. E dentro dela, vamos basicamente definir um método abstrato. Mas não vai abstrair, só vai ser basicamente o tipo de retorno, então o nome do método, os parênteses, e foi isso. Isso é literalmente tudo o que precisamos fazer para colocar na interface neste caso. Assim, a i-ésima interface rótulo pode ser implementada por certas classes que bem deve ter a capacidade de voar. Claro, o avião e o pássaro de ambos têm a capacidade de voar. Portanto, ambos irão implementar a interface flable AI. É a mesma ideia que colocamos aqui no cólon. E então podemos ver, hey, não implementa membros da interface. Então nós vamos dizer, ok, vamos fazê-los. E então nós simplesmente temos que implementar o método fly para que isso possa ser chamado. No nosso caso, o que vamos fazer para o avião é que ele vai simplesmente registrar a partida dos motores a jato. Motores, eles vão. E no pássaro, nós realmente vamos ter algo muito, muito interessante aqui. Na verdade, vamos dizer, bem, isto é um animal. Você também pode, nós também poderíamos dizer que este é um animal abstrato. Só vamos dizer animal. E também é tão duas vírgula i flable. E então temos que implementar a interface também. E aqui vamos fazer o seguinte. Nós vamos dizer Debug dot log, flapping. Vamos fazer batendo. Suas asas. Eles vão. E como você pode ver, o pássaro agora é um animal e um olho voável. E esses realmente não são. Eles não deveriam ser como mutuamente exclusivos. Por quê? Certo? Porque, claro, se você é um animal, você pode voar que, isso faz sentido em um avião, também pode voar. O que é importante é que uma classe sempre pode herdar apenas de uma outra classe. No entanto, ele pode ter várias interfaces implementadas. E vamos ver como isso ficaria dentro de nosso método de início de interfaces aqui. Então vamos ter uma lista de eu voar. E vamos chamar isso de coisas que podem voar. Porque isso é literalmente o que a interface de inteligência artificial basicamente tenta nos mostrar. E nós vamos dizer coisas que podem voar ponto adicionar. E depois vamos dizê-lo, passarinho novo. E vamos copiar isto e dizer “avião novo”. E então vamos apenas adicionar alguns. Vamos torná-lo um pouco aleatório. Pássaro aqui, um avião aqui, e o pássaro aqui e talvez um avião no final também. Eles vão. E então nós vamos ter um para cada loop no final aqui. E agora o interessante é que em vez de ter isso ser pássaro ou avião, podemos ter este eu voável, chamar isso de flable, e então olhar para as coisas da coleção que podem voar. E, em seguida, chamar flable dot fly. E agora por que isso é uma coisa tão interessante e louca? Oh, desculpe, lá vai você. Desculpe, lá vai você. Por que isso é tão louco e interessante? Bem, temos definido ou implementado especificamente motor jato ou as asas em cada uma das classes que implementaram a interface olho flable. Mas ainda estamos chamando o método fly na interface flable. Então, o que vai acontecer? Bem, nós gostaríamos de ver é exatamente isso. Bem, isso está em colapso agora. Então vamos fazer com que não desmorone. E então, como você pode ver, batendo suas asas e, em seguida, ligando os motores a jato, Stirling motor batendo suas asas, batendo suas asas, ligando os motores de prato girando, girando e motores a jato. Então, mesmo que tenhamos frio tudo na interface aqui, na interface como um tipo de dados, ainda temos os métodos implementados reais. E isso é exatamente a grande coisa sobre a interface. Porque desde que saibamos, está bem, algo é um olho voável. Podemos sempre chamar voar nisso. E sempre vai funcionar. E então a grande coisa é que nós também podemos então convertê-lo em uma espécie de interface de IA flable. E ainda vai funcionar que podemos dizer, ok, vamos fazer o método mosca sobre isso. O, uma outra coisa interessante que eu tinha com isso que são realmente era como um caso de uso real que eu tinha em como tipo de jogo de hobby que eu estava programando era que eu tinha. Então foi basicamente imaginar como um RPG 2D, digamos, como Zelda. E assim como a velha Zelda, digamos. E você foi capaz de falar com coisas específicas. Então você é capaz de falar com certas pessoas, é claro, certo, NPCs. Mas então você também pode pressionar a tecla superior, por exemplo, para um console específico ou se houvesse um fogão, então você pode dizer, ei, o que faz esse peso? E você pode clicar e meio que falar com ele em mais ou menos. E eu implementei uma interface de bolha eu falo. E que eu falo sobre interface então me deu a capacidade de basicamente o que quer que seja, falar com ele, basicamente ter o método de conversa, conversa vazia ou mesmo conversa de primavera, algo assim. E eu fui então capaz de, uma vez que o implementado em, por exemplo, um NPC ou qualquer outra coisa, eu era capaz de então fazer a implementação lá. Quem quer que seja a principal coisa que foi procurado foi eu falar sobre sim. Então fale comigo. E sim, essa é a interface pode ser usada em inúmeras coisas diferentes e tenho certeza que vamos ver alguns exemplos disso na programação real quando chegarmos à unidade. momento, este é, sim, este seria o fim para a interface. Espero que tenha achado útil como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 37. (C#) de idiomas: Tudo bem, vamos continuar com a introdução do C afiado aqui para o curso da unidade. Nesta palestra, vamos dar uma olhada rápida nas enums. Enums são basicamente uma espécie do último tipo de big data que vamos olhar. Eles têm a habilidade em que podemos tipo de, é uma espécie de lista pré-definida. Vamos só dar uma olhada. Então temos dois scripts, o script de dificuldade de jogo e no script enumeração. Vamos abrir o loop interno primeiro. E vamos mudar imediatamente para o script de dificuldade do jogo. A idéia é que há duas maneiras ou tipo de dois lugares onde não poderíamos definir um enum. Nós podemos definir um enum em seu próprio script ou podemos defini-lo em uma espécie de outro script ou, orando uma classe. Pessoalmente, eu acho que é melhor se você colocá-los em seu próprio script. No entanto, às vezes pode ser mais fácil colocá-los apenas basicamente no lado do script onde eles pertencem. Então temos a dificuldade do jogo enum e vamos definir fácil, médio e difícil. E como você pode ver, esta é a maneira que uma espécie de enumeração funciona. Temos enumeração pública e o nome da enumeração. E então o tipo individual de coisas pré-definidas que pode ser para nós. Para a dificuldade do jogo, pode ser fácil, médio ou difícil. Então essas são as únicas três coisas que pode ser. É por isso que, por exemplo, uma instrução switch com um enum é realmente útil porque você tem muito apenas coisas predefinidas que pode ser. Portanto, isso é algum aplicativo onde isso pode ser realmente útil. Agora, nós também podemos fazer o que podemos em teoria. Então, digamos, por exemplo, enumere linguagem e defina linguagem. Então, por exemplo, alemão, inglês, francês, ou algo assim. E então criamos uma enumeração dentro desta classe enums. Como eu disse, às vezes pode ser útil, às vezes não porque era, você quer acessar isso fora da classe. Então, é claro, você precisa torná-lo público e também você precisará chamar enums dot language. Pode ser um pouco estranho às vezes. Mas de qualquer forma, vamos criar uma nova dificuldade de jogo de baralho, por exemplo, chamá-lo de dificuldade de jogo é igual a dificuldade de jogo ponto fácil. Então esta é a maneira que isso está escrito. Então isso cria uma nova variável de tipo de dificuldade de jogo e, em seguida, define-o para o valor fácil. Nós também podemos fazer o mesmo com o idioma, idioma e torná-lo idioma ponto Inglês, porque é isso que é. E se fôssemos então depurar ponto log isso, então, por exemplo, dificuldade do jogo, e vamos copiar isso e depurar a linguagem de bloqueio de depuração. Então. Bem, vamos ver o que podemos conseguir com isso. Alguns interessantes, bem, fáceis e ingleses. Portanto, é literalmente exatamente o que escrevemos aqui. Então isso também é um tipo de bom que podemos simplesmente sair. E isso obtém saída. Por que usaríamos enums em vez de uma ANOVA, por exemplo, como uma string ou algo assim. Bem, em uma corda podemos sempre fazer uma flecha. Podemos escrever algo ou algo assim em um enumeração. Nós sempre chamá-lo chamando o nome do enum e, em seguida, ponto e , em seguida, quaisquer que sejam os valores predefinidos para ele. Portanto, não podemos realmente digitar nada errado. Sim, e isso é basicamente, já que as enums podem ser muito, muito úteis para certas coisas. A melhor coisa é mais uma vez tentar com ele um pouco, ver o que você pode ver. E então eu acredito que nas futuras palestras, especialmente quando olhamos para mais do que vamos ver alguns exemplos dessas também. Então, sim, foi isso para esta palestra. Espero que tenha achado útil. Se houver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 38. (C#) Exceções e a declaração de teste e catch: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas exceções. Então, o que são exceções? Já vimos alguns deles quando há um erro. Basicamente, isso é o que poderíamos chamar de exceção. Mas vamos apenas abrir o script de exceção aqui e vamos ver o que podemos ver. Então, primeiro de tudo, vamos fazer um novo array inteiro aqui com dois inteiros. E então vamos dizer log de pontos de depuração. E então vamos dizer números três. Quero dizer, para falar nisso, nós também podemos fazer o número dois, e isso basicamente lançará uma exceção. Agora, o que é uma exceção? Bem, vamos pensar nisso assim. Vamos apenas dizer, vamos fazer isso Olá. Eu também estou aqui é outra saída que nós vamos fazer depois de chamar números dois, que é claro que não existe porque números só vai de 0 para um, porque 0 é o primeiro índice e, em seguida, o segundo índice é um. Então vamos chamar isso de fim. Como podemos ver, vamos ter índice fora do intervalo exceção. índice estava fora dos limites da matriz, e então tudo depois não se apossou. Agora, por que essa exceção é? Por que precisamos, por que isso acontece? O que está acontecendo aqui? Bem, é claro que cometemos um erro aqui. O erro neste caso foi que estamos tentando acessar um número ou algo que não existe, e, portanto, ele vai lançar uma exceção. Agora, podemos fazer algo sobre isso. E o que podemos fazer sobre isso é que podemos basicamente garantir que não façamos isso mesmo que uma exceção aconteça, tudo ainda continua. Então eu basicamente comentei isso e vamos criar um novo método para isso. Só para mostrar isso, vamos chamar isso de método de divisão. Nós vamos apenas dividir o float a e por float b. Então nós vamos retornar a dividido por b. E, famosamente, você não pode dividir por 0. Então, se d for igual a 0, o que vamos fazer é lançar uma nova exceção, fria ou uma mensagem dentro dela. Não é possível dividir por 0. Então vamos fazer isso. Então vamos fazer o log de pontos de depuração. Vamos dividir algo como dez dividido por cinco. E depois um segundo. Vamos fazer 22 divididos por 0. Vamos chamar isto como é. E vamos ver o que acontece. Vamos começar. E como podemos ver, vamos ter uma exceção aqui lançada. Você não pode dividir por 0 exatamente a mensagem que colocamos aqui. O que também podemos fazer é colocar um 22 dividido por 0 também. Vamos colocar assim. E como você pode ver, isso realmente não funciona porque 0 é uma constante. Então nós precisaríamos fazer algo como float z e eu nem tenho certeza, ok, este funciona porque o, esta é uma variável e não verifica variáveis. Se fizermos isso, vamos entrar, vamos ficar infinitos. Muito interessante. Tão infinito, que é claro. Você poderia dizer: “Bem, quero dizer, isso é muito bom, não é? Isso está tudo bem. Eu teria que adivinhar que vai quebrar muito mais coisas do que ter a exceção lançada neste caso. Então, por quê? Por que precisamos disso? O que podemos fazer? Bem, podemos fazer o seguinte, e isso é uma grande coisa. O que podemos fazer é fazer algo que se chama “tentar pegar”. Então vamos colocar a palavra-chave “try”. E então vamos colocar na palavra-chave que tem parênteses depois dela. E então dentro daqui vamos fazer exceção e. E então vamos colocar a depuração dentro disso. E digamos também ter uma depuração aqui. E vamos depurar o registo. Vamos ver avisando a exceção. E vamos, sim, vamos fazer isso. E vamos também, por exemplo, colocar outro. Então um 120 por seis ou algo assim. Esta é a exceção deste é o normal e este é apenas um depois dele. Então vamos ver o que acontece agora. Vamos chamar isto. E como você pode ver, dois e, em seguida, temos o, a exceção do sistema. Não é possível dividir por 0. Agora, isso não é mais um erro, porque o que fizemos foi citar a exceção com esta captura. E o que fez. E o que é possível aqui é que podemos continuar basicamente. Então, se eu fosse fazer isso e eu digo, depois de tentar e pegar, então o que podemos ver é o seguinte, que o código continuará e retomará depois dessa tentativa e pegar, e não vai parar. É por isso que tentar pegar, sabe, tipo de coisa é realmente boa. Há também algo chamado Finalmente, que podemos usar. E isso finalmente fica frio no que quer que aconteça aqui. Então, primeiro tentamos isso e vamos pegar isso, e então vamos finalmente fazer isso. Aconteça o que acontecer, se pegarmos ou não uma exceção. Isto finalmente fica frio. E no final aqui a idéia é que, bem, ok, exceções, eu estou meio que entendendo, mas por que precisamos delas? A idéia de é que lançamos uma exceção em vez de o programa falhar. Essa é uma das grandes coisas. Assim, uma exceção é lançada quando normalmente isso realmente chamaria como levar a um acidente. Mas podemos tentar isso com certas coisas. Nem sempre sabemos onde as exceções podem ser lançadas. No entanto, às vezes sabemos e, em seguida, podemos basicamente pegá-los com esta declaração de tentativa e captura aqui. E as idéias estão sendo, mais uma vez que podemos então espero que seja com a captura, Faça algo sobre isso ou torná-lo para que possamos corrigir um erro que pode ocorrer mais tarde na linha. Então isso, é claro, talvez não seja a melhor ideia para fazer isso. Nós também poderíamos fazer isso um pouco diferente em especialmente dentro da própria Unidade, nós também podemos lançar um erro. Assim, a era do log de depuração também funcionaria. No entanto, neste caso, eu realmente acho que ter este lance uma exceção é realmente totalmente bom, certo? Isso é tudo para exceções. É só uma breve visão geral. Mais uma vez, não é nada para, digamos excitante ou não é nada muito importante na verdade. Mas ainda é bom ter visto isso uma vez antes, só para que você saiba, o que é essa tentativa e pegar significa e o que é uma exceção. Então, se foi isso para esta palestra, espero que tenha achado útil. Se houver alguma pergunta, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 39. (C#) conceitos básicos do Generics no C#: Muito bem, bem-vindos de volta à introdução da queda íngreme aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida em um genérico. Certo, então vamos abrir o script genérico aqui. E também temos um script de par já pronto. E vamos criar um script genérico. Então já vimos algo sobre genéricos que era, por exemplo, uma lista. E você pode ver isso é lista e, em seguida, t dentro desses suportes angulares. E então nós fomos capazes de apenas colocar em basicamente qualquer tipo de uma variável lá dentro. Então qualquer tipo de dados que pudemos colocar dentro dos suportes angulares e funcionou. E isso é basicamente o que queremos criar agora. Então, queremos criar uma classe que é uma classe genérica onde seria capaz de colocar em qualquer tipo de variável ou tipo de dados. E eu vou mostrar isso com uma classe que eu uso para mim em uma base semi-regular, eu diria que há algo que é muito semelhante chamado uma tupla. Eu acredito que isso está sob sistema, System.Out tupla, certo? E você pode basicamente, como você pode ver, você pode fazer 12 ou outra coisa. O problema com uma tupla é que, embora você possa basicamente colocar em vários tipos de dados diferentes, você nunca pode alterá-los. Então você tem um conjunto uma vez e então está feito. E é por isso que eu tenho basicamente essa classe de par que vamos criar agora. Então, é bastante fácil. Na verdade, colocamos os colchetes angulares e, em seguida, vamos colocar em x e y. Estes são geralmente significados com um, uma maiúscula e um caractere singular. Mas, em teoria, você também pode chamá-lo de x2 ou o que quer que seja. Mas X e Y vão ficar bem. Então nós vamos ter um novo, um novo campo aqui, que vai ser x primeiro. E então isso vai realmente ser uma propriedade é definido. E então vamos ter um público por que segundo, que também getter e setter. E depois vamos ter um público. Oh, desculpe, vamos fazer mais uma. Lá vai você. Par público x primeiro, y segundo. E então este vai ser este primeiro SQL para primeiro. E isso é igual a segundo. E isso já é para a classe de pares. É assim que pode ser fácil. Vamos primeiro precisar realmente envolver sua cabeça em torno disso. O que isso significa? Como é que isto funciona? Bem, se eu colocar em uma string, string, por exemplo, então isso seria simplesmente uma string pública. Se eu colocar um animal inteiro, então este seria um inteiro e este seria um animal. Você pode realmente usá-lo para o que quiser. E o x e o y simplesmente são substituídos por qualquer tipo de dados que você coloca quando você declara a variável. Então, por exemplo, podemos colocar em um par chamado int string. E vamos chamar esse exemplo de um. Não, uau, Ok, vamos chamá-lo de par um, y nada, que é um novo par de string int. E então dentro daqui, colocamos em 2005 e, por exemplo, um sim. E a grande coisa é que podemos depois dizer que par um ponto primeiro é, por exemplo, igual a, falar com 200. Então nós podemos realmente mudar isso. E se nós, em seguida, por exemplo, dizer par com animal e corda, então podemos chamar isso p R2. E este é um novo par de animal e corda com, por exemplo, um novo pássaro. E um pássaro novo e uma corda. - Claro. Porque, por que não? E então podemos, por exemplo, também chamar primeiro, que é um ponto-ponto animal. Então isso é uma coisa muito legal porque primeiro é um animal, podemos então chamar o método de comer sobre isso e ele simplesmente vai funcionar. Então, a idéia de genéricos, isso é como um pouco, como um exemplo muito básico, certo? Tipo, não muito complicado. Porque, em teoria, pelo menos na minha experiência pessoal, descobri que é muito raro precisarmos um novo genérico muito complicado para qualquer coisa. Qualquer outra coisa geralmente também é factível com bastante facilidade. Há alguns momentos em que eles podem ser aplicáveis. É por isso que estou mostrando isso como um exemplo. Mas geralmente, tenho que ser honesto, é muito raro que eles realmente apareçam. Se alguma vez aparecerem. Vimos isto e depois podemos, naturalmente, alargar este assunto. Mas por agora, é aqui que vou deixar. Como eu disse, uma visão geral muito básica dos genéricos. No entanto, como sempre, se houver alguma dúvida, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 40. (C#) conceitos básicos do LINQ no C#: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida em um link. Então, o que está ligado? Bem, vamos abrir o link no roteiro e ver o que podemos ver. Então, este vai ser um olhar muito básico no link, ou também conhecido como linguagem integrada consulta. E nós vamos ter dois exemplos agora Eu vou mostrar a vocês como você pode basicamente filtrar uma lista. E então eu posso, eu também vou mostrar-lhe como encomendar uma lista por um determinado parâmetro, digamos. Então, a primeira coisa, nós podemos obter uma nova lista que contém apenas os machos yahoo.com neste exemplo, por exemplo, onde não será como, eu quero todos que têm o e-mail yahoo.com. Eu quero esses. Bem, nós podemos realmente obter isso por, primeiro lugar, ter este usando o link System.out. Muito importante. Então precisamos estar usando este namespace e, em seguida, temos acesso a novos métodos em nossa lista. Então, como você pode ver, tudo como média consultável paralela, temos o método concat, temos alguns métodos aqui. E o método que vamos usar é onde. Então este é basicamente um método que nos permite filtrar. E agora vamos ter uma, uma coisa interessante Basicamente que vamos olhar, que vai ser uma expressão lambda. E isso vai ficar assim. Então vamos ter um macho, então podemos ter essa flecha basicamente, certo? Isto é basicamente um, um sinal de igual e, em seguida, interesse maior do que. E então aqui vamos escrever email dot contém yahoo.com, e então é isso. E isso basicamente filtra isso. Agora isso retorna um novo, neste caso, ele retorna um novo ferro inumerável. Se fizermos para listar , não para string, mas para listar. Então isso vai retornar uma nova lista na qual é provavelmente o que queremos. Mas o que é este ano, certo? Então isso pode parecer um pouco estranho. Eu não entendo isso. Nunca vimos a flecha antes da expressão lambda. O que é isto? Bem, a idéia é que no desgaste leva um funk, como você pode ver, system.out.print. E o que é um funk? Bem, um fungo, basicamente um tipo variável ou um tipo de dados que armazena um método ou função. Agora fungo definido como tendo uma string, neste caso como a entrada e um bool como a saída. Então é isso que significa a corda bool. O correio. Então o, cada elemento é sempre a entrada neste caso, certo? Então, cada um dos elementos é a entrada. E então queremos o booleano como uma saída. Está dentro da nossa nova lista ou não? E então eu vou dizer, bem, se ele contém yahoo.com, então ele vai fazer parte de uma lista. Se não acontecer, então não fará parte de uma lista. E isso é realmente tão fácil quanto isso filtrar isso para pessoas que já viram coisas como quem trabalhou com SQL, por exemplo, é semelhante a isso de muitas maneiras. E para o segundo exemplo, eu vou rapidamente apenas copiar sobre algo. Então eu vou copiar uma lista de números inteiros chamados de pontuações altas. Eles são basicamente aleatoriamente, mas são apenas aleatórios. E o que vamos fazer é fazer pontuações altas ponto OrderBy. Esta é a ordem pelo método. E nós podemos então dizer pontuação e, em seguida, apenas dizer pontuação por exemplo. Então isso agora ordenaria as pontuações mais altas. Bem, pelo, pela pontuação real. Como você pode ver, o funk há um inteiro e, em seguida, ele tem outro inteiro. Então é isso que está sendo comparado. E isso é basicamente mais uma vez, na verdade isso, mas isso é o que está sendo comparado. A idéia é que poderíamos, por exemplo, em vez de ter uma lista inteira, poderíamos ter uma lista de strings. E então poderíamos ordenar por, por exemplo, o comprimento de cada uma das cordas, que também funcionaria. Este é basicamente o inteiro que é dado de volta aqui. Então, estamos simplesmente retornando o inteiro em si, portanto, ordenando por ele. Isso realmente é apenas um olhar muito rápido para isso, um olhar muito básico para ele. Há muito mais coisas aqui. Mas, mais uma vez, como muitos desses, digamos exemplos posteriores aqui ou tópicos posteriores. Eles realmente não são tão propícios para isso. Olhando para a Unidade em si. Eu só queria mencionar isso mais uma vez, e também algo que você pode, claro, pesquisar por conta própria. E se algumas pessoas estiverem interessadas nisso, eu poderia fazer uma palestra adicional. Assim, as expressões lambda, por exemplo, podem ser pelo menos um pouco interessantes. Embora existam também outros tipos de dados que usamos ou outras formas de usar coisas semelhantes dentro do Unity. Bem, sim, essa foi basicamente a visão básica da Link. Como eu disse, se houver interesse suficiente, eu poderia mergulhar um pouco mais fundo aqui. Para a Unidade propriamente dita, ela não é realmente necessária. Esses métodos que eu mostrei a você, o desgaste na ordem por aqueles são realmente bons e , em seguida, talvez alguns outros que poderiam ser úteis. Mas neste ponto, acredito que esses são os dois principais e tudo o mais que você definitivamente pode olhar. E se houver interesses, como eu disse, só para perguntar se há algo pouco claro aqui, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 41. (C#) Eventos e delegações: Muito bem, bem-vindos de volta à introdução do “C sharp “aqui para o curso da unidade. Nesta palestra, vamos dar uma olhada nos eventos e os delegados. Este é um, outro tópico mais avançado. E vamos dar uma olhada rápida e ver o que podemos ver. Então, o delicado roteiro, vamos apenas abrir isso. Nós já temos um temporizador de flutuação e um tempo de alvos flutuantes. Agora, como você pode ver, isso é declarado dentro da classe em vez do método start. E isso é uma coisa muito importante porque nós vamos realmente usar um outro método do Unity desta vez apenas para mostrar este exemplo. E este será o método de atualização. O método de atualização é simplesmente algo que é chamado uma vez por quadro. Então você deve ter ouvido os jogos rodarem a 60 quadros por segundo. E então esse método seria chamado 60 vezes por segundo. Agora o que queremos fazer é criar algo onde basicamente chamamos um determinado método a cada 10 segundos ou a cada segundo, definimos esse tempo alvo como, por exemplo. E vamos fazer isso com o sistema de delegados e eventos. Querido aqui é que vamos apenas na verdade, vamos primeiro fazer um método que queremos chamar. Então, por exemplo, mensagem de teste de anulação privada. E nós vamos colocar no log de pontos de depuração, não um erro, mas log normal, apenas saída um, saída de uma mensagem, algo assim. E queremos chamar esse método em particular toda vez que algo acontece. E podemos fazer isso fazendo o seguinte. Então vamos fazer um delegado primeiro. Então este é um vazio de delegado público. E então nós vamos chamar isso, digamos em dez segundos passados, apenas como um exemplo. E no delegado, como você pode ver, deve ter a mesma assinatura do método que vamos chamá-lo. Então isso é vazio, então este é basicamente o tipo de retorno e, em seguida, também não há parâmetros dentro daqui. Então basicamente a mesma assinatura que sim, método, queremos chamá-lo. E então o que podemos fazer é enquanto este é o delegado, então temos um evento e, em seguida, objetos podem basicamente subscrever esse evento. Então vamos ter um evento público. E este é do tipo em dez segundos passados, onde este é basicamente o tipo de evento. E então vamos dar um nome, por exemplo, autocomplete. E é assim que o evento e delegados basicamente funcionam a inicialização. Assim, objetos, objetos podem se inscrever em eventos. Certo? O que vamos fazer agora é adicionar o método da mensagem de teste. Para o evento, e cada vez que esse evento é resfriado, esse método é chamado. Então, digamos, por exemplo, OnComplete. E então nós vamos fazer mais igual a mensagem de teste. E o importante é que sem os parênteses, então só vamos pegar o nome do método aqui. E o que isso vai fazer é basicamente isso vai adicionar este método a uma lista neste evento. Que quando este evento ficar frio, então nós vamos ter certeza de que este calendário de mensagem de teste também. Então vamos adicionar uma maneira de chamar isso. Então é por isso que tenho este temporizador aqui. Há uma maneira bastante fácil de basicamente adicionar o temporizador. Agora isso vai ser uma coisa justa, bastante fácil. Eu vou explicar este tempo alvo e então nós vamos dizer temporizadores iguais a 0. E então vamos dizer OnComplete e chamar isso e isso é igual. E o que está acontecendo aqui? Bem, cada quadro, vamos basicamente adicionar um pouco de tempo a esta variável temporizador que é 0. E então nós vamos verificar, hey, o temporizador é maior ou igual ao tempo do banheiro? Se for esse o caso, vamos redefinir o temporizador e o carvão OnComplete. Isso deve acontecer a cada 10 segundos, como você pode ver, porque o tempo alvo é exatamente 10. Vamos reduzir isso a algo como quatro, que isso aconteça um pouco mais cedo. E então, a cada quatro anos, a cada quatro segundos, teremos essa mensagem de saída. Então vamos ver se isso realmente funciona. Claro, certificando-se de que estamos na palestra 38 eventos. Agora nada acontece. No entanto, depois de quatro segundos terem passado, devemos vê-los ir e depois de mais quatro segundos devemos ver outra mensagem. Como você pode ver, Vamos recolher isso para que possamos ver cada mensagem método. E como você pode ver a cada quatro segundos, agora vamos receber esta mensagem que está sendo emitida. Agora, por que isso é uma coisa tão boa? Por que não chamamos o método da mensagem de teste aqui? Bem, podemos ver que este método de mensagem de teste de bagunça é realmente privado. E talvez o que queremos é que realmente queremos que isso aconteça em momentos muito específicos e não queremos fazer com que cada coisa, cada parte do nosso programa saiba sobre todas as outras partes. Então, por exemplo, talvez tenhamos um sistema HP para um inimigo ou nós mesmos. E então temos uma interface dentro do nosso jogo que mostra quanto HP, seja o inimigo ou nós mesmos como digamos o jogador, então o que poderíamos fazer, a interface do usuário poderia saber, ok, esta é a saúde do jogador e eles poderiam Verifique cada quadro de atualização, certo? Então, cada quadro, ok. Que tal você, que jogador tem quanto? Constantemente atualizado, mas não precisamos atualizá-lo constantemente. Na verdade, só precisamos atualizá-lo quando a HP muda. E então podemos fazer esses eventos. Então um delegado tipo de mudança na HP. E então temos um evento que basicamente chama o método UI e diz oito, o Reino Unido, a mudança HP. Então esta é a idéia de se inscrever para esses eventos. Podemos separar nosso código muito bem. E também não há nenhuma desvantagem real de ter esses eventos. Então você pode basicamente fazer como 100 ou 200 eventos, um incêndio. E se seus assinantes grande. E se você não fizer isso, você realmente não perde nada porque neste caso, neste caso chamamos isso, isso não perderia, certo? Então isso é basicamente eventos agora em geral, isso também é apenas uma visão muito curta e olhar para eles. Quando, uma vez que começamos realmente a usar a programação de um jogo real, vamos jogar ou uma unidade de jogo heap. Então vamos usar isso de novo. E acredito que nesse exemplo real vai ficar muito mais claro. Agora mesmo. Só queria mostrar que existe algo chamado eventos e delegados. E mais uma vez, dominá-los é realmente difícil. E sim, é apenas algo que é muito bom ter visto alguns. E vamos investigar isso mais tarde, de novo. Só queria mostrar isso rapidamente para você e como isso pode ser realmente útil. Vamos ver em uma futura palestra. Mas, no entanto, se você tiver alguma dúvida, não hesite e sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 42. (C#) Arquivo I/O: Muito bem, bem-vindos de volta ao “C Sharp “introdução aqui para o curso da unidade. E nesta palestra vamos dar uma olhada na entrada e saída de arquivos. Então eu preparei um arquivo de texto muito legal, como você pode ver claramente aqui em nossa pasta de recursos de ativos. E vamos abrir e ver como fica. É um texto super legal. Isso não é ótimo? E agora vamos aprender como podemos ler isso. E então também vamos aprender a escrever um novo arquivo. Vamos entrar no nosso script de arquivo. E eu já preparei basicamente o caminho de leitura e o caminho de escrita que você estará em ativos, recursos. E então o arquivo de texto legal é o que vamos ler. E então vamos escrever para um texto super legal que fizemos com código. E como eu disse aqui, t dot TXT, é apenas um arquivo de texto normal. Então, o que precisamos para, para nós basicamente entrada e saída de coisas? Bem, para escrever algo em um arquivo. Em primeiro lugar, é um processo muito lento. Agora, devagar em termos de comparação de duas coisas que podemos fazer em código. Ainda é incrivelmente rápido, mas geralmente escrever algo em um arquivo é um processo lento. Eu só queria mencionar isso. E vamos precisar usar o namespace system.console aqui. E então vamos ver, então primeiro de tudo, vamos verificar se o arquivo existe ou não. Então o ponto de arquivo existe. E então dentro dele vamos colocar o caminho vermelho primeiro porque vamos olhar se o caminho ler um caminho tem ou não um arquivo que existe lá. Porque se não funcionar, bem, não podemos abrir isto. E agora o que vamos usar é que vamos usar um leitor de fluxo. Então o stream reader SR arquivo ponto texto aberto, e então nós vamos dar-lhe o caminho. Agora a grande coisa sobre o leitor de fluxo é que este é um i descartável, eu acredito que é o termo correto para ele. E espero que você faça lá é que podemos usar a palavra-chave usando. Agora, você nunca viu isso antes. Nós podemos realmente pegar a palavra-chave usando e nós podemos pegar tudo isso, colocá-lo dentro daqui. E então uma vez que terminamos com ele, ele vai fechar o leitor de fluxo para nós porque provavelmente precisamos fechar o arquivo novamente. E isso é basicamente tudo tratado pela palavra-chave usando. E dentro daqui, vamos ter um “S “legal. Poderíamos chamar isso de hábito, um nome um pouco melhor. Acho que AS será suficiente por enquanto. E eu vou ter um loop while dentro daqui, que nós vamos dizer, bem, S é igual a SR ponto readline. Então esta é, a linha vermelha é simplesmente uma string e vamos definir S para essa string. E desde que não seja nulo. Então, enquanto isso não é nulo, vamos apenas saída basicamente S. Então vamos ler cada uma dessas linhas que estão aqui. Agora, só há uma linha aqui. Vamos produzi-lo. E uma vez que terminamos, terminamos de usar isso. O leitor de fluxo basicamente será descartado. E todos estão felizes novamente. Isso é tudo o que precisamos para basicamente ler um arquivo. Vamos ver se isso funciona. Certificando-se de que estamos no arquivo IO. Não vamos nos preocupar com esse aviso. Isso é simplesmente porque temos a variável caminho certo declarado, mas não usado. E vamos ver, em supercool, textos vão exatamente o que temos escrito no arquivo realmente obtém saída. Então isso é muito legal. E agora vamos ver o que podemos fazer para escrever algo. Então, se quisermos escrever algo, vamos usar o escritor do stream. Então, vamos mais uma vez dizer usando e então transmitir escritor. Isso vai ser então SW é igual ao texto de ponto de arquivo, neste caso no caminho certo. E então vamos ter basicamente o que chamamos é o SW. Então, o escritor de fluxo certo, ponto-ponto escrever linha. E então podemos dizer, por exemplo, olá, e então vamos copiar isso algumas vezes. Esta é outra linha. Muito legal. Como isso funciona. Então vamos tentar isso e ver se isso funciona. Então agora não temos um novo arquivo dentro de nossa pasta de recursos. E assim que começarmos isto, o que pudermos ver, vamos acabar com isto. E nós realmente, eu acredito, temos que recarregar isso porque não está certo, nós temos que atualizar. Então, Controle R. E então como você pode ver como eles são. E como podem ver, textos super legais que fizemos com código estão aqui. E então Olá, este é um alinhamento. Muito legal como isso funciona. Tudo o que colocamos aqui, exatamente como fizemos. E agora vamos resumir essa mudança algumas dessas linhas. Vamos, por exemplo, dizer, Claro, Como você faria, Por que não? Esta é mais uma linha e, em seguida, muito legal como isso funciona. E então vamos mudar isso para talvez um desses e ver o que acontece se rodarmos isso de novo. Então vamos colocar isso aqui. E mais uma vez, nós executamos isso sem erros, isso é meio legal. Vamos abrir esse arquivo de novo. E como você pode ver, eles gostam que o programa apenas mudou o que foi escrito aqui novamente, então ele vai substituir o que nós já temos. Então a ONU, o arquivo de texto no caminho certo, neste caso, será simplesmente substituído com o novo material. Sim, isso é o básico realmente fora de entrada e saída de arquivos. Há também coisas mais avançadas. E durante a parte de programação de unidade deste curso, vamos olhar especialmente como ler e escrever coisas com arquivos JSON porque eles são formatados de tal forma que podemos usá-los com bastante facilidade. Mas, no geral, esta foi apenas uma breve e rápida visão geral, mais uma vez, da entrada e saída do arquivo. Como sempre, espero que você tenha achado útil se houver alguma dúvida, como sempre sinta-se livre para perguntar agora certifique-se de responder. E sim. 43. (C#) Convenções C#: Muito bem, bem-vindos de volta à introdução do C-sharp aqui para o curso da unidade. Nesta palestra, vamos dar uma olhada nessas convenções de C-Sharp. Então esta é potencialmente a última das palestras aqui. E nós vamos dar uma olhada rapidamente em algumas convenções que você deve seguir, se possível. Então vamos abrir o roteiro de convenções e ver o que podemos ver. Então eu preparei algumas coisas aqui e vou explicar de cima para baixo algumas dessas convenções e por que elas podem ser úteis e por que você provavelmente deve segui-las. Todas as coisas consideradas e também comprou algumas dessas coisas são. Primeiras coisas, nomes de primeira classe, certo? Então essas seriam, por exemplo, convenções e o que vimos abstrato animal ou animal ou pessoa, deveria ser o caso Pascal. O que é o caso Pascal? Caso Pascal significa simplesmente que a forma como escrevemos certas palavras, neste caso, como você pode ver, animal abstrato. Embora tudo isto seja uma palavra, o abstrato é uma palavra e animal é uma palavra. E ambos estão em maiúsculas. Então é isso que Pascal casos. Nós capitalizamos o primeiro, o primeiro personagem. E então toda vez que chegamos a uma nova palavra, nós também capitalizamos essa palavra. Isso é muito importante. Esse é o caso Pascal. Quando olhamos para variáveis locais, nomes de campo, e também parâmetros, esses devem ser CamelCase. Camelcase significa simplesmente que o primeiro caractere é minúsculo. E então cada palavra que vier depois será maiúscula. Quando olhamos para constantes, não vimos a palavra-chave const realmente. A idéia aqui é simplesmente que esta é uma variável que não pode ser alterada. Então, não vai ser tão complicado. A idéia é que eles também devem estar no caso Pascal e não em gorros gritando. Isso é algo que eu pessoalmente faço às vezes. Eu acho que esta é uma daquelas coisas, como todas aquelas convenções que não são realmente regras, são apenas diretrizes que podem ajudar. E este é provavelmente um pessoalmente que eu faria. Então eu pessoalmente provavelmente ignoro isso a maior parte do tempo simplesmente porque às vezes eu sinto que é mais fácil de ver, ok, isso é uma constante. Mesmo que você possa ver isso pelo símbolo que ele tem aqui. No entanto, eu costumo fazer tudo em gorros gritando, mas ainda é uma convenção que alguém poderia querer seguir. Então sempre usamos nomes significativos para variáveis. Já mencionei isso ao longo de algumas vezes. Mas é muito bom ter um nome próprio para variáveis. Usamos isso a maior parte do tempo. Eu acho que uma ou duas vezes eu não fiz isso, mas geralmente você deve evitar as letras únicas. Então, por exemplo, o inteiro t e vamos ver, ok, bem, o que isso significa? Bem, é muito mais fácil de ler se eu estiver no temporizador e no tempo integral ou concluído. E também, não tenha medo de nomes realmente longos para variáveis. Se é um nome expressivo e é um nome significativo, então você realmente não deve ter medo disso. Porque quanto melhor você pode explicar algo, mais fácil é entender. É por isso que devemos sempre usar nomes significativos para variáveis. Eu pessoalmente também às vezes entendo isso errado, mas quando você pensa sobre isso, quando você, quando você está programando rapidamente, você apenas chamaria isso de S ou apenas chamaria isso em AI. Mas o que é IA? Qual é o seu propósito? E isso também pode levar você a pensar sobre o seu código um pouco melhor e pensar como, bem, na verdade eu realmente não preciso deste inteiro, esta variável aqui. Então, sim, não use abreviaturas em seus nomes de variáveis. Então coisas como ID e XML e algo assim. Tudo bem, mas não colocar em pessoa e, em seguida, fazer PRS n para isso. Isso só vai levar à confusão. E eu tenho que ser honesto. Aqueles dois, aqueles dois personagens que você salva lá, não vai cometer nenhum erro. Há uma coisa que nós realmente não usamos sublinhados em C-Sharp. Isso é só a convenção. Especialmente em, bem, na verdade em qualquer coisa, exceto nos campos privados. E nós vimos isso na palestra de propriedades C Sharp onde eu fiz um, eu acredito que era um booleano ou algum tipo de variável que era particular. E comecei com isso com um sublinhado. Isso é bom. Os nomes de uma classe devem ser sempre substantivos. Então animal, pessoa, esses são substantivos, certo? E eles também devem ser singulares se eu não estou enganado. Então isso também é algo que não deve ser animais ou pessoas porque é sempre uma classe. É um substantivo singular que descreve uma classe. Então vamos ouvir as interfaces prefixo com a letra I. Então o I flable. Essa foi uma interface que fizemos onde poderíamos chamar o método fly. E é dito que devemos começar com a letra maiúscula I. Agora algumas pessoas realmente não gostam disso porque eles são como, eu sei se isso é ou não, isso é uma interface. Pessoalmente, penso que esta é uma boa convenção. No entanto, há algumas pessoas que têm opiniões muito, muito fortes sobre ou não precisamos disso, o que quer que seja, sigam ou não sigam, não importa, apenas permaneçam consistentes. É uma das coisas mais importantes. Se você alterar suas convenções no meio do seu projeto, então você precisará voltar e reescrever o resto do código para que ele siga suas convenções. Como se você tiver algumas convenções e ficar com elas, mas não enlouquecer. E também essa outra coisa. É muitas vezes que terminamos nas interfaces com Able. Então é meio que, você sabe, eu voo, eu falo bolha. Porque isso também significa, ok, o que eles são capazes de fazer? Então isso também é algo para levar com você. Então devemos sempre ter nomes singulares para enums. Então dificuldade de jogo, por exemplo, não dificuldades de jogo. E nunca devemos usar o nome dentro, como enum dentro do nome. Então não devemos ter dificuldade no jogo. Enumeração ou cor enumeração, sempre apenas a coisa singular que é um enumeração nunca usando. Agora, de onde é que eu tenho isto? Eu tenho isso de um repositório do GitHub de convenções de nomenclatura. Isto está, naturalmente, ligado, bem como um recurso. Só posso aconselhá-lo a dar uma olhada nisso também porque há mais algumas coisas. Então eu coloquei aqui. Eu tenho esses foram apenas os mais importantes que eu já vi. E eu posso realmente aconselhá-lo a dar uma olhada no link. Eles são. Porque essas são algumas boas convenções de nomenclatura que você deve seguir. Pelo menos a maioria deles para tornar o seu código o mais padronizado e fácil de ler possível. Mas no geral, foi isso com a introdução acentuada C aqui para o curso. E sim, foi isso. Espero que tenha sido útil para vocês e agora está fora para basicamente aprender a Unidade corretamente. Então você pode, é claro, em primeiro lugar, parabenizar-se por conseguir isso e entrar aqui porque foi uma introdução bastante completa. E havia algumas coisas que você provavelmente precisa aprender dependendo do seu nível anterior de conhecimento. Mas sim, está feito e espero que tenha achado útil. E no final aqui, como sempre, se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 44. (Noções de (Unity Layout e editor explicados: Muito bem, bem-vindos à introdução básica da unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada basicamente no layout da unidade, o específico como editar coisas e bem, apenas alguns corações e algumas partes das janelas basicamente, apenas rapidamente explicar como uma pequena visão geral dada para que você sabe o que tudo isso significa e que você pode encontrar o seu caminho basicamente dentro da UI do Unity aqui que você vê, há um monte de partes móveis, um monte de botões que você pode clicar e não apenas eles. Só uma pequena introdução para isso. Então vamos começar basicamente no canto superior esquerdo. Isto aqui é basicamente a janela da cena. E é uma das coisas mais importantes em Unity porque isso é basicamente o que dá a você a sua visão sobre o seu mundo de jogo, certo? Então, atualmente, isso é basicamente colocado no modo 2D. Você pode ver quando alternado na cena como exibição 2D, quando ele é desligado da cena como na visualização 3D. Ideia aqui ser que, claro, este é um curso 2D. Então vamos fazer tudo em 2D. Podemos olhar para a terceira dimensão clicando neste botão. E então, como você pode ver, temos basicamente uma visão 3D. Mas como não queremos isso, vamos ficar com 2D e depois descobrir como podemos nos mover para dentro daqui. Então, se pressionarmos o botão direito do mouse para baixo, vemos uma pequena mão aparecer e então podemos mover o, basicamente o mundo do jogo. A vista muda e podemos nos mover, certo? Então isso é muito útil. Podemos ampliar e reduzir com eles com o botão do meio do mouse, é claro, também podemos nos mover se segurarmos o botão do meio do mouse para baixo. E então também podemos basicamente nos mover. Se mantivermos pressionado o botão esquerdo do mouse, podemos selecionar coisas. Atualmente em nossa cena. Podemos ver o que temos aqui, aqui na Hierarquia. Vamos ver isso um pouco mais tarde também. Mas agora só temos a câmera principal aqui. E podemos, por exemplo, selecionar isso. E então, como você pode ver, em primeiro lugar, a câmera principal aparece aqui em baixo. Então isto é o que veríamos dentro do jogo. E então, no lado direito aqui, um monte de coisas aparecem, que nós também vamos olhar para dentro de pouco tempo. Então, o que mais é, portanto, a visão da cena? Embora haja um monte de botões aqui, basicamente você pode ativar e desativar o áudio. Você pode usar iluminação de cena. Há coisas para caixas de céu. Você pode ver quantos objetos existem e também alternar na grade. Então, por exemplo, agora não temos uma grade, e então temos uma grade. Então a grade pode ser muito útil. E também às vezes pode ser que os aparelhos estão desligados. Então os aparelhos, ou basicamente, se eu clicar neste pequeno botão aqui, você pode ver que existem certos ícones que você verá que simplesmente ajudaram a encontrar certas coisas dentro da visão da cena. Por exemplo, a câmera, certo? Não importa se eu diminuir um pouco, então as câmeras ainda estão lá. E se eu ampliar muito do que as câmeras ainda maiores, mas isso mostra que está bem, há a câmera principal ou há uma câmera e se desligarmos isso, então não vemos nada e nem sabemos onde a câmera está nesse caso . Então os aparelhos são basicamente para nos ajudar a ver certas coisas que são ajudas visuais. Grande que você só pode ver dentro da visão da cena, certo? E há também uma espécie de caixa de ferramentas aqui. Raramente uso isto. E então você também pode alterar as configurações da câmera aqui. Então, estas são as configurações para a câmera de exibição de cena. Neste caso. Eu também diria que não costumo usar isso. Você também pode procurar algo aqui em cima. Mas há muitas barras de busca, na verdade, há uma aqui, há uma aqui. Então podemos procurar de muitas maneiras. Então esta é a janela da cena. Basicamente. Você também pode ter modos diferentes no canto superior esquerdo aqui. E esses basicamente não farão nada no momento se tivermos coisas aqui. Então isso também é mais sobre, eu diria, a perspectiva 3D. Tão sombreado simplesmente significa que se temos, se temos um cubo aqui, eu posso adicionar um bem rápido para que possamos ver isso como um exemplo. Agora temos um cubo preto aqui, como podem ver. E então, se eu fizer um wireframe, veja isso como um wireframe. E então um wireframe sombreado simplesmente significa que ambos vemos o wireframe sob o modo sombreado. Também temos coisas diferentes que podemos fazer caminhos de renderização. Podemos fazer com que o canal alfa sobreponha o mapa MIP. Então, essas são simplesmente como diferentes idéias de renderização, por assim dizer. Por exemplo, uso eu geralmente mantê-lo em sombreado. Esse é o que faz mais sentido. E em 2D, as diferenças não são realmente tão importantes de qualquer maneira. Então, no topo, também temos algumas ferramentas que podemos usar. Então eu disse clicar com o botão direito ou clique do meio do mouse, podemos mover. Nós também pode simplesmente selecionar esta ferramenta de mão e, em seguida, mover com o botão esquerdo do mouse como um clique. Isso também funciona. Temos a ferramenta Mover. A ferramenta de movimento basicamente é se eu tiver um determinado jogo objetos selecionados, por exemplo, a câmera, então essas setas aparecerão e com esses Eigen basicamente mover a câmera ao redor. E então, no lado direito, aqui você pode ver que a posição da câmera realmente muda. Como eu disse, neste caso, porque estamos em 2D, vamos ser apenas precisa da direção x nesta direção e na direção y e nesta direção. E sim, o, sim, isso é basicamente isso. Então temos a rotação. Então esta é a ferramenta de rotação. Podemos girar em torno deste ângulo, certo? Então podemos girar em torno do, este seria o eixo z, certo? Porque o eixo z é aquele que vai para o, para o próprio computador. E então nós também podemos basicamente inclinado nesta direção. Mas geralmente eixo z é a única rotação que precisamos em duas dimensões, três dimensões, nós, é claro, poderíamos girar em torno de cada eixo. Também temos a ferramenta de dimensionamento. Então isso não vai fazer nada para a câmera neste caso, porque a câmera, a escala da imagem da câmera é controlada de forma diferente da escala do próprio objeto. Então isso só se aplica a objetos diferentes, mas neste caso podemos escalar isso com essa ferramenta. E então esta é a minha ferramenta favorita, ferramenta direta. Porque quando temos, especialmente em duas dimensões, podemos basicamente ter a capacidade de dimensionar algo para cima ou para baixo com os lados. É muito semelhante a algo que você veria se você ativar o modo de transferência no Photoshop para qualquer um de vocês que, como quem entende o que é isso. Isso é alguma coisa, mas vamos ver isso mais tarde também. E mover, girar e dimensionar objetos. Então isso simplesmente coloca todos os três juntos em um. Pessoalmente, não prefiro esta vista. Algumas pessoas realmente gostam disso porque então eles podem fazer o que quiserem. Nós também temos a ferramenta editor. No entanto, não temos nenhuma ferramenta personalizada aqui. Então isso realmente não faz nada para nós. Eu pessoalmente manter a minha unidade quase exclusivamente em destruído na ferramenta rect e mover ao redor como eu disse, com o botão direito ou do meio do mouse, geralmente o botão direito do mouse e zoom in e out assim. Sim, essa é basicamente a essência disso. Você também pode ir para esses botões por uma pessoa Q, W, E, R, T, e então o z sido ah, isso é realmente o y sido. Sim, exatamente. Então q0, QWERTY basicamente são esses botões que também funciona, mas sim, também é suficiente se você simplesmente clicar neles. Então vamos mudar de abas aqui e olhar para a vista do jogo. Atualmente, como você pode ver, há basicamente nada aqui porque nós não temos nada dentro do jogo agora. Isto é simplesmente o que você veria quando você joga o jogo. E isso também é o que começa. Então, se apertarmos o botão Iniciar aqui, o botão Play, isso também é o que vemos, então ele muda automaticamente para a visualização do jogo uma vez que começamos o jogo. E a visão do jogo, como eu disse, é o que você definitivamente gostaria. Basicamente um-para-um exemplo do que você veria dentro do jogo uma vez que você iria iniciá-lo, há certas coisas que podemos fazer. Podemos basicamente ter exibições diferentes aqui. Agora. Agora só temos uma exibição. Podemos definir a resolução atualmente, como você pode ver. Dois, para k, nós também podemos apenas dizer, bem, na verdade, vamos colocá-lo em full HD. Isso vai ficar bem. Podemos escalá-lo. Então isso simplesmente amplia a imagem sem fazer qualquer fantasia como técnicas de Zoom ou alguém assim. É literalmente só ampliação. Se batermos maximizar no jogo, uma vez que jogamos, a janela fica maximizada aqui, isso pode ser muito útil se você quiser ver, você sabe, como quase todos os detalhes porque isso é quase tela cheia. E então há áudio mudo deve ser auto-explicativo. A Musa o áudio. Podemos olhar para as estatísticas que estão em execução e nós também podemos ligar os aparelhos aqui. E esses são basicamente os mesmos aparelhos que nós temos, a visão da cena. Mas esta é a vista do jogo. Na verdade, não há muito nisso. Sim, vamos continuar com a hierarquia hierárquica. Vamos também voltar para a vista da cena. A hierarquia basicamente são todas as coisas que estão na cena atual. Atualmente estamos na cena da amostra. Esta é uma cena que é criada quando começamos um novo projeto Unity. E como você pode ver, nós basicamente só temos a câmera principal aqui como um componente. Podemos adicionar novos componentes indo para este pequeno botão mais, por exemplo. Então, podemos ter coisas predefinidas que podemos criar ou podemos clicar com o botão direito do mouse em ano e também ter o mesmo. Coisas que talvez queiramos criar. Assim, por exemplo, podemos criar um objeto vazio. E este objeto vazio literalmente não tem, Ele só tem uma posição, rotação e escala. E não tem, digamos, marcação visual de qualquer tipo. Então nem sabemos onde é isso quando podemos adicionar isso. E então, por exemplo, mudar as coisas. Mas agora não vamos adicionar isso e vamos apenas mantê-lo assim. A propósito, nós, se a cena mudar, certo? Então, se mudarmos a cena, então se movermos isso, então você verá uma pequena história aqui e uma pequena loja no topo. E a loja pode, oh boy, você pode basicamente salvar as alterações simplesmente usando Control S ou indo para Arquivo e depois Salvar aqui. E, hum, eu provavelmente vou usar isso várias vezes ao longo. E assim como em quase qualquer outro programa, podemos desfazer ou refazer coisas com Control Z. Isso simplesmente desfaz as coisas e então Control Y basicamente muda de volta e reduzi-as. Então isso deve ser quase auto-explicativo, certo? Em seguida, a hierarquia, se selecionarmos algo aqui, ela também é selecionada na exibição de cena e também aparece algo no inspetor. O inspetor é uma das grandes coisas que vamos olhar, como mesmo com mais detalhes quando olhamos para roteiros, porque é aí que fica muito interessante. No entanto, o que deve ser dito sobre o inspetor é que basicamente, para cada um de nossos GameObjects que existe dentro de nossa cena, obtemos informações adicionais que também podemos manipular. Então, por exemplo, para a posição, eu basicamente posso mudar isso. E como você pode ver à esquerda, ele realmente muda na cena também. Então isso é muito importante e estes são uma espécie de, estes são agrupados em sua funcionalidade. Então, por exemplo, esta câmera obviamente tem uma espécie de componente de câmera associado a ela onde podemos mudar coisas diferentes que estão associadas com a câmera. E a transformação significa simplesmente que este é o posicionamento e a escala rotacional. Então este é o tipo de, digamos, a manifestação física deste objeto. E cada objeto sempre tem componentes de transformação. Então estes são os componentes individuais. Não vamos falar sobre Adicionar Componente agora. Isso é algo que vamos ver mais tarde. No entanto, podemos, é claro, adicionar componentes aos nossos objetos individuais. Vamos ver rapidamente o console também. Assim, o console tem duas partes principais. Aqui. Nós já vimos se você assistiu a introdução nítida C, então você terá visto isso várias vezes. Existem basicamente saídas. Se fizermos debug dot log ou debug, debug dot log aviso, em seguida, aqueles são exibidos aqui. Se os selecionarmos, podemos ver uma espécie de traço aqui em baixo. E isso também pode ser expandido ou movido para baixo. Temos alguns botões, isso limpa o console. Podemos colapsá-lo, podemos pausar em erros, e então também temos algumas coisas que podemos fazer. Como você pode ver, seleção de alvo. Eu realmente não uso isso. Isto é para, se nós realmente enlouquecer com a nossa depuração, realmente não é necessário. Nós também pode filtrar para em basicamente normal, apenas logs, avisos e erros. E isso é basicamente todo o console. Não é assim tão louco. E como com quase todas as outras coisas, vamos olhar para aqueles como ainda mais tarde na linha, a visão do projeto é basicamente as pastas e diretórios que temos para o nosso projeto. Atualmente, dentro de nossa pasta de ativos, temos uma pasta de cenas, e dentro dela temos a cena de exemplo. Esta é a cena que é criada no início do fim quando criamos um novo projeto aqui, esta é simplesmente a cena que é criada. E isso é tudo o que temos aqui. Indo para. futuro, criaremos mais algumas pastas. E eu também vou basicamente mostrar a vocês minha estrutura de pastas pessoais que eu uso. Isso é, naturalmente, algo que depende completamente de você. Você pode segui-lo ou não segui-lo. Isso é apenas uma sugestão. Mesmo com o layout básico do, de toda a tela aqui. Isso é algo que você pode querer seguir ou não. Vamos falar rapidamente também sobre os botões certos aqui, apenas para conclusão, isso é colaborar. Isso significa simplesmente que, se você quiser colaborar com várias pessoas com o Unity Colaborar, você pode fazê-lo com isso. Eu não me preocuparia com isso agora porque vamos fazer o básico primeiro. Vamos começar a rolar com o conceito de unidade e omega1 basicamente falar sobre colaboração. Os serviços gerenciados simplesmente significa que existem serviços. Então, se eu clicar sobre isso, a janela de serviço aparece e esses são serviços específicos que eu poderia basicamente habilitar aqui para este jogo em particular. Como a colaboração não necessária, eu posso basicamente fechar esta janela de serviços clicando do meio do mouse e, em seguida, ele desaparece. Eu também posso clicar com o botão direito do mouse e eu acredito que posso fechar guia também. A conta é simplesmente a conta em que estou conectado. Portanto, suas camadas de conta do Unity são as camadas que existem. Isso é algo sobre o qual vamos falar mais tarde também. E no layout simplesmente como o layout da minha Unidade. Então eu posso, por exemplo, mudá-lo. Eu poderia mudar isso uma crença que então é recarregado. Então eu não quero realmente fazer isso, mas eu tenho meu próprio layout KJ aqui. Como eu disse, eu tenho isso e acredito que também posso disponibilizá-lo. Então eu posso realmente salvar isso em um arquivo e eu vou ter o layout disponível. Já devias ter isto. Deveria ter sido transferível no início do curso. Então sim, sim, é basicamente isso. Quero dizer, as únicas outras coisas são o início, a parada, e o botão de passo. O botão de passo simplesmente coloca o que temos aqui. Então, se colocarmos isso e pararmos, por exemplo. Então este botão de pausa na verdade, e então nós podemos passo como quadro por quadro através de uma cena particular com este botão. Claro que, neste momento, não faz nada porque, bem, não há nada aqui. Então não há nada para ver são esses três botões. E então, se alguma dessas coisas em particular não estiver aqui, você sempre pode ir para Janela e olhar para todas essas janelas diferentes que estão lá. Então a cena, você sabe, o jogo, o inspetor que vimos, hierarquia, console de projeto, esses são basicamente os mais importantes que devem estar lá quase sempre. E então tudo o resto é algo que vamos olhar em alguns detalhes e alguns não detalhes. E então nós vamos olhar para como realmente bem. E algumas das outras coisas são muito mais avançadas que nós realmente não precisamos fazer, digamos jogos simples ou até mesmo um pouco mais complexos jogos. Mas sim, isso é basicamente tudo o que eu queria dizer para o layout da unidade, é um pouco mais abrangente. Mas, e é claro, há mais a aprender e as aplicações disso. Mas eu só queria, você estar pelo menos um pouco confortável dentro deste layout, então você sabe, ok, eu gosto vagamente saber onde ele está. Ok, a hierarquia me mostra todos os objetos na cena e, em seguida, o projeto tem basicamente a estrutura de pastas e assim por diante e assim por diante. Então, sim, isso é basicamente o layout da unidade. E o editor explicou, espero que você tenha achado isso útil como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 45. (Noções básicas de (Unity Estrutura de bolte: Muito bem, bem-vindos de volta à introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada na estrutura básica de pastas. Basicamente que eu uso pessoalmente. Acho que, não sei, evoluiu ao longo dos anos. Não é realmente tão complicado ou louco de explicar, e deve ser bastante simples também. Então, dentro de nossa visão de projeto aqui, nós temos a pasta de ativos. E esta pasta de ativos. Isso é basicamente onde teremos tudo o que o nosso jogo tem ou scripts. Teremos nossas cenas lá, teremos nossas fotos e imagens e sprites. Tudo isso vai para dentro desta pasta de ativos, a pasta Pacotes aqui. Podemos basicamente ignorar isso por agora. Nós não usaremos nenhum pacote para o futuro previsível. No entanto, a pasta de ativos, É aí que vamos criar nossas próprias pastas dentro dele. E vamos basicamente fazer a nossa estrutura de pastas aqui. E isso é simplesmente clicar com o botão direito do mouse na pasta Ativos, criar e depois Pasta. E a primeira pasta que vamos criar será chamada. Então, dentro deles, é claro, todos os roteiros irão no futuro. E então vamos criar uma pasta chamada sprites. Então, em vez de lá, todos os sprites irão. E, em seguida, duas outras fotos que são bastante importantes que também podemos criar já é a pasta Recursos. Agora é muito importante que isso seja realmente escrito corretamente porque essa é uma das outras pastas que é espécie de onde seremos capazes de entrada e saída de coisas, Digamos. Portanto, esta é uma pasta muito fácil de ser lida da unidade. Vamos manter isso assim por enquanto. Vamos ver isso mais tarde também. E então uma coisa que também vamos criar é a pasta Prefabs. Nós vamos falar sobre o que prefabs são também em uma futura palestra agora, nós estamos basicamente construindo uma espécie de fundação. E então nós vamos adicionar a esses seguidores individuais continuamente abaixo da linha. Especialmente é claro, a pasta de scripts vai ser aquela onde nós vamos basicamente criar um monte de scripts que são, você sabe, deca tem uma infinidade de funcionalidade e irá basicamente mostrar cada um dos indivíduos, funcionalidades individuais que vamos dar uma olhada nesta introdução básica da unidade. Então essas são basicamente todas as pastas que são interessantes. Uma coisa a mencionar para os scripts é que se eu tiver, por exemplo, namespaces diferentes, Eu já expliquei isso na parte C afiada para C afiada. Eu tenho diferentes namespaces e são basicamente espelhar os namespaces em uma espécie de pasta de scripts. E o que podemos fazer é basicamente, podemos entrar aqui e, em vez das configurações do projeto sob a duração do projeto da costa do mar, fazer um namespace raiz. Agora, dentro de nossa introdução básica de unidade, não vamos fazer isso, no entanto, quando criarmos nosso próprio jogo. Então, quando fizermos o primeiro jogo lá, definitivamente vamos fazer isso. Porque, em seguida, a pasta de scripts realmente irá espelhar isso. Neste caso, a pasta de scripts é um pouco melhor servida por ter o separado porque as palestras que virão são basicamente independentes umas das outras. Então você poderia, por exemplo, saltar de palestra para palestra 5 sem perder nada. Se palestra para é algo que você já viu ou sabe sobre. Sim, então essa é a estrutura básica do projeto, nada muito extravagante ou muito louco sobre isso. Há um par de mais, bem basicamente pastas que podem se juntar mais tarde abaixo da linha. Provavelmente quando olhamos para conceitos mais intermediários e avançados, então mais pastas se juntarão. No entanto, essas são basicamente as fotos que precisamos para a introdução básica e para o primeiro jogo que vamos criar. Então, sim, nada muito excitante. Mas agora finalmente, podemos basicamente começar, e na próxima palestra vamos finalmente começar a ler um roteiro e realmente ver um pouco o que pode, que a unidade pode basicamente oferecer. Então, mais uma vez, espero que você tenha achado útil se houver alguma dúvida, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 46. (Basics da Unity: Muito bem, bem-vindos de volta à introdução da unidade básica aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada em onde tanto o inspetor quanto os roteiros em geral. Então vamos dar uma olhada se você é um roteiro e como isso se manifesta. E então nós também vamos ver como isso parece dentro do Inspetor. Para isso, vamos criar nosso primeiro roteiro aqui. E estamos mais uma vez com o botão direito do mouse na pasta de scripts, criar e, em seguida, script C-sharp. Podemos então renomear isso. Vamos dar um nome a esta saúde. Então este é o, nós vamos basicamente fazer uma aula de saúde neste caso. E também vamos criar uma nova cena para isso. Então eu basicamente quero que cada uma das diferentes palestras tenha uma cena associada a ela. Então vamos fazer com que o botão direito do mouse em cenas criem novamente, e depois aqui para cena. E isso vai ser basicamente três. Então L3, isso seria roteiros. Você pode, claro, dar o nome que quiser. Você não tem que seguir os roteiros mesmo como as cenas individuais como essa. Você pode fazer o que quiser. Eu só acho que este é o mais arrumado. E isso também se traduzirá para o conteúdo baixado do aplicativo. Então você pode, naturalmente, também baixar toda a introdução da unidade básica como um pacote, importá-lo, e então você terá quase a mesma estrutura que isso. Então a primeira coisa que vamos fazer é criar um novo objeto vazio aqui. Então crie um clique com o botão direito dentro da Hierarquia. Criar Vazio. Este é agora um objeto de jogo vazio. Vamos chamar isso de saúde. Só por causa da discussão. Eu, pessoalmente, faço uma outra coisa. Eu sempre posiciono meus GameObjects vazios na posição 0, 0, 0. há, literalmente, nenhuma razão para fazer isso. Eu só odeio ver como esses números realmente tortos nesta posição. É por isso que eu faço isso. E você não tem que fazer isso, mas eu faço. Então, sim. E agora que isso é criado e posição, podemos basicamente pegar o script pressionado com o botão esquerdo do mouse e, em seguida, arrastá-lo até aqui. E como você pode ver, eu posso realmente obter um indicador aqui. E se eu soltar, e podemos ver script de saúde agora é basicamente um componente deste GameObject. E a melhor coisa é que depois de salvarmos aqui, a grande coisa é que podemos basicamente agora manipular este script. E isto agora vai correr para dentro do nosso portal. Então, podemos clicar duas vezes aqui ou clicar duas vezes aqui. Vamos clicar aqui. E então, para mim, um estúdio visual será aberto. Ele será aberto em uma tela diferente e diferente. Então, eu só vou passar por cima, eles vão. E este é um novo script basicamente formado. E é assim que parece. Obtemos um método de início e obtemos um métodos de atualização. Então essas são duas das coisas que são pré-geradas. E também podemos ver que esse script de saúde, isso ajuda a classe de saúde. Herda do comportamento mono. O comportamento mono, como você pode ver, é a classe base da qual todos os scripts do Unity derivam. Então, se você quiser um script de teste de unidade onde o método de início funciona e o método de atualização funciona, então isso precisa basicamente herdar do comportamento moral. E o que também é importante se eu olhar rapidamente para este comportamento mono também, a coisa que você precisa basicamente colocar um script em um GameObject aqui. Então, caso contrário, isto não vai funcionar. Então, se eu tiver um script onde eu não tenho esse comportamento mono, a herança, eu não posso realmente me apegar a nada. Então o que vamos fazer é criar alguns novos, basicamente campos e variáveis aqui. Então não dentro do nosso método, mas acima dele. Então, basicamente, como parte desta classe, vamos clicar em Criar uma Saúde Pública. E nós vamos defini-lo igual a um 100 e, em seguida, uma maneira int pública igual a um 100. Então isso é algo que uma classe de saúde pode gerenciar com uma saúde, uma variável de saúde e uma variável de maneira. E nós também vamos fazer um inteiro variável privada poderia experimentar. E isso também vai ser um 100 só por causa do argumento agora. Agora vamos manter isto como está e olhar de volta para a Unidade. Então vamos ter algumas recargas aqui. Agora. Nós vamos. Este é um aviso que não nos diz respeito agora. Simplesmente diz: “Ei, criamos como um campo, uma variável que nunca usamos. Então isso é como algo que é inútil basicamente, porque nós não o usamos. Eu diria realmente que este é um aviso que quase sempre pode ser ignorado, especialmente no início. Estamos apenas fazendo estamos tentando algumas coisas e sim, então na maioria das vezes, isso pode ser ignorado se você está realmente trabalhando em um projeto e você começa isso como com quase tudo que você cria, então isso simplesmente significa um, talvez existam algumas coisas que alguns campos ou algumas variáveis que poderiam ser excluídas. Mas neste caso agora, não nos diz respeito a quem podemos realmente limpar o console. Se olharmos agora para o nosso objeto de jogo de saúde aqui e um meio script, você pode ver algo apareceu, uma variável de saúde aqui e um homem de variável aqui. Portanto, há dois campos que apareceram com seus valores básicos que colocamos aqui. E quero dizer, isso é muito legal, certo? Então isso é realmente algo que acabou de acontecer sem que façamos nada. Mas se estou declarando e inicializando essas variáveis, isso é muito legal. Mas se vemos que a variável espúria não está realmente lá. E a razão para isso é porque nós tornamos isso privado. Então, os modificadores de acesso neste caso realmente importam para nossa visibilidade dentro do Inspetor. Mas para isso, podemos fazer o seguinte. Podemos colocar os colchetes basicamente aqui e digitar campo serializado dentro deste irá basicamente serializar este campo. Agora nós também não vai obter basicamente a era ou o aviso, Hey, isso não é usado porque agora ele é usado e é usado pelo inspetor. E como você pode ver, agora a experiência, não se preocupe com isso. Agora a variável de experiência aqui também aparece. Então esta é uma maneira em que podemos tornar as variáveis privadas visíveis especificamente para o Inspetor. Sim, e isso é o básico aqui. Também podemos, se começarmos agora, nada acontecerá porque não temos nada excitante aqui. Mas o que podemos fazer é, por exemplo, podemos fazer saúde menos igual a 20, por exemplo. E então apenas por uma questão de argumento, se eu puder descobrir como digitar 0 no método de atualização. Poderíamos colocar em experiência mais igual a um, por exemplo, apenas para que tenhamos algo para mostrar. E vamos apenas, vamos apenas olhar para isto. E então podemos realmente ver essa mudança aqui. E vamos começar. E como você pode ver, agora a experiência, como você pode ver, está indo muito, muito rápido porque atualmente são FBS, isso é tipo mil ou em algum lugar em torno disso? Paramos rapidamente ou pausamos o jogo. Então o que podemos fazer é realmente ir quadro por quadro. E então, como você pode ver, isso realmente só é aumentado em um cada quadro, como é suposto. E ele reinicia uma vez que paramos o jogo. Como isso basicamente não é persistente, os dados aqui revertem para o que temos, configurá-lo dentro do nosso script basicamente. Então sim, essa é uma visão geral básica do roteiro e do inspetor. Temos na introdução acentuada C visto que o método de partida basicamente algo que apenas acontece no início, que é exatamente verdade. Assim que começarmos a cena, tudo dentro daqui é executado. E, em seguida, depois que isso é feito, o método de atualização é chamado cada quadro. Então isso é dependente do quadro. E então vamos adicionar algo aqui. Nós vamos no futuro também ver maneiras diferentes onde podemos fazer as coisas dependentes do tempo. Então podemos basicamente dizer, “Ei, vamos esperar um minuto por isso ou, ou um segundo ou alguém assim. E sim, essa é a visão geral básica disso. Espero que você tenha achado útil como sempre, se houver alguma dúvida, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 47. (Noções de Unity: Muito bem, bem-vindos de volta à introdução básica da Unidade para o curso UD. E esta palestra, nos encontramos fora da unidade. Eu conheço a loucura. E isso é basicamente algo que eu queria mostrar para os ativos que você poderia querer usar. E para um exemplo de ativos que vamos usar. Então os bens do Kenny são basicamente um monte de ativos e eles são todos livres para usar, certo? Então há mais de nove lados, como você pode ver com um monte de coisas. Como você pode ver, existem diferentes ativos 2D e também 3D aqui também alguns ativos de áudio. E se nós, por exemplo, apenas ir para a próxima página, como você pode ver, há uma variedade de coisas e todas elas são muito legais. Eles parecem muito bonitos. E como eu disse, eles podem ser usados. Eles estão sob uma licença universal, então eles são você pode usá-los para fins comerciais ou qualquer finalidade que você gostaria. E para nossa introdução básica aqui, então, para o básico da unidade, vamos usar as cartas de jogo aqui. Eles são, na verdade, eles nos oferecem tudo o que precisamos realmente. E eu basicamente só quero uma imagem em particular que possamos usar para fazer coisas com que pareça um pouco mais agradável do que apenas, eu não sei, como uma tela preta ou branca. E como você pode ver aqui, este é um cc, seu inverso, bem, você está livre para usar isso em jogo em qualquer projeto, pessoal ou comercial. Não há necessidade de pedir permissão. Dar atribuição não é exigido por muito apreciado. Claro, é por isso que eu mostro este número 1 porque é um ótimo recurso. E também porque isso é, quero dizer, é incrível, certo? Nunca foi tão fácil. E há alguns ativos realmente bons aqui que você pode fazer coisas incríveis com. E também, Eu vou, é claro, as cartas de jogo, Eu vou ter aqueles incluídos como um download e também o link para os ativos aqui é também como um recurso disponível. E há mais uma coisa, que é a Unity Asset Store. Você já deve ter visto isso antes. Mas este é basicamente um poço onde os ativos são vendidos ou também podem ser baixados gratuitamente. Portanto, há alguns ativos que são vendidos, e há também alguns ativos que são gratuitos. Então, se filtrarmos por três primeiros, como você pode ver lá, há um monte de coisas aqui que são livres para usar e que você também pode usar em seu jogo. Estamos, vamos nos concentrar nos ácidos Kenny, então vamos usar os ativos Kenny daqui para frente. No entanto, como eu disse, a Unity Asset Store também pode ser um ótimo momento onde você pode basicamente obter novos ativos também. E sim, basicamente seria isso. Eu só queria dizer a você que vamos usar os ácidos Kenny e que há, há ainda mais lugares onde você pode ir online. Eu acho que ir para artistas de jogo aberto, outro lugar. Então, há muitos lugares. Rubber, vamos mantê-lo no Kenny Assets. E isso era apenas algo que eu queria mencionar. Como eu disse, tudo como um recurso disponível. E sim, já era isso para esta palestra. Eu só queria mostrar isso para você rapidamente. Espero que você achou útil se houver alguma pergunta como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 48. (Noções de Unity: Muito bem, bem-vindos de volta à introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida nas configurações de compilação e fazer uma compilação. Então, o que é uma construção e o que isso significa fazer? Para olhar para as configurações de compilação? Bem, a idéia é que um projeto de lei é basicamente um executável que você pode, do seu jogo, que você pode executar. E tem tudo nele. É basicamente o lançamento do seu jogo, quase como você gostaria que ele fosse lançado. E há algumas configurações que precisamos fazer para que isso realmente funcione. Então, há um monte de configurações na verdade, e nós vamos dar uma olhada mais tarde na linha também. Mas uma das coisas que é muito importante são as configurações de compilação. Então, indo para o arquivo e, em seguida, construir configurações. E se eu mover isso rapidamente para cá, como você pode ver, estas são as configurações de construção. Há algumas coisas que você verá imediatamente. Então, podemos basicamente olhar para qual plataforma queremos publicar este aplicativo. Normalmente PC, Mac e autônomo é uma espécie de, eu diria, o padrão. E então você pode, se você tiver, você pode escolher diferentes plataformas de destino e também alterar a arquitetura aqui. Normalmente, no início, você quer colocar isso como um desenvolvimento construído porque este é um desenvolvimento construído. E então também muito importante é, como você pode ver, há cenas que você realmente quer construir. Então, quando você cria novas cenas, então você realmente quer ter em mente que você terá que adicionar essas aqui quando você construir. Então, como você pode ver agora, eu vi cena de amostra de barra que, que um está lá, mas o L3 que não está lá dentro. Então eu posso simplesmente arrastá-lo e tê-lo aqui. E estes 01 é basicamente o índice. Portanto, há realmente uma onda na qual podemos acessar isso. Então, se olharmos para algo assim, então há realmente uma maneira que podemos acessar isso por script basicamente. E sim, então vamos rapidamente dar uma olhada nisso para que possamos construí-lo. Eu não vou, porque agora há realmente, na verdade, quer saber? Vamos fazer isso. Basicamente, pronto, ok, onde queremos construir isso? Normalmente eu diria que dentro de sua pasta Unity, você cria uma pasta chamada builds. E então você, você escolhe essa. E a construção vai demorar um pouco, dependendo de quanto está lá. Agora, é claro, eu basicamente não tenho nada aqui. Não há, não há sprites de verdade. Não há bens reais. Não há quase nada aqui. E só um segundo, vou mostrar onde isso apareceu. Então o basicamente aqui, lá vai você. Então temos um ano EXE que poderíamos iniciar um executável. Agora ele vai começar na tela errada, então eu não vou fazer isso agora. Mas no geral, como você pode ver, há tudo aqui. Nível 01 são basicamente os dados para cada uma dessas cenas lá. E então também temos uma pasta de recursos. Este é o que eu mencionei que tinha que ser o nome certo. E há também uma pasta gerenciada com um monte de basicamente DLLs. No geral. Isso é também o que você basicamente levaria. Então o EXE e a pasta de dados, e esses dois seriam aqueles que você teria enviar basicamente para as pessoas para que eles joguem seu jogo. Elas também são Configurações do Jogador. Vou clicar rapidamente nisto e mostrar-vos, vamos passar por isso mais tarde também. Essas são simplesmente coisas como o nome do produto, qual empresa você tem, qual versão, alguns ícones e assim por diante e assim por diante. Há muita coisa aqui e vamos cobrir algumas das configurações do projeto mais tarde. Como eu disse, neste momento, não vamos realmente olhar para isso porque eles não são tão importantes quanto poderia ser, certo? Então este foi o criado, o Build, criou uma compilação. E vamos apenas, por uma questão de argumento, criar uma nova cena aqui. Isso seria cenas L5, certo? Porque estamos falando de cenas. Vamos abrir isso e, em seguida, vamos também criar um novo script. Então este é apenas o teste. Vamos chamar isso de roteiros de cenas tão importantes que são cenas e não vistas. Porque eu acredito que se nós fôssemos nomear isso, apenas vê-los, nós poderíamos entrar em conflito com alguma coisa. E dentro daqui podemos usar alguma coisa. Então temos que usar um novo namespace. Aqui é Unity Engine. Não, isso não está certo. Você conhece o motor que a gerência sênior. E com isso, podemos realmente fazer todo tipo de coisas divertidas. Então, por exemplo, temos o gerente de cena. E o gerente de cena pode basicamente fazer tudo o que queríamos fazer. Podemos até criar novas cenas. Podemos conseguir todas as cenas. Podemos ser vistos em um determinado índice, que é exatamente o índice em vez das configurações de compilação. Nós também podemos obtê-lo, obter as cenas pelo nome. Podemos carregar uma nova cena. Então é aqui que podemos basicamente mudar de uma cena para a outra. Há também dois eventos que você é mesmo que nós poderíamos assinar. E sim, esses são alguns dos outros. Vamos fazer o seguinte. Vamos apenas fazê-lo para que imediatamente após o início, ele carregue uma cena diferente. Então ele vai carregar visto com o índice um. Isso está correto? Vamos verificar rapidamente novamente. Então essa é uma das coisas em que é um pouco sim, L3. Isso é exatamente certo. Então está tudo bem. Sim. Então a idéia aqui é que nós, naturalmente, temos que anexar isso a um objeto. Então isso vai ser objetos de uma cena, 000 000. Isto é apenas mais uma vez para mim, porque eu realmente quero que isso esteja na posição 0 000 cenas. Portanto, o script agora está anexado a este objeto. Se eu salvar e começar agora, esta cena mudará para L3 visto. Como você pode ver agora estamos em L3. Talvez tenhamos que expandir isso para ver. E depois temos o nosso guião de saúde de volta. E isso está funcionando porque basicamente começamos este C agora. E se fecharmos fora disso, estamos de volta ao nosso L5 SI original. Então isso é uma pequena coisa sobre cenas e as configurações basicamente construir e como construir o seu jogo. Vamos ver isso mais tarde na linha em um pouco mais de detalhes e um pouco mais do que vai para ele. Mas, no geral, as cenas em si são bastante importantes. E sim, foi basicamente isso para esta palestra. Espero que você tenha achado útil se houver alguma pergunta como sempre, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 49. (Noções de Unity: Muito bem, bem-vindos de volta à introdução da unidade básica para o curso UD. E nesta palestra vamos dar uma olhada no roteiro de comportamentos mono. Então vimos na primeira palestra desta introdução básica que tínhamos que ter um script ou uma classe herdar do comportamento mono da classe base para que ele fosse um componente dentro do inspetor em nossos objetos. E agora vamos olhar para o que esse comportamento modelo basicamente nos permite fazer alguns exemplos e inhames, basicamente alguns exemplos do que isso é e o que ele faz. Então vamos criar uma nova cena. E este seria seis, e este é o comportamento mono. E vamos também abrir essa cena, claro, criar um novo GameObject vazio. Vamos chamar isso de E. Vamos chamar esse exemplo neste caso, porque eu não quero que ele seja chamado de comportamento mono necessariamente. Eu acho que você pode. Eu acredito que os nomes aqui não são tão importantes para os casos porque o comportamento mono é uma palavra-chave. E eu não acredito que os nomes aqui são algum antigo associado com ele. Mas só por precaução, e chamaremos isso de exemplo de comportamento mono. Para que não estejamos confundindo nada. E vamos abri-lo. E como podem ver, mais uma vez, comportamento do modelo deste ano é exatamente a classe base. E, como sempre, dois desses métodos são criados, o método de início e o método de atualização. E, na verdade, já há comentários aqui. Então começar método é exatamente o que ele diz. Ele é chamado antes do primeiro quadro. Então a idéia é que isso aconteça, tudo dentro de você acontece logo no início. E o método de atualização é simplesmente algo que é chamado de cada quadro. Para isso, o script deve estar habilitado. Isso é algo que podemos ativar e desativar no Inspetor. Vamos ver isso em breve. E então temos alguns outros métodos básicos que podemos chamar, por exemplo, o método acordado. Então, podemos apenas digitar acordado e, em seguida, pressionar a tecla Tab para completá-lo automaticamente. O método de espera nos permite basicamente ter algo chamado antes do método de início. Assim, o método awake realmente é chamado quando o script está sendo carregado. Então este script em particular neste caso, está sendo carregado. E isso acontece a propósito, quando a cena começa ou quando um objeto de jogo inativo é basicamente reativado, por assim dizer. Então, porque podemos alternar um objetos de jogo específicos ligado e desligado. E esse método de despertar é chamado, como eu disse, quando o objeto de jogo inativo é definido como ativo novamente, onde a cena é carregada pela primeira vez. Também temos diferentes métodos de atualização. Temos dois métodos de atualização diferentes. Temos a atualização fixa aqui em baixo, e também temos a atualização tardia. Então, o consertado. É basicamente um método de atualização que é independente de taxa de quadros. E a ideia de estar aqui que normalmente a física deve ser calculada dentro do método de atualização fixa. Porque, como você pode ver aqui, esta função é chamada a cada quadro de taxa de quadros fixa se o comportamento moral estiver habilitado. Então, se isso estiver habilitado, este script, então isso é chamado em uma taxa de quadros fixa. Portanto, a taxa de quadros independente. Por que é importante que, que a física são em vez disso, em vez do método de atualização? Bem, a idéia é que se você tem um bom computador ou um computador melhor, digamos, então talvez um jogo seja executado para você por 60 quadros por segundo. E, portanto, o método de atualização vai ser ficar frio 60 vezes por segundo. E talvez alguém que tenha um pior computador, na verdade, só tenha 30 quadros por segundo. E isso significa simplesmente que isso só é chamado 30 vezes. E se a física é dependente da taxa de quadros, então tudo se moveria mais rápido para a pessoa que tem o melhor computador e mais lento para a pessoa que tem o pior computador. Portanto, a física vai para a atualização fixa, pode realmente adicionar um comentário aqui também. Física, física dentro daqui. Então isso é meio importante. Isso é o fixo até ele. E a atualização tardia é chamada também todos os quadros. Nós podemos realmente ver este levar até este tribunal cada quadro, mas ele é chamado depois que o método de atualização foi chamado um realmente depois de tudo um método de atualização ha, foram chamados. Então esta é a coisa que corre por último no final do quadro e pode ser usada basicamente se tivermos duas coisas, se formos como, ok, o método de atualização vai e então a atualização fixa pode ir. E então nós queremos algo que no final, em seguida, a atualização tardia pode ir um pessoalmente eu não usei muitas vezes, mas eu também queria mostrá-lo porque pode ser muito importante. E há mais uma coisa que eu queria mostrar e que é o método de destruição, o método OnDestroy. Vamos ver se tem alguma coisa. Isso é chamado quando o comportamento moral será destruído. Então, a idéia é que podemos basicamente chamar um destruir um método que, em seguida, destrói este particular, ou este comportamento modelo particular e basicamente remove-lo de um objeto de jogo. Ou também podemos destruir um objeto inteiro e isso fica frio. Então este método é exatamente o que é chamado quando estamos prestes a destruir algo. Isso pode, por exemplo, salvar alguns dados, ou pode emitir uma mensagem, ou pode ter outra chamada de evento que queremos retransmitir, por exemplo, para o, para a interface do usuário. Então talvez você tenha 10 inimigos e nós realmente mostramos esse número na parte superior da tela e na interface do usuário. E então cada vez que este OnDestroy esfriar, talvez queiramos ver um inimigo ter sido destruído. Então, atualizamos a interface do usuário com isso. Isso seria um exemplo. Então vamos adicionar, se você os logs aqui, assim depurado com o método awake neste caso. E então vamos apenas copiar isso explicado para cima. Eu posso basicamente marcar algo aqui para que eu possa selecioná-lo. Pressiono Control C e, em seguida, entro aqui e pressione Control V para colá-lo. E este é o método de início. Também temos a atualização. Então vamos colocar isso aqui. Vamos realmente colocar a atualização fixa aqui porque é uma espécie de, você sabe, não é realmente antes da atualização normal, mas é que eu acho que isso faz mais sentido. E então a camada que está no final. Então este é o método de atualização. E nós também vamos copiar isso para a atualização tardia. E então, por último, mas não menos importante, o OnDestroy vamos adicionar. Podemos realmente ver isso. Vamos ver isto, basicamente destruído. E vamos realmente dar uma olhada nisso primeiro e então veremos outra coisa também. Além disso, não se esqueça de adicionar isso ao nosso objeto de jogo aqui. Esta é uma das coisas que provavelmente vai acontecer com alguns onde você vai começar e nada acontece. É porque você não adicionou a coisa ao seu objeto, certo? E como você pode ver claramente, a atualização na atualização tardia são chamados de todos os quadros, certo? E atualização fixa, como você pode ver, é chamado de pesar menos porque não importa qual é a nossa taxa de quadros aqui em cima. Isso é chamado em todos os lugares da mesma forma. Então, em teoria, esse número deve basicamente subir exatamente ao mesmo tempo que o seu número. E estes dois podem ser completamente diferentes para alguns, para alguns de vocês que podem ter um computador melhor, vai ser muito mais rápido. E para alguns de vocês que podem ter um computador não tão bom, isso pode ser muito, menos vermelho e como vocês podem ver, acordado, então a atualização armazenada é acionada, então a atualização fixa, depois a atualização e, finalmente, o atualizar. E também podemos ir quadro por quadro. E como você pode ver, que nós estamos realmente recebendo novos. E como você pode ver, agora é tudo o mesmo agora, porque agora nós estamos realmente indo quadro por quadro. E o FPS é, basicamente significa que é 0. E então eu vou quadro por quadro. Portanto, eles estão todos em sincronia. Certo? A outra coisa que eu queria te mostrar, porque o que ainda não vimos é o contratorpedeiro. E o método de destruição que podemos chamar. Nós vamos fazer ou vamos destruir este objeto. O que vamos fazer é ter um novo vazio privado. E nós vamos chamar isso de apenas o método de teste. Porque não? E este método de teste vai realmente fazer duas coisas. Uma coisa, vai produzir alguma coisa. Só vai dizer: “Ei, isso é muito legal. E a segunda coisa que fará é destruir este objeto. Então, como podem ver, destruir é um método que podemos chamar. E este método de destruição leva um objeto. Então podemos literalmente colocar qualquer coisa dentro disso. E na verdade já sugere que quer que a Transformação de Objeto do Jogo destrua o objeto do jogo seja destruída. Então isso destrói exatamente esse. Então isso destrói neste exemplo aqui. E veremos isso em breve. Mas o que faremos é não queremos que isso aconteça imediatamente. O que queremos é que isso aconteça depois de um determinado período de tempo. E para isso podemos usar o método invoke. E o método invoke é um método de comportamento mono que, como você pode ver, invoca o método, o nome do método em tempos de segundos. Então, se nós invocar e, em seguida, chamamos o nome do método é método de teste. Então vamos copiar isso porque o nome tem que coincidir exatamente com muito importante. E digamos apenas quatro segundos. Então, após quatro segundos, com esta chamada, o método de teste é chamado, que irá imprimir, hey, isso é muito legal, e então destruir o objeto do jogo. Portanto, também produzir este método OnDestroy, bem como parar todos os métodos de atualização porque eles estão associados a este objeto específico. Então, isso é muito uma vez, vamos ver o que vai acontecer aqui. Então, se o armazenamos mais uma vez, o que já vimos antes, deixe-me, deixe-me fazer isso um pouco maior. E como você pode ver, ei, isso é muito legal. Basicamente destruído e, em seguida, a contagem parou, bem como o objeto não estar mais lá. Por isso, foi destruído aqui. E se agora basicamente pararmos com isso, o objeto está de volta novamente. Porque isso é exatamente como já vimos antes. Os dados basicamente redefine para o quando paramos. E sim, essa é a idéia de ter alguns, então alguns truques mono comportamento, por assim dizer. Nós também podemos olhar para alguns outros. Então, se colocarmos esses pontos, então podemos realmente ver que há um monte de coisas que podemos chamar. E se você tem alguns métodos aqui, bem como, claro, alguns tipos diferentes de propriedades. E sim, essas são basicamente algumas das coisas que podemos fazer. Podemos, claro, também olhar para o comportamento mono em si. Acredito que se pressionarmos o Controle. Então, se você segurar Controle e clicar em comportamento moral, podemos realmente ver os metadados aqui. Então esses são basicamente os diferentes tipos de métodos que são capazes de ser frios. E sim, mas agora, isso não é muito interessante. Neste momento, acho que já vimos algumas coisas. Basicamente destruir um objeto e algumas outras coisas todas associadas a este comportamento mono. E sim, isso seria realmente para este método, comportamento mono é uma parte muito crucial desta estrutura de unidade. Então há definitivamente um, é uma coisa importante. Então, para entender isso é realmente importante. Então, como sempre, mas neste caso, especialmente se houver alguma pergunta como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 50. (Noções de Unity: Tudo bem, este é apenas um pequeno adendo que fiz para explicar vetores e a matemática por trás deles. Isso é realmente útil para realmente entender. E enquanto não vamos entrar em detalhes loucos, vamos olhar para algumas coisas para que você possa entender o conceito básico de vetores. Então, primeiro vamos começar com algo. Todos devem estar familiarizados com a linha numérica. Agora, como você pode ver, a linha vai de 0 a cinco, e, claro, além disso também. Mas para os nossos propósitos, isto é tudo o que precisamos. Você poderia se imaginar em algum lugar naquela linha para saber sua localização. Você só precisa saber um número, o número que você está enviando, certo? Então esta seria uma linha unidimensional neste caso, porque apenas um número precisava saber onde você está. Vamos adicionar os números negativos também. Isto ainda é unidimensional? Sim, é porque ainda precisamos especificar apenas um número para saber onde estamos. Pode ser negativo ou positivo, mas ainda era apenas um número. O que isso tem a ver com vetores? Você pode perguntar, bem, nós podemos representar esse número como um vetor. Assim, os dois então se torna uma seta de 0 a 20 neste caso, e muitas vezes outros casos são chamados de origem. Podemos ter vetores diferentes. Vamos ver alguns exemplos aqui. Temos um vetor com valor2, valor3 e valor negativo três. Se eu pedisse para adicionar os números 23 juntos, você diria, bem, são cinco. Bem, vamos ver o que acontece quando adicionamos os vetores juntos. Aqui temos um vetor com valor2 e aqui com valor três. Como podemos juntá-los? Poderíamos imaginar o vetor com valor3 viajando pelo primeiro vetor. E depois de fazer aquele diário olhar o que acabamos em cinco. Então dois mais três é igual a cinco. O mesmo pode ser feito com subtração ou números e vetores negativos. Então 5 mais menos três é igual a dois. Isso pode parecer completamente óbvio para você porque é assim que você adiciona e subtrai números todos os dias. Mas e se formos uma dimensão mais alta para a segunda dimensão? Agora temos duas linhas numéricas. Este é tradicionalmente chamado de eixo y, aponta para cima e como vertical. O outro é chamado de eixo x, e ele está apontando para a direita e é horizontal. Olhando para o mesmo exemplo que tínhamos antes, os dois seriam agora escritos como 2 0, porque agora precisamos de dois números para identificar onde estamos nesta grade. Nós vamos dois passos na direção x e 0 passos na direção y. Mas digamos que queremos acabar aqui. Bem, temos de ir cinco passos para a direcção X. Em três passos na direção y, vamos chamar este vetor a igual a 5, 3 com valor 53. E nós podemos querer adicionar outro vetor sobre isso, possivelmente ser igual a menos 2 e 2. Podemos fazer exatamente a mesma viagem antes de eu simplesmente deslizar b ao longo do vetor A, podemos chegar ao nosso destino C igual a 3 cinco. E como você pode ver agora, a adição e subtração é simplesmente uma adição para cada número do vetor independente um do outro. Então, se você pegar o valor x e adicioná-los ou subtraí-los. E se pegarmos os valores y e somarmos, subtraí-los, seja lá o que for, a soma, esses são os novos valores do novo vetor. A multiplicação é apenas esticar o vetor. Então, se temos 2, 3 anos e multiplicamos por dois, e nós apenas esticamos o vetor para que ele se torne 46. E a divisão só faz alguns mais curtos. Agora, para nossos propósitos, estamos usando vetores em três dimensões, mas é tão fácil quanto em duas dimensões. Obrigado por ouvir esta palestra sobre vetores. Eu acredito que é uma parte importante da matemática para entender, especialmente quando se tenta desenvolver um jogo, não importa o motor ou sistema que você está usando. E se houver alguma pergunta, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 51. (Noções básicas de Unity: Tudo bem, vamos continuar a introdução da unidade básica aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas transformações. Então vimos algumas coisas, o comportamento mono, e agora vamos dar uma olhada em algumas das partes constituintes, bem como se clicarmos em um de nossos GameObjects aqui, podemos ver que temos essa transformação quando tivemos a posição, a rotação na escala. E vamos dar uma olhada nisso em um pouco mais de detalhes. Então vamos criar uma nova cena aqui. Então esta cena vai ser L de transformações. E vamos abri-lo e fora da tela. É simplesmente chamado de transformações também. Transforma, muito importante que seja com o S. Então nós transformamos. Caso contrário, provavelmente teremos um problema com o script de transformação real. Então ou parte. Então vamos fazer propagação de zeros 0000 transformados nos scripts de transformação aqui. E então podemos simplesmente clicar duas vezes para iniciá-lo. E então podemos pensar sobre isso. Já vimos isso. Então vamos depurar ponto log exatamente isso, este ponto transformar. Então esta é a transformação anexada a este objeto de jogo. Então simplesmente irá retornar o componente de transformação real. Então este aqui. Então vamos ver como isso parece, como isso realmente produz. E como pode ver, não faz nada. Então, na verdade, temos que entrar um pouco melhor do que isso. Então isso simplesmente diz, certo, isso é como uma classe de transformadores. Isso não nos leva a lugar nenhum. Esta transformação, no entanto, tem alguns componentes, sendo esta a posição. Então este é um vetor de três. Tem a rotação, que é um quaternio. Vou dizer o que é isso daqui a pouco. E há também a escala, que é dividida na escala local e de perdas. E este também é um vetor três. Então vamos fazer algo assim. Talvez. Sim, escala local e com perdas. E então, em primeiro lugar, os vetores, vimos isso na última palestra. O que é um vetor neste caso, estes são vetores tridimensionais. No entanto, os vetores bidimensionais estão funcionando basicamente da mesma maneira, apenas com o último eixo não sendo importante. O que um quaternion é, é na verdade, uma estrutura quadridimensional, é quadridimensional para representar rotações no espaço tridimensional. Agora isso soa incrivelmente complicado no primeiro pensamento. E pode ser bastante complicado. Mas o bom é que a rotação também pode ser convertida em um vetor três, basicamente, porque a maior parte da rotação pode ser feita em ângulos de Euler, que é simplesmente uma maneira matemática de expressar as rotações também. Você fez, pode ter ouvido falar dele quando você talvez com um avião, há a guinada e o arremesso. E isso é algo que também pode ser descrito com isso. E uma rotação assim funciona. Você pega basicamente um eixo específico. Então, por exemplo, você diz que vamos basicamente pegar um ponto e colocá-lo através do eixo x e, em seguida, girar em torno disso. E essa é a maneira que essa rotação também funciona basicamente. No entanto, no nosso caso, a rotação, nós vamos olhar para isso talvez em um pouco mais de detalhes também. Mas agora, o importante é que em 2D, apenas a rotação Z realmente importa para nós. Porque a rotação Y seria neste plano, o que, ou melhor, neste plano, faria qualquer sentido. E a expectativa seria neste plano, o que não faz sentido. Só andar por aí assim faz sentido para nós. Qualquer outra coisa em 2D realmente não importa. Então vamos realmente voltar aqui e depurar log cada uma dessas coisas. Então este ponto transforma, ponto posição. E nós podemos copiar isso com o Controle C e colá-lo Controle V, obter a rotação aqui e obter a escala local neste caso. E vamos, por que não pegar também a outra escala? Então, se colocarmos em escala, como você pode ver, há dois deles. Há a escala local e a escala de perdas. Há realmente bons comentários lá. Então podemos realmente ver a posição espacial mundial da transformação. Temos um quaternion que agita as lojas a rotação da transformação no espaço mundial. Nós também temos a escala da transformação em relação aos objetos do jogo. Pais, vou explicar o que isso significa daqui a pouco. E esta é a escala global do objeto. Então, quando olhamos para isto, saída, isto e vemos o que realmente vamos conseguir. E a primeira coisa é isso, como os vetores parecem basicamente, certo? Então são três componentes, assim como aqui. Então a posição vai ser 000, 000, a posição de rotação é 000. E então um, como eu disse, um quaternion é basicamente um vetor quadridimensional que expressa as rotações para nós agora. Não vamos pensar muito nisso. Vamos pensar sobre isso. Temos quatro números que, de alguma forma, representam uma rotação. Mas também podemos fazer isso com esses três números. E então isso pode mudar de acordo. A escala, tanto local quanto com perdas é a mesma agora, porque este é simplesmente um, um objeto de jogo que está na raiz. Então o que podemos fazer basicamente é se eu colocar em um novo vazio, então eu tenho isso selecionado, então eu tenho isso selecionado mouse nisso, diga Criar Vazio do que ele ir. Ele vai criar este objeto de jogo como um, como um, basicamente uma criança para este objeto de jogo. Então este é o objeto criança, por assim dizer. E isso é agora, basicamente tem duas escalas. Porque se fôssemos escalar este pai, então a criança iria escalar com ele. E se fôssemos escalar apenas a criança. Apenas a criança é escalada. Então, se eu colocasse na escala para 22. E então, como veremos, se eu começar isso e primeiro de tudo, nós vamos ter 22 e ambos, porque o, o pai, tudo bem. No entanto, se desativarmos o script de transformação neste, vá para o script filho e coloque o mesmo script de transformação neste. Mesmo que a escala aqui seja 1, 1, 1. Vamos começar isto. Você verá que a escala local é 111 porque esta é a própria escala. No entanto, a escala de perdas em termos de como o mundo olha para isso é de dois a dois. Porque isso fica basicamente sim. Adicionado. Acredito que seja multiplicativo, certo? Então isso é sim. Então é multiplicativo. Então o, então, se isso é três vezes maior em qualquer direção, e isso também é três vezes maior, claro. Isso faz sentido. Essa é basicamente a idéia de escala local e escala com perdas. E há também uma última coisa que seria a posição local. Há também a rotação local. E mais uma vez, isso é relativo à transformação do pai e a posição local é relativa à transformação dos pais. Vamos dar uma olhada rápida nisso. E vamos realmente como um rapidamente adicionar o isso porque caso contrário nós vamos ter números loucos lá fora e nós não temos nós nem sequer vamos saber o que são esses. Então esta é a posição, esta é a rotação. E só para o inferno vai adicionar a rotação local também. Porque, por que não? Se estamos aqui, então podemos ver isso rapidamente. Então esta é a rotação local que queremos. E então esta vai ser a escala local. Vamos virar isso rapidamente. Então vamos colocar isso aqui porque sempre temos o local, o fundo. Então vamos fazer disso um hábito. Lá vai você. Tudo bem, então nós temos a posição, então nós vamos colocar a posição local para fora, em seguida, a rotação do que a rotação local, a escala e a escala local. Então vamos rapidamente dar uma olhada nisso. Vamos começar e ver o que veremos. Assim, a posição é de 000 000, 000 posições locais zeros. Isso faz sentido porque tanto a transformação como a criança têm depósitos zeros, portanto, nada mudou a rotação. É o mesmo porque era exatamente o que tínhamos. E então as perdas, a escala de perdas. Então escala comparada com o mundo é três. escala local por si só é uma. Então vamos, por exemplo, girar este 90 graus na direção z e, em seguida, a criança, nós poderíamos, por exemplo, na verdade, então vamos então também mover este cinco para cima. Na verdade, só vamos subir. Então o que vamos ver é que a escala local na posição local não vai mudar, como você pode ver, porque localmente esta criança ainda está bem aqui. Então local é basicamente o eixo disso. E então, em termos de posição mundial, então a posição normal está agora em 0 a 0, porque esta criança, se olharmos para esta, está localizada bem aqui. Então, mesmo que localmente, então se esta seria a raiz. Este é em 000, 000 porque é exatamente a mesma posição esta transformação em tempos do mundo, Ele é movido. E o mesmo com a rotação. Como você pode ver, isso agora é um pouco diferente aqui. Como eu disse, o quaternion. Você não precisa entendê-los agora. Basta notar que isso é diferente desta rotação Basicamente. Sim, e essa é a ideia aqui. É um pouco. Não posso ficar um pouco louco. Normalmente. Simplesmente o que você deve perceber é que se você tem objetos filhos e filhos, então eles podem trabalhar um pouco diferente dos objetos normais. Mas geralmente é, o que também podemos ver aqui. Podemos definir realmente mover a rotação e a rotação local, mesmo que com a posição local e a posição normal. A única coisa que não podemos definir é a escala de perdas. Só podemos definir na escala local. Agora, para objetos que são, que não têm um pai de onde o pai é basicamente a raiz. Isto não importa. Você sempre deseja definir a escala local de qualquer maneira. E só para que tenhamos feito aqui, o que vamos fazer é fazer rapidamente um movimento muito parecido com o mais fácil que pudermos. E isso vai ser este ponto ponto transforme traduzido. Então este é um método que podemos chamar para esta transformação. E como você pode ver, nós realmente temos um monte de métodos que podemos chamar. Então, há muitas coisas. Então lá vai você. Para que, como podem ver, há muitas coisas nesta transformação que poderíamos chamar. E agora vamos olhar para traduzir. E o que isso faz, como você pode ver, move a transformação na direção e na distância da tradução. Então vamos mudar isso. Se pudermos olhar para isso, isso precisa de uma tradução vetorial três e também pode ocupar um espaço em relação a. Isso, simplesmente significa que ele se moverá ao longo de um determinado vetor. Vamos dar um vetor de dois pontos, certo? Então este é simplesmente o vetor 0, então um na direção X e 0 na direção y. E nós estamos indo para vezes isso por vezes por vezes.DeltaTIME. E esse tempo delta é basicamente o tempo de conclusão em segundos desde o último quadro. A ideia é que queremos que isso não seja, para não mover isso a uma velocidade incrível. Mas queremos que isto seja atenuado um pouco. Basicamente. Vamos ver o que isso vai fazer. Na verdade, para os propósitos disso, vamos desativar o objeto filho e o script aqui. Vou ligá-lo para que isto se transforme. Porque isso é mais interessante agora. E sim, vamos ver, então isso deve mudar a posição. E deve mudar esta exposição. Vamos realmente também desativar a rotação aqui porque caso contrário ele vai ficar um pouco funky. Então, se olharmos para isso, como você pode ver, ele agora se move para a direção x. E se entrarmos na visão da cena, podemos ver que ele realmente está se movendo lentamente, mas seguramente longe. E sim, isso é, como eu disse, um movimento muito, muito básico e simples que podemos fazer. Claro, em teoria, o que você pode fazer é que você também pode levar seus próprios vetores aqui para que você possa criar um novo vetor porque a distância que eles estão é importante. Então, quão grande o vetor é importante? Mas sim, no geral isso é uma visão geral básica do componente de transformação, digamos. Então este é o mais básico dos componentes que cada objeto de jogo sempre tem. Então isso está sempre presente em qualquer script que tenha o comportamento mono como uma classe base, você deve ser capaz de fazer essa transformação de ponto e mudar o posicionamento ou a escala ou algo assim. E como você pode ver, há algumas outras coisas, contagem de crianças, você pode ter filhos. Há uma maneira de obter componentes e há também uma maneira de girar este objeto. Então há algumas coisas como você, como de costume, eu provavelmente sugeriria dar uma olhada rápida em algumas dessas coisas, mas é claro, muitas delas nós também vamos dar uma olhada em futuras palestras. E então uma aplicação real vamos ver uma vez que realmente começar a fazer um tempo, basicamente um jogo real, certo? Um jogo real como um jogo onde podemos colocar. Isso é excitante, mas estamos construindo coisas muito importantes. Então esta é outra daquelas coisas que é realmente muito importante, transforma uma parte crucial, basicamente significando onde no mundo um objeto particular está. Então, mais uma vez, se houver alguma pergunta, sinta-se à vontade para perguntar e eu vou ter certeza de responder. Mão. Sim. 52. (Noções de Unity: Muito bem, bem-vindos de volta à introdução da unidade básica aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em um jogo objetos. Então nós falamos sobre isso ou eu falei sobre isso por um tempo agora, eu sempre chamei os elementos basicamente constituintes dos objetos do jogo de cena. E isso é exatamente o que são. E vamos dar uma olhada neles agora com mais detalhes. Então vamos criar uma nova cena aqui chamada El Nine GameObjects. E então nós vamos, claro, também criar um novo script e vamos chamar este jogo de objetos também. Um importante novamente com o S no final, porque caso contrário podemos ter alguns problemas com o nome. Portanto, um novo GameObject vazio é necessário. Além disso, vamos chamar este jogo objetos e 000, 000. Mais uma vez, isso é só para mim porque eu realmente preciso que este seja 0. Não sei porquê, mas quero que o meu objecto de jogo vazio esteja na posição 0. Antes de entrarmos no roteiro, precisaremos de mais uma coisa. E isso é algo para basicamente visualizar o nosso muito bom um objeto de jogo. Então vamos realmente adicionar algo a ele para que possamos ver isso. Então vamos fazer isso como se segue. Eu vou ter rapidamente, Eu tenho uma pasta no diferente em, em outra tela e eu só vou arrastar para ouvir um PNG. Então este vai ser um arquivo PNG em vez dos sprites. Mas isso, é claro, está disponível como um recurso. E essa coisa em particular é, como você pode ver no Inspetor, agora temos essa textura 2D em vez de aqui. Na verdade, já viu isso como um sprite. E não há realmente nada que precisamos mudar aqui para que possamos mantê-lo assim. Nós vamos em uma futura palestra ir para o sprite, basicamente um Sprite Editor e como isso funciona em uma palestra e ver o que podemos ver lá. Mas agora, nós vamos fazer é realmente vamos adicionar isso como um objeto de jogo. Então podemos simplesmente pegar isso e arrastá-lo para nossa cena. E assim, ele cria um novo GameObject como você pode ver. E este é um poço então simplesmente situado aqui. O que vamos fazer é porque isto é um pouco pequeno. Nós só vamos aumentar a escala aqui para algo como cinco vezes cinco. E o que vai, você também vai ver é que ele está um pouco embaçado. Podemos corrigir isso alterando este modo de filtro para apontar e, em seguida, clicando em Aplicar, e, em seguida, ele não está mais desfocado. Explicarei essas coisas como disse um pouco mais tarde. Em vez de um sprite, neste momento, não precisamos realmente nos preocupar com isso, mas agora nós realmente temos algo. Então vamos também centróide em 000 e, em seguida, movê-lo um pouco para cima, provavelmente, como três. Sim, isso é bom. Então agora está no topo da tela. E se mudarmos para a nossa visão de jogo, isto é agora o que veríamos dentro do jogo. Então nós veríamos este ás de copas basicamente flutuando aqui no topo. E seremos capazes de fazer algumas coisas legais com isso. Vamos mudar o nome para carrinho porque é um cartão. E nós vamos, vamos ver o que podemos ver. Então, neste momento, este é um objeto com um componente de transformação, o componente de renderização de sprite. Assim como com o spread alguns sais, vamos dar uma olhada no renderizador em pouco tempo. Agora mesmo. Nós só precisamos saber que, ok, isso é basicamente eles são para que tenhamos um visual para este objeto. Isto, claro, sendo um objeto vazio, não temos que, no entanto, temos o script aqui. E o que vamos fazer é clicar duas vezes nisso e começar a programar algo agora mesmo. Então a primeira coisa que queremos é que queremos um novo campo aqui, e que vai ser um objeto de jogo privado chamado cartão. E essa é a coisa legal porque como eu disse, em vez da hierarquia, as coisas individuais são objetos de jogo lá dentro. E podemos referenciá-los simplesmente usando uma nova variável do tipo de objetos de jogo. Então isso é simplesmente um testamento de classe, porque este é um mundo privado, fazer disso um campo serializado para que possamos realmente ver isso dentro do espectro. E então, em vez do método de início, a questão realmente se torna, bem, onde é que isso é chamado agora é apenas vai ser atribuído a ele. Bem, vamos dar uma olhada. Então, como você pode ver agora, não há nenhum objeto de jogo aqui. E se eu fizesse algo com este cartão, então o que aconteceria é que simplesmente não funcionaria porque isso é nulo. Então o, ele não foi atribuído porque este é, como você pode ver, num significa que não há nenhum objeto de jogo aqui. Agora o que eu posso fazer, e esta é a coisa realmente legal sobre o Inspetor. Eu poderia arrastar isso aqui. E como você pode ver, ele realmente vê que, Oh, este é um objeto de jogo. E se eu colocá-lo aqui, eu posso ver que este tribunal agora é referenciado dentro desta variável em particular. No entanto, geralmente não queremos isso porque nem sempre, nem sempre é uma boa ideia atribuir coisas através do inspetor. Às vezes pode ser bom, mas eu também queria mostrar como você pode fazer isso dentro de si mesmo. Existem várias maneiras diferentes e uma delas é basicamente uma das mais fáceis. Então o que podemos fazer é dizer que cordão é igual ao objeto do jogo. Então o nome da classe ponto encontrar em vez. E, em seguida, dentro desta chamada método, podemos chamar, podemos colocar em um nome. Nesse caso, isso seria chamado porque esse é o nome do objeto. Podemos verificar isso de novo. Sim, este é o nome do objeto é chamado de cartão, e isso é o que precisa entrar lá. Então este é um método estático de GameObject que retorna um GameObject, como você pode ver, encontra um GameObject pelo nome e retorna. Então isso vai olhar através de toda a cena que temos Open atualmente. Procure o objeto com o nome dado aqui e devolva-o. Se o encontrar. Se não o encontrar, é claro, ainda será nulo. Então vamos apenas ver se ele realmente encontra isso fazendo algo como cartão ponto transformar posição ponto. Então vamos simplesmente obter a posição do acorde que acabamos de ver lá. E sim, vamos ver se realmente funciona ou se não funciona. Porque neste momento, é claro que o tribunal, o tribunal não tem nenhum script associado a ele. Agora estamos recebendo este, este objeto de jogo através deste script aqui e dando uma olhada, então vamos apenas armazenar isso e ver o que acontece. Então, a primeira coisa que podemos ver é que esta variável de cartão realmente preencheu. Então ele encontrou o cartão com ponto GameObject encontrar. E também vemos que 0, 3, 0 foi emitido e esta é exatamente a posição do carrinho. Então tudo funcionou exatamente como queríamos. O que é muito legal. Então esta é uma maneira em que podemos olhar para um jogo objetos e, em seguida, sim, mesmo, até mesmo manipulá-los, certo? Vimos as transformações da última vez. Como podemos manipulá-los, mudando a posição. E é claro que poderíamos, por exemplo, fazer isso também. Mas eu queria mostrar outra coisa porque há outra coisa que é realmente interessante e que está gerando novo objeto de jogo. Então isso é tudo uma espécie de parte de objetos de jogo. E o que podemos fazer é basicamente fazer uma nova variável de objeto de jogo aqui. Então objeto de jogo e definir este igual para instanciar. Instanciar é um dos, um dos métodos realmente objeto. E então nós simplesmente damos a ele um, um objeto original, que é este acorde. Então isso pode ser um pouco estranho. O que estamos fazendo aqui? Bem, este método instanciado simplesmente cria um novo GameObject baseado em um determinado objeto de jogo que lhe damos uma espécie de modelo. Isso também pode ser chamado de prefab. E nós vamos olhar para prefabs em um pouco, pouco como uma semana depois. Agora eu só queria basicamente mostrar rapidamente que podemos gerar novos GameObjects. E este novo GameObject agora é, naturalmente, salvo nesta variável de objeto de jogo. E eles são, podemos definir a posição, por exemplo, no novo vetor 3 e, em seguida, algo como 0, menos três. E menos três, f termina em 0, algo assim. E sim, vamos fazer isso e ver se funciona. Então, no início, devemos ver um novo cartão aparecer com um clone de cartão de nome. Exatamente. E isto está na posição 0 menos 3 0. Vamos dar uma olhada nas instanciações um método em um tempo em mais detalhes mais tarde na linha também. Eu só queria mencioná-lo rapidamente, porque esta também é uma parte muito grande dos objetos do jogo. E no geral, ele vai ser o GameObjects. Essa é a principal coisa sobre a qual vamos falar. Então ele sempre vai ser feito GameObjects. Sempre serão componentes e sempre serão roteiros. E sim, esses são os blocos de construção. Ideia é que temos diferentes tipos de componentes e GameObjects pode basicamente levar quase qualquer tipo de componente para eles. Scripts ou um componente específico transforma-se. E como vimos o renderizador de sprite, certo? Isso tem a habilidade de nos mostrar algo como uma imagem. E há tantos mais em tipo de componentes aqui, certo? Então esses são todos os grupos diferentes. E para cada um deles, há muitos deles. Então nós vamos ir pedaço por pedaço, você sabe, pouco a pouco. Vamos aprender mais e mais. E espero que em algum momento, então seremos capazes de fazer um pequeno jogo. Vamos ver. Seria uma ótima ideia se isso realmente funcionasse. Então essa é a essência dos objetos do jogo. Pode ser um pouco assustador no início, porque há um pouco para eles. Agora, é claro que só mostraram algumas coisas. Se colocarmos em GameObject dot, nós realmente não temos gordura, muitos métodos diferentes que podemos chamar. Então há métodos como aqui. Mas o que é interessante é que o, esta taxa de chamada é exatamente um GameObject. Então isso retorna um objeto de jogo. Se dermos uma olhada nisso. Então o, vamos para a transformação. Lá vai você. E assim a transformação de distorção é exatamente algo para um componente neste caso. Mas o, isso se refere exatamente ao objeto do jogo. Então, nós também podemos dizer este ponto GameObject, e então nós podemos obter exatamente o GameObject que este script particular está anexado a. Então este seria o script e, em seguida, este ponto GameObject retorna o objeto de jogo real. Como você pode ver que este componente está anexado a. E sim, há muito mais coisas e eu tenho certeza que muitas delas você vai pegar como nós avançamos. Porque poderíamos fazer uma palestra de uma hora sobre GameObjects. Mas isso realmente não nos leva a lugar nenhum porque há tantas coisas que você precisa como uma espécie de pré-requisito para entender outras coisas. Então, às vezes, pode ser um pouco nervoso, mas eu acho que no geral vamos ter uma boa linha para entender cada parte em particular. Mas de qualquer forma, Suficiente disse que esta era a palestra sobre um jogo objetos. Espero que tenha achado útil. E eu, é claro, realmente apreciaria uma crítica sua. Caso contrário, se você tiver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 53. (básica de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada nas entradas. Então entradas, basicamente se você pressionar uma tecla e, em seguida, uma certa coisa acontece. Como podemos fazer isso na Unidade? Bem, vamos descobrir isso. Vamos criar uma nova cena, L dez, chamada entradas e abertura, como sempre criar um objeto de jogo vazio aqui, também chamando essa entrada. E vamos. Depois de centralizar isso em 000 000, vamos também criar um novo script das entradas de nome. Alguém poderia ter adivinhado, mas lá vai você. Agora, não vamos precisar do método start aqui. Só precisamos do método de atualização para este. Porque o método de atualização basicamente executará todos os quadros. E se pressionarmos uma tecla, então algo vai acontecer. Então, como podemos fazer isso? Bem, nós colocamos em uma declaração se e então vamos chamar o ponto da classe de entrada, obter a chave para baixo. Então este é o método que queremos, então retorna true durante o quadro, o usuário começa a pressionar uma tecla, e esta tecla é acessível usando o ponto de código de tecla. Então o código chave é um enumeração. E dentro daqui, como você pode ver, eles são basicamente um monte de códigos diferentes. E vamos apenas tomar para este f. Então pressione F para depurar log de pontos. Descanso FQ. Eu gosto disso. Então, em teoria, se tudo funcionar, isso deve ser verdade quando eu pressionar a tecla F. Então eu pressioná-lo e isso vai obter saída uma vez, porque neste caso ele só recebe os verdadeiros. Então vamos ver se isso realmente funciona. Além disso, certificando-se de que o script de entrada está ativado aqui. Muito importante. Agora, nada e depois a tecla F, e lá vai você. Agora o que eu posso fazer é se eu segurar a tecla Shift, como você pode ver, ela não aumenta. Ainda estou segurando a chave. Você simplesmente deve confiar em mim para isso. Mas, de fato, isso não aumenta. E se eu deixar pra lá, eu fiz isso de propósito. Então talvez você já tenha ouvido isso. Então vamos ver. Há, claro, outras coisas que podemos fazer. E isso é exatamente certo. Então, há uma chave de ponto de entrada e eles recebem C0 simplesmente também leva um código de chave. Vamos também dar-lhes F aqui. Vamos copiar isso e dizer pressionando a tecla F. E só para terminar, vou para o outro. Isto é “Levante-se”. E isso é chamado, que é então parado pressionando grade de teclas F. Então a tecla para baixo é verdadeira uma vez que eu começo, uma vez que eu pressione a tecla. Para apenas os get key, como você pode ver, retorna true enquanto o usuário mantém pressionada a chave identificada pela chave, chave chamada enum parâmetro. E eles obtêm chaves verdadeiras durante o quadro que o usuário libera para a chave. Portanto, temos a capacidade de verificar se uma tecla foi pressionada ou não uma vez. Ou melhor. Como. Vamos ver o que acontece aqui. Então eu pressiono F e mantenho pressionado. Como você pode ver, pressionando a tecla F, ele só, ele realmente pára se o foco não está mais no jogo. Porque se você olhar, que possamos ver se eu faço isso e então eu paro de pressionar porque eles param de pressionar aqui. Mas você pode ver que isso agora está em foco por causa desta linha ligeiramente azul aqui. E se eu me mudar para cá em algum momento, talvez porque eu clique de distância, então o foco muda e então, claro, isso não está mais funcionando. Então isso é o mais provável que tenha acontecido aqui. Que, por alguma razão, sim, lá vai você. Agora o foco mudou e, em seguida, isso vai parar, é claro. Então essa é uma coisa que é muito importante de perceber também. Mas, no entanto, ainda funciona muito bem. E como você pode ver, se eu realmente gosto, tente apenas clicar uma vez e ainda assim como 40, 7, 2, 4, 7, 1. Então, mesmo eles são porque, claro, nossa taxa de quadros é tão alta. Pressionamos isso muitas vezes, mesmo que eu esteja pressionando por quase um segundo, ainda estamos enlouquecendo. Então, sim. Sim, mas isso é uma entrada básica. Na verdade, isso é tudo o que há para eles. É como muito simples se afirmações. Isso é tudo o que realmente existe. E aqueles simplesmente retornam booleanos. Então é claro que você também pode acorrentá-los, certo? Então entrada obter a chave para baixo com kicker f. E então se, por exemplo, você poderia usar alguns dos operadores booleanos, alguns dos operadores lógicos, o fim, e, basicamente, colocá-los juntos com outro código de chave. Então, sim, essas são as entradas muito básicas. E isso realmente permite que você já faça algumas coisas loucas legais. E o que vamos ver basicamente a próxima pré-apresentação é fazer um script de movimento muito simples. Agora, há algo que você também pode pensar se você lembrar de nossas transformações, nós tivemos um movimento muito, muito simples lá. E se você agora aplicar as entradas e basicamente o que tivemos na palestra de transformações, talvez você já possa descobrir antes de assistir a próxima palestra, como podemos criar um script de movimentos muito simples. Sim, mas com isso, vou deixar você e eu por enquanto, para esta palestra de entradas, foi claro, uma das coisas mais importantes para um jogo. Eu sei que, como estou sempre dizendo, bem, esta é uma das coisas mais importantes, mas isso pode não ser importante como exatamente funciona. Mas entradas em si é importante para um jogo. Então as entradas provavelmente poderiam tê-los descoberto por conta própria. Mas, no entanto, esta é a palestra de entradas. E no futuro há um pouco mais de nuance. Então, pode muito bem mostrar-lhe rapidamente. Então a classe de entrada já tem, como você pode ver, muito mais coisas também. Então esta não é a única maneira de obter a entrada. Há algumas coisas que você pode fazer. Mas, por enquanto, essa é a entrada que, você sabe, eu era. Acho que faz sentido mostrar a você. E depois mais abaixo da linha, se precisarmos de mais alguma coisa, vamos ver isso também. Sim, mas para isso, é o fim da palestra. Espero que você tenha achado útil e como sempre, se houver alguma dúvida, sinta-se livre para perguntar e eu vou ter certeza de responder. Mão. - Sim. 54. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra, vamos criar um roteiro de movimento muito simples, mas eficaz. E para isso, é claro, nós vamos, primeiro de tudo, criar uma nova cena. Este seria o movimento L 11, um movimento. E vamos começar imediatamente isso. E desta vez não vamos criar um GameObject vazio, mas vamos mais uma vez simplesmente pegar o coração e colocá-lo aqui e realmente dimensioná-lo. Vamos dimensioná-lo até cerca de quatro vezes o tamanho normal. E começou em y nível dois. E então nós também vamos fazer um novo roteiro. Isto vai ser um guião chamado “Onde está?” Não, eu perdi. Aparentemente, lá vai você. Movimento. Movimento. Sim. E vamos abrir esse roteiro e ver o que podemos ver. Então, primeiro de tudo, vamos ter algumas coisas aqui. A primeira coisa vai ser um campo serializado, vai ser um carro alegórico privado chamado velocidade. E vamos definir isto para três. Para o momento. Claro que podemos mudar isso mais tarde. Porque com o campo serializado, isso está disponível para nós no inspetor. E o que nós também vamos fazer é criar uma transformação privada, que será apenas a minha forma de vertentes de tendência. E isso simplesmente vai ser ajustado para. Então minha transformação é igual a essa transformação. Não precisamos necessariamente de fazer isto. No entanto, em uma palestra posterior, vamos aprender sobre gets componente e por que armazená-lo em cache como esta é uma idéia muito inteligente como esta. Fazer isso é realmente bastante. E então vamos criar dois métodos diferentes porque vamos começar a fazer as coisas de uma forma que é, digamos legível. No máximo, assim seria ótimo. Então, vamos ter um método de execução e um método de movimento. Não, método de movimento normal. Lá vai você. Então este, vamos apenas pegar os colchetes aqui e então, e esses dois são, será chamado dentro do método de atualização. Então r1 e, em seguida, mova-se. Então isso é algo que é uma coisa boa para se pensar. A geralmente é melhor separar cada uma das funcionalidades em seu método de atualização em como métodos diferentes. E então simplesmente tê-los aqui. Porque agora se eu entrar neste código e ver, oh, ok, primeiro eu vou, eu vou chamar run e então eu vou me mover. Isto. Você sabe, a nomeação pode ser um pouco diferente, mas no nosso caso eu acho que vai ficar tudo bem. Agora este método de movimento vai ter exatamente o que aprendemos basicamente nas poucas palestras anteriores. Então, primeiro de tudo, o input.txt recebe chave, não obter chave para baixo, mas obter chave. E depois com uma nota chave com um código de chave. Então este é o ponto de código de enumeração. Vamos pegar o w. então vamos nos mover para cima. Então, isso fará o seguinte. Na verdade, sim, claro. Vamos fazer assim. Vamos, na verdade, vamos primeiro fazer isso assim. E depois vou mostrar-te outra forma de o fazeres. Então meu transform.py traduz, oh, não, traduz. Então esta é a chamada de método que temos usado. Da última vez. Esta foi a chamada de método para basicamente mover algo. E vamos colocar isso no vetor dois pontos. Então esta é a direção ascendente com Time.DeltaTatime vezes velocidade. Então esta é basicamente a chamada que vamos fazer, que vamos fazer porque então vamos avançar o caminho para cima. Então 0, 1, x sendo 0, y sendo 1, delta vezes, mais uma vez para torná-lo de modo que nós não, basicamente torna isso mais ou menos como a atualização fixa. Não exatamente, mas vamos chamá-lo assim por enquanto para que não tenhamos um número louco, louco como grande. Vamos também fazer WASD por causa do argumento S e D aqui. E então um seria a esquerda, S seria vetor para baixo e um vetor para escrever. Então, isso é bom. E vamos testar isso com este código por enquanto e então vamos refatorar um pouco depois de testarmos. Então vamos pegar o script do movimento e adicioná-lo a este acorde. E então vamos entrar e ver se isso realmente funciona. Então, se eu pressionar a tecla Esc, nós nos movemos e se eu mantê-lo pressionado, então ele se move e o cartão realmente se move. Agora o que você vai notar é que o movimento diagonal é um pouco mais rápido do que o movimento normal. Isto é simplesmente devido ao IEP. Isto é devido à adição semelhante porque estamos nos movendo, digamos velocidade urbana de três nesta direção e a velocidade de três nesta direção. E então, em teoria, devemos estar nos movendo a uma velocidade de seis nas direções diagonais. O que, claro, não é o que queremos. No entanto, vamos ignorar isto por enquanto. Primeiro de tudo, o que vamos fazer é pensar em tornar isto um pouco mais legível. Agora isso não é a maior coisa e não precisamos necessariamente fazer isso. Mas como você pode ver, isso é como um muito como este é quase sempre o mesmo, certo? Esta, esta chamada aqui. São sempre as minhas tendências de retradução. E a única coisa que muda é isso. E se nós temos isso, é realmente bastante fácil fazer mais uma vez outro método ou este, então isso seria, por exemplo, mover para poderia ser a coisa ou nós poderíamos, nós também poderíamos chamá-lo de mover novamente. Porque nós vamos ter um perímetro aqui que vai ser um vetor para citar a direção. E então nós podemos basicamente apenas copiar isso porque isso é, nós só vamos usar esses. Coloque a direção aqui. A velocidade vai ser tomada, claro daqui de cima, então isso não importa. E então podemos basicamente dizer Mover para e, em seguida, dizer vetor para ponto. Isso seria certo. E então basicamente apenas mude isso. Assim, boop, boop, boop. E, em seguida, apenas certificando-se de que temos os corretos aqui. Isto é para a esquerda e isto para baixo. Eles vão, certo. Este é apenas um exemplo. No final do dia, realmente não há uma resposta certa ou errada para isso. No entanto, vou dizer que acredito que isso é provavelmente melhor para ler. Poderíamos também dizer que talvez se mova na direção. Este pode ser um nome melhor. E se quisermos mudar este nome será pode fazer é podemos acertar o Controle R duas vezes. Então, basicamente controlar RR. E então podemos mudar isso, então siga em direção. E então isso é ainda melhor para ler. Então, creio eu, isso é ainda melhor para ler. Então podemos ver, ok, se a tecla for pressionada, então mova na direção do vetor ponto-ponto. Então, conhecemos o nosso caso. Estamos indo para a direção para cima. Na verdade, gosto muito de ler. E no geral eu acho que um bom método para basicamente refatorar neste caso, certo? Então, o que tem a ver com essa corrida também? Então, também temos este método de execução aqui. E o que vamos fazer aqui é basicamente fazer o seguinte. Então, a chave input.txt para baixo. Então, se pressionarmos as teclas, então o que vamos fazer é dizer calor ou mudança para a esquerda, apenas por causa da discussão agora. Então vamos definir esta velocidade para cinco. Então, basicamente, uma vez que eu pressioná-lo uma vez, então nós vamos colocar a velocidade em 25. E então vamos copiar isso e dizer, se conseguirmos a chave para cima, então vamos redefinir para três. Então isso simplesmente faz com que possamos correr. Basicamente. Há alguns, digamos, problemas associados a ele que vamos analisar também. Mas vamos ver se isso funciona. Então, em primeiro lugar, nossos movimentos normais ainda funcionam. E então se eu pressionar a tecla Shift e movê-los, como você pode ver, eu sou mais rápido do que eu era antes. E então se eu parar de segurar Shift, então ele funciona para que eu possa em rajadas basicamente correr. Isso é muito bom. Agora, uma das coisas que, é claro que eu poderia fazer. Agora, tenho a tecla Shift pressionada. E porque ele procura o levantar-se, eu posso basicamente clicar para fora desta janela, parar de pressionar a tecla Shift, voltar para dentro. E agora estou sempre fugindo. Também podemos ver isso aqui. A velocidade é cinco agora. E agora estou sempre fugindo. Agora isso é algo que você precisa pensar também. É apenas uma coisinha curta que eu queria mencionar apenas por enquanto. E agora vamos também pensar sobre a idéia do, a duplicação. Então a duplicação acontece porque, como eu disse, quando olhamos para isso, se eu pressionar W e E, ambas as direções serão movidas para dentro. E então, basicamente, a tradução vai se mover para a direção da direita, com essas adições. Então vamos apenas dizer que para o bem do argumento vai se mover para ou para a esquerda melhor. Então ele vai se mover em direção menos 1, 0. Ele também vai se mover para a direção 0, 1. E esses basicamente são adicionados. E o movimento diagonal que então é mais rápido, que por causa do, exatamente como os vetores funcionam. Certo? Corrigir esta diagonal é realmente, eu não diria impossível para a tradução. No entanto, isso vai envolver um pouco mais de delicadeza neste caso. E isso é algo que não vamos fazer, especialmente porque o método Traduzir na verdade nem sempre é a melhor maneira de movimento, como se houvesse melhores maneiras de garantir movimento. E geralmente também, o movimento diagonal. Se isso, realmente não importa se o movimento diagonal é mais rápido ou não mais rápido do que é claro, isso não é realmente preocupante. Mas agora não vamos corrigir isso porque neste caso é realmente não é um problema. E também por causa do fixo iria realmente ir um pouco mais fundo em como isso funciona e tornaria isso um pouco mais complicado. E este é suposto ser um script de movimento muito fácil que simplesmente funciona. Agora isso é claro, um script de movimento que funciona para uma espécie de visões de cima para baixo ou uma espécie de visão de Zelda neste caso. Mas isso pode ser adaptado a um tipo de plataforma de u.Aguarde o salto e o diferente, digamos movimentos diagonais. Então há uma maneira diferente com isso. Podemos basicamente usar o sistema de movimento ou criar um sistema de movimento diferente. Digamos que isso é, é algo que vamos dar uma olhada em uma palestra posterior. No entanto, tenha certeza, isso será analisado em uma data posterior, certo? Então foi isso para o movimento muito básico. Agora você realmente tem um cartão basicamente que pode se mover, o que é muito legal. Consideradas todas as coisas. Então, percorremos um longo caminho. E, no geral, foi isso para esta palestra. Espero que tenha achado útil como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 55. (Básica de Unidade, Entrada de mouse: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada em entradas de um mouse. Então já vimos entradas normais e, em seguida, um pouco de script de movimento. Agora vamos ver o que basicamente as entradas poderiam ser com um mouse. E vamos criar uma nova cena para isso, que vai ser L2. Esta é a entrada do mouse, do mouse. E, em seguida, é claro, também um novo script. Isso também vai ser chamado de taxa de entradas do mouse. Ok, vamos ligar imediatamente isso a um GameObject vazio, também chamado de entradas Desmos. Por que não? E depois centroide zeros 0000, só para meu próprio prazer desta vez. E vamos abrir o script de entrada do mouse e ver o que podemos ver. Então, primeiro de tudo, vamos passar pelos diferentes botões. Então nós temos entrada, ponto, obter botão do mouse para baixo. É quase como a Unidade. Ouça o que eu estava dizendo. E em vez de aqui, nós realmente temos que especificar o botão por inteiro. Então vamos ver o que são. Então depure o log de pontos e digamos apenas Watson 0, apenas para o inferno. E então vamos adicionar um a ele e três, por que não? E veja quais são. Então, Botão 1, 2 e 3. E vamos tentar isso rapidamente. Assim, o script é anexado ao GameObject. Então vamos ver. Então, se eu fizer um clique esquerdo é 0, então clique com o botão esquerdo é cerca de 1000. Clique com o botão direito um. E o botão do meio do mouse é sido também. Agora, eu realmente não tenho outro botão no meu mouse, portanto, botão três. Bem, isso não existe para mim neste caso. Se você tem um mouse que tem vários botões, então mais do que, digamos, o botão esquerdo, o direito e o botão do meio do mouse, então você pode realmente acessá-los também simplesmente aumentando o índice dado ano. Agora isso você provavelmente terá que tentar isso. E eu não sei o quão confiável é ao mudar de mouse para mouse. Então, deve ter cuidado se você for por este caminho. Mas sim, sim, e então teremos que olhar para alguma coisa. Então agora vamos tomar a posição do mouse, o que é muito interessante. Então a posição do mouse do ponto de entrada do log de depuração E isso é muito interessante. No entanto, a posição do mouse pode ser especialmente no início, um pouco confusa. Então vamos ver a posição do mouse em ação. Então vamos ver a posição do mouse toda vez que eu basicamente clicar no botão esquerdo do mouse. Então não vamos ter constantemente, a saída no console. Mas toda vez que eu basicamente clicar com o botão esquerdo, teremos isso. Então, se eu for para o meio da tela, nós temos a maior posição de 9635. 71 e diga, ok, vamos para o topo da tela. E lá temos 0 e depois 1000 e algo assim. Então vamos para a parte inferior esquerda da tela. Tente ir o mais longe possível doadores, e então temos 0,514. Então a idéia aqui é que o canto inferior esquerdo da tela é basicamente 00 e o canto superior direito da tela, se eu conseguir acertar, eu sim, basicamente acertei. É basicamente a resolução. Então, 000. E então aqui em cima é basicamente a resolução, no nosso caso, Full HD. Então 1920 por 10 ADP. E esta é a entrada normal do mouse, então a outra posição do mouse em vez. E podemos, no entanto, mudar isso. Então a questão é, bem, quero dizer, talvez eu queira as coordenadas reais do mundo. Então, se eu clicar aqui, eu quero 000 porque este era 000. Então, como faço para conseguir isso? E isso é um pouco enquanto eu não diria que necessariamente só confuso, pode ser um pouco estranho. Então isso é algo que eu também às vezes tenho que olhar para cima porque existem diferentes maneiras de que podemos basicamente projetar nossa posição do mouse em algo. E o que vamos usar é usar a câmera para isso. E ainda não falamos sobre a câmera. No entanto. E este é um método muito simples que podemos usar. Então podemos usar o script da câmera. Então ponto da câmera, isso simplesmente recebe o personagem principal desta cena em particular. E então vamos usar a tela de pontos para o ponto do mundo. E isso retornará um vetor de três, como você pode ver e requer uma posição. Então esta posição é que, em seguida, é claro, neste caso, a posição do mouse ponto de entrada. E isso, como você pode ver, transforma um espaço verde ponto em espaço mundial. Onde o espaço é definido como o sistema de coordenadas no topo da hierarquia do jogo. Assim, a posição da tela é exatamente o que é dado aqui em pixels. Então deixe a parte inferior esquerda 000, resolução de tela superior direita. Então largura vezes altura. E isso então basicamente transforma aqueles no espaço mundial. Então vamos ver o que podemos ver lá. Mais uma vez, teremos isso quando eu clicar com o botão esquerdo. Então vamos voltar para o 00. Isso é realmente negativo porque eu estava fora da tela. Então isso também funciona. Vamos tentar a mão realmente ficar dentro da tela. Sim, tudo bem. Então, como você pode ver, em algum lugar ao longo de 000, estamos em menos oito , menos, digamos menos nove, menos cinco e menos 10. Isso deve funcionar. Porque mais uma vez, em uma espécie de anos, então o meio estamos em 000 000. Quase acertei no meio exato. Isso é, isso é muito bom, na verdade. Então, lembramos que a câmera está na posição 0, 0 menos 10. Este é o lugar onde este menos 10 vem, porque estamos basicamente no avião onde as câmeras se sentam. Então, se eu fosse ajustar isso para menos 5 e clicar novamente, então, de repente, estaríamos em menos cinco. A posição Z simplesmente corresponde à posição z da câmera. Então isso é importante saber apenas para sua informação. Agora esta é a tela para o mundo ponto a ponto exatamente. Há também uma outra coisa. Isso pode ser bastante útil. Isso também é acessível através do ponto da câmera, e esta é a tela para ponto de visor. Este é o mouse input.txt, posição do mouse, é claro. E este, se olharmos para isto, vai ser o seguinte. Se começarmos de novo, então o viewport, se tentarmos ir 000, não estamos bem em 000. Vamos tentar acertar esta perna corretamente. Na verdade, vamos esclarecer isso. Esta é a janela de exibição. Portanto, isto é 000 000 000. A posição real era 0529 e, em seguida, a posição mundial em algum lugar em como menos 9 novamente. Então já vimos isso sábio, os zeros 0000. Bem, aqui em cima, se eu conseguir chegar ao topo é 11. Então isso é basicamente, como você pode ver, uma espécie de no meio é 55 como 0.5.5. Então a viewport é 00 na parte inferior e 11 no topo. Também pode ser útil para algumas coisas, mas essas são as principais mudanças. Vou também acrescentar rapidamente os comentários que aqui tenho. Então eu já preparei alguns comentários para cada um deles para que possamos realmente pensar sobre isso um pouco mais. Eu já expliquei isso. Como eu disse, a maioria dos vasopressores pode ser um pouco confuso porque temos que traduzir isso de específico, você sabe, do espaço da tela para o espaço do mundo e assim por diante. E há também vários outros. Assim como você pode ver se eu vou aqui. Então a tela, nós também temos uracil e podemos ir ver portas para tela e assim por diante e assim por diante. Para que possamos mudá-lo. Nós queríamos. É por isso que eu disse que às vezes eu ainda tenho procurá-lo porque no final do dia, sim, às vezes é assim que as coisas são. No entanto, a posição normal do mouse no canto inferior esquerdo, 00 no canto superior direito, tempos de largura adsorvidos com altura é o vetor. Para a visão de mundo rastreada representa as coordenadas em vez do mundo. Então, se clicarmos no meio do cartão, nós realmente não temos um cartão agora e nós podemos apenas testar isso. Por que não? Então, vamos puxar uma carta aqui. Por que não? Então podemos realmente clicar nisso. Então vamos colocar isso em, por exemplo, 0, três e tentar clicar no meio dele. E então devemos ser capazes de ver, vamos tentar e ficar realmente no meio disso. Eles vão 003, que, como você pode ver, e então negativo 10, e isso é o que eu estava mencionando antes. Assim, a posição z da coordenada corresponde à posição z da câmera usada. No nosso caso, usamos a câmera principal desta cena. Portanto, a posição Z está em 10 negativo. E viewport, como eu também disse, 00 no canto inferior esquerdo e um em um no canto superior direito. Então essas são algumas das entradas do mouse. E ler a posição do mouse pode ser muito útil para algumas coisas. Agora, para clicar, digamos que um objeto de jogo diferente, podemos realmente usar um método, uma maneira mais fácil. Não temos de usar isto. E isso é algo que vamos ver mais tarde também. Portanto, não precisamos verificar basicamente sempre a posição do mouse dentro deste nó. A posição do mouse pode ser usada para que um objeto de jogo específico siga o mouse. Agora isso é realmente algo que você provavelmente já deveria ser capaz de fazer. Então isso é algo que você pode querer descobrir. E sim, mas foi isso para a palestra de entradas do mouse aqui. Espero que tenha achado útil. Se houver alguma pergunta como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 56. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida na câmera principal. Então nós já vimos na última palestra nas entradas do mouse basicamente longe com, em que podemos tomar a posição do mouse e tipo de convertido em diferentes tipos de pontos. Então vimos os pontos do mundo. Então tela para crescer pontos e tela para visualizar PowerPoints. E isso dependia da câmera. Então essas são uma ou duas coisas. Por exemplo, a câmera pode fazer. Há também mais alguns. Posso mostrar-lhe rapidamente que não vamos criar um novo script para isto. Vamos apenas olhar para o tipo de script de entrada do mouse. Então camera.capture basicamente tem algumas coisas diferentes que podemos usar. E, na verdade, alguns, como você pode ver claramente, há um monte de coisas, você sabe, a largura de pixel, ortográfica, o que faz isso, tudo isso significa, podemos redefinir a câmera. Então, há um monte de métodos que podemos chamar também. Mas a maior parte disso geralmente não, não é feito por script. Nós realmente fazemos as mudanças dentro de nossa cena aqui. Então aqui nós podemos basicamente usar todas essas coisas que acabamos de ver no script. Então, há algumas coisas que podemos fazer. Então, há bandeiras claras. Temos apenas profundidade, não limpar e Skybox. E se passarmos o mouse sobre ele, como você pode ver claramente, há realmente uma explicação muito bem pensada para muitas dessas coisas. Então o que eu estou indo apenas rapidamente vai passar por essas coisas. Então, no geral, cor, quero dizer, que deve ser cores auto-explicativas, apenas a cor de fundo que temos. Máscara de abate basicamente é como você pode ver, quais camadas da câmera renderiza. Então, há camadas diferentes que algo pode ter aqui. E se você quiser algo ignorado, então, por exemplo, se formos para o ás de espadas, esta é a camada padrão aqui. E se pararmos de renderizar a camada padrão, então, como você pode ver na câmera principal e também no jogo, ela não está mais lá. Então isso é, por exemplo, algo que você pode ligar e desligar. A projeção é muito interessante. Então, se olharmos para isso aqui, tão ortográfico simplesmente significa que se eu mudar rapidamente na visão da cena para o espaço tridimensional, e eu diminuir um pouco. Então, com o botão direito do mouse, eu posso mover a câmera ao redor com o botão do meio do mouse, eu posso movê-la. Então você pode ver esse tipo de caixa que se estende para basicamente o plano infinito aqui. E esta é a projeção que está sendo feita. Portanto, é uma projeção um-para-um, sem perspectiva. Então, normalmente, talvez já tenha ouvido falar disso. O, Há uma perspectiva. Então coisas que são Neera, você atrairia mais do que coisas que estão mais distantes. Esta perspectiva simples basicamente, agora o ortográfico realmente tem tudo do mesmo tamanho. Só para mostrar, eu vou realmente dimensionar rapidamente isso, escala, isso até como 44. Então nós podemos realmente ver isso um pouco melhor. E então a câmera principal, se olharmos para ela novamente, e eu mudar isso para perspectiva, então, como você pode ver, agora, este cone de projeção é na verdade muito mais parecido com uma câmera normal seria, certo? Então, tipo. E não é realmente perceptível neste caso. No entanto, o objeto real aqui realmente não muda muito porque antes de tudo, é um sprite 2D plano. E também, nós não estávamos realmente precisando usar essa projeção. A projeção de perspectiva basicamente é necessária se você quiser um jogo tridimensional. Essa é a maneira mais fácil de pensar sobre isso. Há também um campo de visão neste caso, nós somos, como você pode ver, podemos fazer a projeção mais longe ou maior distante. Portanto, há realmente um f de v slider aqui. E há outras coisas que podemos fazer disso uma câmera física. Tenho que ser honesto, nunca brinquei muito com isso. E planos de corte simplesmente significa que onde está a distância quando as câmeras param a renderização? Então vamos colocar o tamanho ortográfico. Estamos na verdade também colocar no tamanho. Então, o tamanho simplesmente significa o tamanho da previsão como você pode ver. Então, fazer o menor basicamente renderiza uma área menor que lá dentro. Os planos de corte simplesmente significa, ok, quando isso pára de renderizar? Então, se eu colocar isso no negativo nove, então é muito, muito perto da câmera. Agora, isso não muda porque a projeção ortográfica é apenas, oh sim, isso é apenas uma superfície 2D. Se eu fosse colocar perspectiva e, claro, agora o, ele se foi. E se eu mover a câmera um pouco para cima e é enorme como você pode ver. Então essa é realmente uma boa maneira de mostrar a distância não importa para a escala do objeto. Só que a escala em vez de aqui realmente importa. E o plano de corte simplesmente significa que, à medida que isso se aproxima da câmera, agora estamos a 0,4 de distância da câmera, ainda lá. Mas se eu for no ponto menos 9, 7, então estamos 0,3 de distância. Então isso é apenas no limite. Onde é que ainda estamos a vê-lo? E então em 98, então agora é o único 0.2 longe da câmera, e então ele pára de renderizar porque ele está muito perto da câmera. Isto é basicamente o que este avião de corte aqui, meu controle. Então, se eu colocar isso em 1.1, então, de repente, como você pode ver, o cartão aparece novamente. Então estes são os aviões de corte. Vamos realmente fazer isso, podemos clicar nesta chave de bloqueio e, em seguida, qualquer que eu clique, o inspetor fica onde está. Então isso é realmente meio útil. A viewport é, como você pode ver, a indicação onde a tela e a visão da câmera serão desenhadas. Eu geralmente também sou algo que eu realmente não precisei muito. Vamos colocar o coração de volta. Onde está a câmera ou 10 negativo? E então este é, oh desculpe, eu sou, é claro que isso, isso faz sentido. Porque isso tem, continua sendo a câmera é claro 0, e então este está no negativo 10. Então lá vai você. Ok, agora podemos ver o ás de espadas de novo. E se mudarmos esta amina, podemos mudar isto. Como você pode ver, a tela simplesmente fica, quero dizer, negativo não seria a melhor idéia. Assim, a tela, como você pode ver, simplesmente fica menor e é realmente deslocado. E então este, nós, quero dizer, você pode torná-lo maior, mas não funciona. E então você também pode torná-lo menor aqui. E depois na direção y. E o mesmo acontece também. Como eu disse, geralmente não use o Viewport Ret tanto. O mesmo com quase todas as outras coisas. Especialmente porque geralmente eles não são realmente necessários para jogos bidimensionais. Há alguns, algo dito sobre a profundidade pode ser. No entanto, no geral, eu diria que esta é uma boa visão breve, certo? Então isso é só uma pequena olhada nisso. Comigo. Basicamente as principais coisas que precisamos para o desenvolvimento do jogo bidimensional neste caso, certo? Mas também a maioria das coisas na câmera realmente não precisa ser mudada. A única coisa que pode querer ser mudar o tamanho das câmeras. Então, o quanto ele realmente mostra, talvez também os planos de corte, embora um 0.310104, geralmente é suficiente. Então foi isso para esta palestra. Apenas uma breve visão geral para a câmera. Se houver perguntas como, sempre, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 57. (Básica de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada no método Get componente, que é um método central basicamente usado para obter os componentes de GameObjects. Então, o único exemplo disso que vimos mais ou menos foi a transformação. Mas temos acesso a este componente de transformação simplesmente usando dot transform e acessando-o através de um proprietário de propriedade particular, o objeto de jogo. No entanto, existem outros componentes aqui. Por exemplo, o renderizador de sprite, como veremos aqui, que foi capaz de mostrar basicamente uma imagem. Tínhamos roteiros específicos. Esses também seriam contados como componentes, ou por exemplo, que também vimos o componente da câmera. E podemos acessar aqueles de outros GameObjects dentro de nossos scripts. Enquanto isso, coloquei tudo dentro de pequenas pastas legais aqui. Então vamos criar uma nova pasta. Este vai ser L 14 obter componente. Agora l 13 está faltando porque na última palestra é claro, nós simplesmente olhou para a câmera principal. Não havia scripts associados a ele. E também queremos uma nova cena. Então vamos fazer um novo sênior também. L 14 recebe componente. E dentro dos roteiros, vamos primeiro abrir a cena. E então, em vez dos scripts, vamos criar dois scripts desta vez. Um deles vai ser o exemplo de script que você vai e você já pode abrir isso. E então vamos também criar outro script. E este é o script de componentes obtendo, em vez disso, isso é o que estamos chamando. Tudo bem, então dentro do nosso script de exemplo, vamos primeiro excluir o método de atualização. Não precisamos disso. E então nós vamos apenas declarar algumas variáveis agradáveis. Então, que tal um valor de teste inteiro de 100? E então um flutuador público, que é outro valor. O que é algo que alguém gosta, não sei, como 42.1337 camisas, claro. E então vamos também fazer uma câmera pública. A câmera como uma variável, que neste caso não é inicializar e vamos inicializar isso dentro do método de início fazendo Camera Principal. Então isso simplesmente salvará a câmera principal aqui. E como é muito claro, tudo aqui é público. Caso contrário, não será acessível através de outro script. Porque neste caso, ou melhor, sim, não é acessível a partir de outro script porque isso simplesmente. Teremos a aula de volta, mas veremos isso em breve. Vamos também pensar sobre dentro de nossos componentes obtendo. Vamos realmente fazer um objeto de jogo privado aqui. Então este vai ser o cartão. Vamos adicionar um cartão em breve. E sim, vamos realmente adicionar o cartão em primeiro lugar, e vamos adicionar algumas coisas a isso. Então, mais uma vez, podemos pegar o ás de copas aqui, colocá-lo, vamos posicioná-lo aqui, torná-lo um pouco maior para que possamos realmente vê-lo. E então aqui vamos pegar o roteiro de exemplo e colocá-lo no No Ás de Copas em si. Então, para o cartão. Também vou mudar o nome para tribunal porque é mais fácil. E nós também estamos assim o que poderíamos fazer, é claro, poderíamos pegar a câmera principal e colocá-la na Europa ou já mostrou isso que você pode basicamente colocá-lo no, dentro do próprio inspetor e configurá-lo assim. No entanto, no script, é claro que definimos a câmera de uma maneira que usa o método start. Então, isso também é bom. E então vamos fazer um, um GameObject vazio aqui. Este é o objeto de jogo componentes obtendo. Claro, mais uma vez centralizando-o apenas para que todos sejam felizes aqui. E, em seguida, obter os componentes é o script que queremos neste. E agora o que queremos é de alguma forma acessar esses valores de teste aqui a partir deste script. Então isso pode ser, você pode pensar nisso assim. Talvez haja um script de saúde que queremos mudar ou há um manuscrito que queremos rastrear, sabe, ou algo assim. Queremos simplesmente isto, estes valores. Queremos mudá-los. E também queremos talvez até mudar a posição do cartão ou algo parecido. Agora, como fazemos isso? Bem, em primeiro lugar, temos o cabo GameObject aqui. E vamos fazer isso como um campo serializado, só para que possamos ver o que está acontecendo aqui. Em vez do método start, vamos usar o ponto objetivo do jogo Find método, que nos permite, o que já vimos, que nos permite simplesmente encontrar um homem que é um objeto específico dentro da cena com o nome, neste caso cartão. Mais uma vez, é importante que o nome esteja escrito corretamente. E agora o que podemos fazer, nós encontramos este curso porque este é claro, apenas para esclarecimento, este objeto de jogo que vamos encontrar, este tem um script de exemplo anexado a ele como um, como um componente. Então podemos fazer agora é basicamente podemos, e não precisamos necessariamente disso, mas você pode dizer exemplo de script. Então esta é simplesmente uma nova instância do script de exemplo. Então isso funciona totalmente bem porque esta é uma classe normal que podemos ter uma variável normal off. E podemos basicamente inicializar e configurá-lo. Então, podemos atribuir isso para carros ponto get componente. Como você pode ver, isso já está destacado aqui. Então podemos dizer obter componente e, em seguida, este é o lugar onde algumas pessoas estão um pouco confusas. Temos este componente Get com os suportes basicamente angulares. E aqueles, claro, significam um genérico A. E as pessoas dizem “Não sei bem o que coloquei aqui. Bem, você coloca aqui exatamente o que você quer. Então, a partir dos componentes, então, se eu quiser o componente de script de exemplo, eu coloco em script de exemplo e, em seguida, é claro, precisa mudar, terminar isso com os parênteses aqui para significar que esta é uma chamada de método. E isso voltará então. Se o, este objeto de jogo realmente tem o componente que nós especificamos aqui, então ele irá retornar isso e simplesmente salvá-lo dentro de nossa variável. Agora, se eu olhar para trás, novamente, podemos ver que, claro, o script de exemplo é definitivamente um componente deste cartão. No entanto, há também o renderizador sprite e isso também é, por exemplo, o transporte. Mas há muitas outras coisas que não são componentes disso. O que, por exemplo, poderíamos dizer, bem, quero dizer, eu quero saúde agora. A única razão pela qual isso não funciona é por causa disso. Então, se eu tivesse uma variável de saúde aqui e eu dissesse, bem, me dê o componente da saúde. Poderíamos fazer isso. No entanto, é claro que isso não vai funcionar porque não há nenhum componente de saúde no local sobre isso, neste objeto de jogo específico. Então é assim que podemos basicamente dizer, ok, me dê esse componente, me dê esse componente, me dê esse componente. E essa é uma ferramenta muito útil. E uma das maiores coisas que comemos basicamente tem que fazer para obter componentes específicos de objetos de jogo. E uma coisa que é muito importante mencionar é que o, este carvão Get Component é muito, pode ser muito, muito intensivo em termos de uso de como CPU e tempo. Então este é um, este é um carvão caro. É por isso que você deve sempre, sempre, sempre usar este no método de armazenamento e armazenar isso em cache. Basicamente como este, e não continuar chamando get componente, que componente, cone obter componente no mesmo componente. Mas você deve sempre colocar isso em cache assim. E vamos apenas dizer debug dot log exemplo.bam valor de teste. Como você pode ver agora eu posso acessar aqueles porque este exemplo é simplesmente uma variável conhecida do tipo script exemplo. E esta é uma aula normal. Podemos pensar nisso como uma classe completamente normal. E depois podemos copiar isto. Eu também posso dizer outro valor. E então, por exemplo, a câmera. A câmera, quando a câmera, sim, lá vai você. Então isso funciona totalmente bem. E se começarmos isto, o que vamos ver é um 142 e nulo. E agora vem a pergunta: Espere, por que isso é nulo? Porque a câmera está ajustada aqui? Bem, a razão pela qual isso é não, é por causa da ordem de execução do script. E isso é algo que vamos dar uma olhada quando olharmos para algumas das configurações. Mas, em geral, a ordem de execução do script é que, claro, porque temos dois scripts no ano 1, um desses scripts tem que ser executado antes do outro, certo? Então, porque não podemos executá-los em paralelo, especialmente pense nisso assim. Temos 120 scripts. Quero dizer, não podemos executá-los em paralelo com scripts seria possível em teoria, mas isso ainda não está acontecendo. Então, há algumas coisas que podemos fazer para basicamente garantir que as variáveis foram definidas. Podemos, em vez de usar o método str, podemos usar o método de espera, porque o método de espera sempre é chamado antes do método de início. E isso simplesmente garante que a variável da câmera foi definida. Então vamos tentar isso e ver se isso ainda nulo ou se temos realmente nó mestre. Agora a câmera principal está ajustada e todos estão felizes. Então isso é muito legal. E daqui para frente, o que você também pode pensar é, bem, na verdade, o que eu quero é eu quero, eu quero mudar a posição deste carrinho. Bem, nós podemos fazer isso. Podemos dizer transporte. Então vamos salvar a transformação e dizer cartão Transformar, Transformar. E então, em vez de simplesmente para que pudéssemos fazer isso de duas maneiras. Poderíamos dizer cartão de ponto transformado. Para que possamos fazer assim. No fundo. Esta transformação não faz mais nada. Em seguida, chame o método get componente com transformação. Então isso é basicamente intercambiável. Quando fizermos isto. Lá vai você. Então isso é intercambiável, exatamente a mesma coisa. E faz exatamente o mesmo. Sim, basicamente tem o mesmo resultado. Então o que podemos fazer então é, por exemplo, dizer acordes transformar posição ponto, apenas produzir a posição. E então no meio aqui, vamos mudar a posição para, digamos um novo vetor 3, que é algo como, eu não sei, como um, F para F e F. Sim. Certo. Então, vamos apenas mudar a posição desta transformação central que obtivemos com o componente Get também. Então vamos realmente fazer isso assim. Então também possível, o mesmo que obter componente. Componente é e vamos ver se isso funciona. Se o tribunal mudar de posição. E como você pode ver, o cartão mudou sua posição, 2, 1, 2. E se olharmos para a saída, você também pode ver que primeiro a posição foi 03 e, em seguida, a posição foi 12. Assim, o método componente é uma parte central deste design baseado em componentes que Unity tem inerente a si mesmo. E é simplesmente possível, com este método, obtém basicamente todos os componentes de um determinado objeto de jogo, acessar suas variáveis, e também, bem alterá-los se necessário. Sim, esta é realmente uma maneira bastante fácil de acessar diferentes componentes de diferentes scripts. No geral. Como eu disse, este é definitivamente um componente central e todos os outros componentes que estamos aprendendo podem ser acessados basicamente assim. E o melhor é, porque isso é o que já vimos com a câmera, por exemplo. Todas as coisas que vemos. Então, todas as coisas específicas que podemos ser capazes de mudar aqui, o tamanho ou para o cartão, o script de exemplo, o valor de teste para outro valor que a câmera. Esses também podem ser modificados por exatamente outro script depois de termos obtido o componente de lá. Então obtenha componente, incrivelmente útil, ferramenta incrivelmente importante para nós em nossa caixa de ferramentas para basicamente trabalhar com Unity, certo? Mas foi isso para esta palestra. Como sempre, espero que tenha achado útil. Esse foi, de facto, um tema bastante importante nesta altura. Mas, no geral, acho que correu muito bem. E, no entanto, como sempre, se houver alguma pergunta, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 58. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em prefabs e como instanciá-los. Então, em primeiro lugar, o que são prefabs? Nós vamos prefabs são basicamente GameObjects que são, portanto, um para replicação, por assim dizer. Então, há uma espécie de modelo, por assim dizer, a partir do qual podemos criar novos objetos que são muito parecidos com esses. E vamos criar uma nova cena. Primeiro de tudo, mais uma vez, assim visto 15 chamado prefabs. E então vamos começar isso imediatamente. Uma nova pasta aqui, L 15 prefabs. E só precisamos de um guião. E chamaremos isso de “gerador de cliques”. Porque o que vamos fazer é com isto. Uma vez que clicamos no botão do mouse, vamos cisnar em um novo cartão. Então isso vai ser muito interessante. Então vamos apenas dizer que temos os cliques Warner aqui. Clique em gerador. Mais uma vez na posição 0, 0, 0. Claro que sim. Também certificando-se de que os componentes estão lá. E então vamos criar um novo cartão aqui. E nós vamos colocar isso em 000, 000 também. E nós vamos realmente fazer isso apenas cerca de duas vezes o tamanho. Na verdade, vamos mantê-lo em 11, um com o tamanho. E então podemos pensar em fazer algo com isso mais tarde. E o que podemos fazer agora é basicamente dizer, bem cartão, então este é agora um objeto de cartão. E como fazemos um pré-fabricada com isso? Bem, a maneira mais fácil é simplesmente pegar esse objeto certo? Uma vez que basicamente definimos tudo, como deve ser. Então este é o posicionamento padrão de um cartão. Então nós dizemos, ok, vamos apenas arrastá-lo aqui para pré-fabs. E agora, como você pode ver, isso fica azul. E agora aqui em baixo temos um ativo pré-fabricada. Então, a idéia é que agora temos esse tipo de modelo e todos os valores diferentes que definimos aqui ou dentro deste prefab. Agora também podemos abrir este prefab e vê-lo em vez deste tipo de modelo exibido, tipo de tela pré-fabricada e pode alterá-lo aqui. Então podemos mudar algumas coisas como virar o, virar a foto ou podemos movê-lo. Ou também podemos adicionar componentes. Por exemplo, agora não vamos fazer isso. Para voltar atrás, podemos simplesmente pressionar a seta para trás lá. E neste caso particular deste prefab, eles estão conectados. E você pode ver isso basicamente pelo azul. Sublinhe aqui e há algumas coisas que são marcadas como se fossem ousadas. E a idéia é que uma vez que mudamos algo, podemos, por exemplo, dizer que, como você pode ver substituições para cartão em cena, o que isso significa é que você basicamente muda, você pode mudar algo aqui. Então eu não sei a rotação. Quero dizer, esta rotação não faz sentido. Então esta rotação, por exemplo. E com uma tecla de seleção, podemos selecionar imediatamente o prefab dentro de nossos projetos. Também podemos abri-lo imediatamente. E agora, o que isso faz é substituir o cartão. O que isso significa? Bem, se olharmos para este, nada mudou. Isso basicamente sobrescreve. Diz: “Ok, estamos pegando esses valores em vez desses valores aqui. Há algumas coisas que podemos fazer. Então, com um pré-fabricada, como você pode ver, podemos desempacotá-lo e empacotá-lo, simplesmente desanexá-lo do prefab. Podemos selecionar o ácido. Há algumas coisas que podemos fazer com prefabs. E o que mais importante é basicamente que podemos, agora aqui podemos entrar, entrar nele de novo, como vocês podem ver. Mas a coisa mais importante para a pré-fabricação que podemos fazer é criar novos objetos, todos esses. Então vamos apagar isto dentro da nossa cena real. E o prefab aqui, aquele que vamos criar novos cartões. E vamos fazer isso alterando o script spawner clicker aqui. E dentro dele, teremos um GameObject privado porque sempre criamos novos objetos de jogo chamados de prefab court. Este vai ser um campo serializado, muito importante para que possamos realmente acessar isso porque não há outra maneira de acessarmos. Não podemos usar o ponto de encontrar GameObject neste caso porque, bem, não há nenhum cartão em vez de R. E meio que vendo aqui. Então temos que fazer isso de outra maneira. E a maneira como vamos fazer isso é que vamos definir isso manualmente. Então, vamos dizer “obter a maioria do botão para baixo 0”. Espero que se lembre que este era o botão esquerdo do mouse. E o que vamos fazer é criar um novo objeto de jogo aqui. Então novo cartão é igual a instanciar. E eu vou dizer cartão pré-fabricada com esta transformação ponto-ponto. E o que isso faz é que se passarmos sobre isso, devemos realmente ser capazes de ver, como você pode ver, isso leva uma transformação como um pai. Então este novo objeto de jogo que vamos criar com a chamada de método Instanciate vai ser imediatamente atribuído o pai de cliques Bonner. E então nós também, porque nós temos a nova variável de cartão aqui, nós podemos mudar algumas coisas lá imediatamente. Em breve, novo cartão ponto transform.py missão. E o que vamos fazer é que vamos realmente fazer desta uma posição aleatória. Então vamos dizer intervalo de pontos aleatórios entre algum lugar entre 10 negativo, digamos e1 mais 10. E o y também vai estar em algum lugar entre um 10 negativo e 10. Na verdade, vamos baixar para sete, porque não sei. Não tenho 100% de certeza de onde estão as fronteiras. Mas veremos isso em breve também. E sim, podemos, claro, também mudar todos os tipos de outras coisas. Se o cartão, agora, pensando sobre a última palestra com o componente Get, é claro, também podemos chamar get componente aqui. E se houver algum componente particularmente importante neste acorde, poderíamos, claro, também defini-los. Então, se isso tivesse um script de integridade, por exemplo, poderíamos mudar as coisas no script de integridade como você pode ver. Então, por exemplo, nós poderíamos mudar a saúde se isso estivesse no cartão, e assim por diante e assim por diante. Então esta é uma espécie de uma maneira de inicializar alguns valores de certos objetos. Certo? Agora, é muito importante que este tribunal pré-fabricada, claro, tem que ser definido, e, portanto, temos que realmente arrastar isso aqui. Esta é a única vez que temos de arrastar alguma coisa para lá. Se estamos usando prefabs e estamos criando objetos a partir deles, então isso tem que ser uma espécie de coisa mais ou menos manual. E vamos ver se isso funciona. Então, se eu clicar na tela, um novo cartão aparecerá. E se olharmos para este clone de cartas de um ano, e podemos ver que ele realmente aparece como um filho desse gerador de cliques. Então algumas cartas, porque sete é definitivamente um pouco longe demais. Então este é provavelmente mais como cinco é provavelmente o, então cinco provavelmente seria melhor. Então vamos voltar aos cliques Boehner e dizer, ok está em qualquer lugar de cinco a cinco negativos. Isso também faz sentido porque a câmera principal, claro, o tamanho é definido para cinco. Então isso realmente confere em um monte de desperdício. Então, vamos apenas clicar algumas vezes. E como você pode ver, agora estamos recebendo um conjunto de cartas, apenas geradas aleatoriamente e há mais e mais cartas e estamos apenas gerando-as como loucos. Mas funciona, funciona muito bem. E esta é uma maneira na qual podemos basicamente criar novos objetos, fazê-los surgir dentro do nosso jogo. E então, é claro, se eles têm scripts específicos que são executados, então eles podem ser executados sem quaisquer problemas, sem que tenhamos que fazer nada particularmente louco lá. Então, sim, essa é basicamente a idéia de prefabs. Eles são ferramenta incrivelmente útil para ter um modelo a partir do qual podemos, em seguida, criar novos objetos de jogo. Então, alguns exemplos disso podem incluir algo como um tipo até mesmo uma mensagem de texto. Você poderia ter prefeitos assim. Você poderia ter Prefabs para inimigos. Este é um dos exemplos clássicos, certo? Teria um pré-fabricada inimiga e, em seguida, um gerador inimigo, por exemplo, e simplesmente estragando-os enquanto você vai. Agora uma coisa que é mencionar é que o método Instanciate é, naturalmente, muito intensivo de CPU ou muito caro novamente também. Então há algo chamado pool de objetos que você poderia fazer. Assim, o início do jogo, você poderia criar como um 1000 objetos, colocá-los em algum lugar no mundo do jogo onde eles não fazem nada e, em seguida basicamente, apenas definir seu posicionamento e talvez habilitar algumas coisas sobre eles. Mas no geral, isso é algo que não é, não vamos nos preocupar agora. Eu só queria mencionar isso, que o método Instanciate, como vimos da última vez com o método Get componente, realmente não deve ser como loucamente usado. Então você não deve criar como 100 mil novos GameObjects como cada quadro ou algo louco como isso. Portanto, seja muito cauteloso, especialmente se você tentar usar para loops dentro do método de atualização. Isso é algo que pode não funcionar como você queria. Mas sim, isso foi basicamente para criar novos objetos de jogo com prefabs. Como sempre, espero que tenha achado útil. E se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 59. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada nos sprites e especialmente nos espectros aqui. Então nós vimos, nós também já adicionamos ao ás de copas como um sprite. E eu disse que vamos olhar para isso mais tarde e agora é a hora. Então, para isso, eu realmente abri o L4 para obter scripts de componentes para que possamos ver o sprite real dentro da exibição de cena aqui visualmente. E se fizermos mudanças nisso, então podemos basicamente não. Certo, o que está acontecendo? Por que está acontecendo e sim. Então, primeiro de tudo, vamos passar de cima para baixo. O tipo de textura de Sprite é aquele que basicamente vamos usar exclusivamente dentro deste curso. E como você pode ver, a questão aqui é para que essa textura será usada? Exatamente, vai ser um sprite. Então este é o que vamos usar. Os outros realmente não nos interessam no momento. Pelo menos não para este curso. Em seguida, o modo sprite. Então, o modo sprite é muito interessante. Temos um único, múltiplo e polígono. Tão solteiros e múltiplos outros que são interessantes para nós. Simplesmente significa que esta é uma textura única. Este é um único sprite. Esta apenas uma coisa e múltipla, que é algo que vamos olhar mais tarde abaixo a linha é onde temos várias imagens específicas em um arquivo para que possamos basicamente colocar em um arquivo. E então podemos separar isso através do Sprite Editor, que vamos dar uma olhada na próxima palestra mais detalhes, pixels por unidade. Então, o que isso significa? Bem, como você pode ver, quantos pixels no sprite correspondem a uma unidade no mundo. Esta é a razão pela qual nós mais ou menos temos que escalar esse acorde para que ele realmente se encaixe. Porque o cartão realmente é, Eu acredito que a imagem é 64 por 64 pixels. Então o que podemos fazer é definir para 64. E se eu me candidatar, o que você verá é que o cartão agora ficou muito maior porque agora é 64 pixels para uma unidade de espaço. Então, quanto menor esse número, basicamente maior a imagem real fica. Mas geralmente, depende de quão grande é a imagem. Normalmente eu acho que isso deve ser colocado, vamos olhar rapidamente este ano para que eu possa clicar em todos os lugares. Normalmente o este número deve estar em algum lugar em torno de quão grande as imagens, especialmente se é um quadrado, que é o melhor tipo de malha, tipos de sprites muito gera. Eu tenho que ser honesto, isso é algo que eu não estou 100% familiarizado com. Há na minha mente agora. Não há muita diferença lá. Extrude bordas, quanto espaço vazio nos deixa em torno dele, certo? Então isso realmente é importante. Veja, em uma malha gerada agora para nós, não é tão importante. O pivô, o pivô apenas irá alterá-lo para, por exemplo, o canto superior direito e aplicar isso. E como você pode ver, de repente isso se move para baixo. Porque mesmo que o cartão em si, se desbloquearmos isso novamente, a corrente em si ainda está na mesma posição agora. O pivô desta imagem em particular, o sprite não está mais centrado, pode ser, pode ser realmente útil. Eu costumo deixá-lo no centro e mudar o objeto do jogo em si. Isso é melhor. Nós vamos gerar física, como você pode ver, é simplesmente gera uma forma física padrão para que possamos ter, isso pode ser ligado ou desligado. Quer dizer, depende se você precisa ou não de física. Essas são algumas configurações avançadas aqui. E alfa, é claro, garante que se você tem um PNG, que o Alpha é então basicamente levado em conta. Nós também podemos olhar, vamos trancar isso de novo. Lá vamos nós. E também podemos ignorar algumas das coisas. Assim, o alfa pode ser não-transparente, por exemplo. E, e agora não é transparente e podemos apenas dizer, bem, que seja. Então, o Alfa neste caso não é transparente. Mas onde você quer que isso seja transparente. E há outras coisas que podemos fazer. Ignorar o arquivo PNG Gamma, podemos habilitar ler e gravar dados de pixel para que possamos realmente mudar com esta imagem em particular. E sprite pode ser útil. Embora isso seja algo que onde você tem que ter cuidado , porque então você pode basicamente também seus sprites para sempre. E você também pode, em teoria, gerar um mapa mental aqui, que pode ser algo que você quer. Sim, modo rap e modo de filtro. Então o modo é basicamente quando você tem um, vamos fazer isso. Se tivermos um, adicione isso como uma textura, então o modo de repetição vermelho simplesmente repete essa imagem se a colocarmos em algum lugar. Então, se a colocássemos em uma superfície e não fosse grande o suficiente, então simplesmente repetiríamos. O plano faria com que fossem aqueles que eu não sei por que ele sempre estende os avançados que eu aplico. Então isso é meio que uma coisa interessante. Espelho por eixo geralmente deixá-lo na braçadeira que soma o suficiente, isso é bom o suficiente. E então o ponto que são as coisas interessantes para o modo de filtro, porque vimos que o bi-linear é aquele com o qual começamos. , se eu me candidatar, o que vamos ver é que, de repente, isto fica muito, muito embaçado. E a razão é porque isso é pixel art. E bi-linear é basicamente mais ou menos, é suaviza as bordas. E nós, neste caso, não queremos bordas suavizadas. Trilinear deve torná-lo não necessariamente pior, mas basicamente o mesmo endpoint simplesmente significa que não há filtro na hashtag, nenhum filtro. E isso fará sua arte de pixel. Você é linda. Aqui estão algumas configurações interessantes, basicamente que você pode usar para vitórias uma vez que este é publicado. Portanto, o tamanho máximo simplesmente se refere ao tamanho máximo. Então, se eu fizer 32, por exemplo, como você pode ver, de repente, oh meu lambda que não é, eu não posso nem ver o que está acontecendo. Se eu colocá-lo em 16 mil, é afiado como uma batata frita. Mas eu acho que mesmo 1022 ou 128, mesmo que seja mais do que suficiente. 64 ainda é suficiente porque isso ainda é suficiente para ter tudo lá em cima sobre algo como sim, então então no meio provavelmente vai ser suficiente. Também temos um algoritmo de redimensionamento. Você pode alterar o formato disso. Isso é alterado e você também pode alterar a compactação. Isto basicamente é essas configurações aqui podem ser alteradas. Por exemplo, talvez se você tiver um jogo para celular, o que você gostaria é, bem, na verdade vamos fazer uma baixa qualidade e fazer alguns bits a menos, por exemplo. Então você pode mudar, oh, vamos fazer este 32 bits. Ou podemos dizer, bem, alfa oito, então isso é, e agora tudo se foi. Ou apenas mantê-lo no automático. Isso também funciona. Há algumas coisas que podemos mudar o seu, porque talvez em certos locais onde queremos publicar este jogo, nós realmente queremos que o tamanho seja menor. Então, em um PC, há razão para não ter o maior tamanho para os arquivos, porque se um jogo é ou não três gigabytes ou oito gigabytes. Não importa para no PC, geralmente em um telefone. Isso é uma grande diferença, certo? Então a diferença entre um jogo em um telefone que tem nosso, digamos como 250 megabytes versus como quatro gigabytes é enorme porque enquanto os telefones têm nos últimos tempos ficaram maiores em termos de espaço de memória, ainda quatro gigabytes para, Digamos que um jogo casual é demais. Então isso é basicamente o que, este é quatro. Então este seria o padrão. E, em seguida, aqui você pode substituir algo para particular, para basicamente particular BuildSettings. Mas, mais uma vez, isso é algo que também é um pouco mais avançado. Eu não me preocuparia muito com isso. Apenas certificando-se de que se a sua imagem está embaçada, se o seu suor está embaçado que pode ser o tamanho máximo que você colocou. A compressão também pode ter a ver com isso. E também o modo de filtro pode ser a causa do problema, certo? Mas foi isso para a rápida olhada na textura aqui neste modo. A próxima coisa que vamos dar uma olhada é o Sprite Editor deste como basicamente uma nova janela. E com isso, também veremos o modo sprite de múltiplo. Espero que tenha achado esta palestra útil como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 60. (Noções básicas de (Unity de (Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada no Editor Sprite. E com isso, nós também vamos importar os vários cartões basicamente. Então, vários sprites ao mesmo tempo. Tivemos o ás de copas aqui como uma textura singular ou sprite há muito tempo. E agora vamos dar uma olhada nele, o próprio mapa de mosaico. Então vamos, eu só vou copiar isso aqui. Então vamos arrastá-lo para lá. E como você pode ver, este é Cards grande mapa mosaico. Atualmente, se eu fosse apenas colocá-lo aqui, é um arquivo com vários cartões, como você pode ver. E, obviamente, isso não é o que queremos se importássemos algo, queremos mais de um cartão porque este é agora um único modo. Então vamos colocar isso em vários modos, mudar os pixels por unidade para 64. E vamos esperar que antes de tudo aplicar isso, também fazer este ponto muito importante, o modo de filtro para que ele fique bem. E então vamos entrar no Sprite Editor. Então, se abrirmos isso pelo editor, podemos ver se eu apenas obtê-lo da outra tela aqui, que nós podemos basicamente fazer algumas coisas aqui. Podemos ampliar e diminuir o zoom com o botão do mouse. Clique com o botão direito do mouse, Faz-nos mover isto. E se pressionarmos o botão esquerdo, então temos o tipo de seleção. No entanto, se pararmos a seleção, então paramos de pressionar o botão esquerdo do mouse. E como você pode ver, ele cria uma espécie de sprite aqui. E também podemos mudar isso. Podemos torná-lo maior ou menor. E isso basicamente representa um sprite nesta imagem em particular. Agora, há algumas coisas que são realmente agradáveis. Então, aqui em cima, podemos olhar para algumas coisas. Cliente como, nós não vamos realmente olhar para isso. Então este é um ter um esboço personalizado. Queremos o Editor Sprite neste caso. E o Sprite Editor pode emendar, o que é muito bom. Então podemos fazer automático. O que isso faz. Se eu disser fatia, como você pode ver, ele criou esses diferentes spreads aqui automaticamente. Então isso é muito bom que, isso funciona. Vamos reverter. Então podemos reverter e agora não há mais sprites presentes. Também podemos ter diferentes tipos. Então podemos dizer por, por tamanho. E podemos, porque sabemos que estas cartas são 64 por 64, diríamos, ok, cortá-las 64 por 64. E então, como você pode ver, se eu não mover isso, todas as cartas agora também estão em um sprite, mas é um pouco maior. Tem um pouco de espaço nas laterais para que pudéssemos fazer isso. Ou se revertemos mais uma vez, também podemos fazer isso pela contagem. Então, se sabemos que, por exemplo, isto é, isto seria 10, 11, 12, 13, 14. Então sabemos que há 14 linhas e quatro colunas. E nós podemos cortar, isso é realmente o caminho errado, é claro, 144. Lá vai você. Agora, vogal. Agora funciona. E isso também funcionaria. Então, há algumas maneiras de fazermos isso. Claro, também podemos mudar o pivô. Há algumas coisas que podemos fazer aqui. Há algum estofamento, algum deslocamento. No entanto, eu acho que o tamanho neste caso faz mais sentido aqui. E então nós temos basicamente tudo, se eu chegar aqui ou 56 cartas neste caso, porque nós também temos duas maneiras diferentes de este é um, um carrinho vazio ou nós também podemos ter isso como o fundo para pairar. Isto é, acho que nos referiu ao fundo. Então, sim, isso é muito legal. Então, vamos nos inscrever. Mais uma vez, só para mencionar isso, esses são os cartões dos recursos renais. E uma vez que aplicamos isso, podemos ver dentro do nosso projeto, bem, este ainda é apenas um pacote de título aqui, mas vemos esta pequena flecha. E se expandirmos isso, você pode ver que cada um desses individuais é um acorde. Então, se, por exemplo, também quisermos tirar o ás de copas, poderíamos fazê-lo fazendo isso. E se nós tamanhos até quatro vezes quatro, então, como você pode ver, é literalmente exatamente o mesmo tamanho. Porque nós vamos, em vez de ser uma carta singular, agora é parte deste pacote. E a grande coisa sobre isso é, e vamos olhar para isso na próxima palestra com um pouco mais de detalhes, o renderizador de sprite. O que podemos fazer agora é basicamente dizer que eu quero mudar isso e eu quero mudar o sprite bam, e então o cartão mudou. E nós vamos, como eu disse, nós vamos olhar para isso na próxima palestra com um pouco mais de detalhes o que a renderização sprite tem a oferecer. Mas isso foi basicamente para uma breve visão geral do Sprite Editor. Agora, há mais algumas coisas, é claro, que isso pode fazer. No entanto, por enquanto, isto será definitivamente muito mais do que suficiente para nós. E esta ferramenta incrivelmente útil, porque agora não temos necessariamente que ter cada um dos nossos sprites independentemente ou em arquivos separados, mas podemos ter todos eles em um arquivo e cortá-los manualmente, por automaticamente podemos fazê-lo por contagem ou mesmo por tipo de quantas linhas e quantas colunas. Certo? Então foi isso para esta palestra. Espero que tenha achado útil como sempre. Se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 61. (Noções de Unidade+ OS Renderer de sprite: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nele, o renderizador de sprite. Então este é outro componente. E para isso vamos primeiro criar uma nova cena mais uma vez. Então este é 18 sprite renderer. E, em seguida, também crie uma nova pasta aqui. Deixe o renderizador de sprite. E o script que vamos criar dentro daqui será chamado de aparência de renderizador de sprite. Claro que o nome aqui é mais ou menos, escolhe. Se você quiser um nome diferente, você pode, claro. E vamos pegar um novo cartão aqui. Vamos pegar um cartão deste, nosso novo mapa de azulejos. Basicamente, uma vez que você pode torná-lo quatro por quatro, Vamos realmente colocá-lo no meio da tela neste ponto. E vamos renomear isso para cartão porque isso é como um nome muito melhor e adicionou a aparência do renderizador de sprite a ele. E sim, vamos ver o que podemos ver nesta coisa em particular. Então, primeiro de tudo, o renderizador de sprite é um componente simples. Então, podemos basicamente salvar renderizador de sprite privado e chamar isso de renderizador de sprite. Renderizador de sprite. Lá vai você. E podemos obter isso fazendo no método inicial propagação r1, r2 é igual e, em seguida, este ponto get componente. Então também podemos obter componentes do GameObject em que estamos atualmente. Então, onde este script está anexado. E então vamos chegar ao renderizador de sprite. Como eu disse, esta é uma idéia muito inteligente para fazer isso. E nós deveríamos basicamente sempre fazer isso. Agora vamos pensar em outra coisa. Também teremos uma matriz de sprite privada chamada sprites. E vamos fazer deste um campo 0, é claro, para que possamos acessar isto através do inspetor. E se dermos uma olhada nisso agora, e podemos ver é que temos uma lista. Veja, isso está vazio. Mas o que podemos fazer é pegar no mapa de blocos de sprite e arrastá-lo para cá. Agora, como você pode ver, isso não funcionou porque nós excluímos este elemento de matriz. O que temos que fazer é que temos dois. Felizmente, não temos que levar tudo um por um. Podemos ver isto aqui em cima. Então, no canto superior direito do inspetor, podemos olhar para isso. Então podemos basicamente selecionar tudo. Então, se selecionarmos uma das coisas, então segure, mude e selecione a parte superior e tudo no meio é selecionado. E se movermos isto para cá, e como podem ver, agora encher-se-á de todas as nossas cartas. Então isso é muito bom e muito útil. E agora, bem agora, de repente, o que temos é que temos uma lista de sprites que podemos acessar como um array. O que poderíamos fazer com isso? Bem, o que poderíamos, por exemplo, fazer é dizer, bem, no começo, eu quero esse renderizador de sprite e o sprite que está dentro dele. Então este é o sprite que, que está sendo exibido. Então, a renderização do sprite, eu quero que este seja um dos sprites do carrinho. Então, por exemplo, eu poderia dizer, bem, eu quero que isso seja. Os tribunais, mas no índice 4, ou eu poderia dizer, bem, eu realmente quero que isso seja uma corrida aleatória, random.randrange começando de 0 porque, claro, 0 é o primeiro índice todo o caminho até tribunal espalha comprimento ponto. Então, e então se você olhar para isso, o máximo é exclusivo. É por isso que não precisamos fazer comprimento menos 1 porque comprimento não é tomado, mas apenas o comprimento menos um é o intervalo. Então o mínimo é inclusivo e o máximo é exclusivo, apenas para que, você sabe, agora, se começarmos isso, devemos ver que este cartão realmente muda seu sprite OnStart. Vamos ver se isso realmente funciona. E lá vai você. Agora é o seis de paus, eu acho. E vamos fazer de novo. Agora é o cinco de paus. Não tenho certeza, na verdade. Três de copas eles vão. E mais uma vez, só para o inferno de discussão, acho que seria o sete de diamantes, certo? E agora, isso é muito legal. Podemos fazer mais duas coisas. Então o que vamos fazer é pegar a entrada aqui e obter keydown, keycode dot espaço. Então vá para a barra de espaço. O que vamos fazer é que o sprite de ponto do renderizador de sprite é basicamente exatamente isso. Então podemos copiar isso. Mais uma vez, isso seria agora, por exemplo, algo que nós colocaríamos em um método diferente, bem, apenas diferente aqui. Então isso seria uma mudança para sprite aleatória. Não precisamos necessariamente fazer isso, especialmente porque este é apenas um pequeno exemplo. Mas porque temos basicamente uma citação duas vezes, há um bom ponto de fazer isso. Porque agora se você olhar para isso agora nós vamos ser como, ok, o que acontece se eu pressionar a barra de espaço oh, mudou para sprite aleatório. Certo, isso faz sentido. E isto é muito mais legível do que se eu tivesse isto aqui. Porque definitivamente temos que dividir isso. Podemos ok, aleatório, ok, então a soma do aleatório, ok, eu, eu, eu pego um sprite aleatório, mas este, eu acabei de ler o nome do método real e é como, ok, isso faz sentido. Então obter keydown, keycode dot return. Então esta seria a chave de retorno. Nós também podemos apenas mudar outro e nós podemos, nós podemos, nós não temos que necessariamente voltar. Vamos fazer, vamos realmente fazer. Vamos fazer o C afiado, tecla C. Porque o que eu quero fazer aqui é que eu quero que o renderizador de sprite, cor do ponto do renderizador de sprite mude. E isso pode ser feito usando a cor de ponto aleatório S, H, v. Isso simplesmente retorna uma cor aleatória que você vai, o que é muito legal. Então vemos que podemos realmente mudar a cor dele. E com o espaço, podemos mudá-lo para um cartão diferente. E se eu olhar para este renderizador sprite novamente, mais uma vez, todas essas coisas aqui. Então todos esses campos estão basicamente disponíveis através do script. Apesar de claro, bem como a cor aqui. Virando este x e y, podemos fazer isso também. O modo Desenhar, a interação da máscara, a dinâmica apesar do ponto de classificação. Então a camada laranja é algo que é muito importante. Então, se tivermos este casaco, copie-o pressionando Control C, Control V para colá-lo. Então agora temos um novo cartão aqui. E a camada de ordenação simplesmente determina onde este acorde em particular está. Então, se mudarmos isso só por causa da discussão aqui. Então quatro de copas, agora, ás de copas é agora camada é 0. Este é mais tarde 34. Portanto, é mais alto, por isso está acima dele. E se eu reduzi-lo, então, como você pode ver, isso muda também. Então isso é algo a considerar e também ter em mente. Muito importante. Mas o suficiente disse, agora, vamos realmente tentar isso aqui e ver se isso funciona. Então temos o nosso cartão aqui. E agora isto escolheu uma carta aleatória e eu acredito, na verdade escolhi esta. Podemos realmente tentar isso pressionando a barra de espaço. Acho que foi um sorteio de sorte. Acho que sim. Então. Sim, podemos escolher, podemos colocar a barra de espaço e como você pode ver, ele escolhe um cartão aleatório lá dentro, que é muito, muito legal. E se eu pressionar C, então ele muda sua cor aleatoriamente também. Oh, isso foi muito preto. E então, como você pode ver, lá vai você. Então muda a cor aleatoriamente também. E se eu pressionar os dois ao mesmo tempo que os dois mudam ou posso ter uma festa de rave. Vamos lá. Eu gosto, isso é muito legal. Então isso é uma coisa muito legal. O renderizador sprite, principalmente, Eu acho que na minha experiência, o sprite que definitivamente muda um pouco. Portanto, isso é algo que é muito importante. A idéia de alterar o sprite e salvar basicamente todos esses sprites dentro de um em vez de um array. Isso também faz muito sentido. A razão pela qual eu escolhi a área aqui é porque, claro, uma vez que definimos de uma vez, nós realmente não precisamos mudá-la. E o número de spreads não muda. Ou melhor, mesmo que mude , não muda durante o jogo. Então, enquanto o jogo está em execução, não precisamos mudar isso. Não temos que ter uma lista dinâmica aqui. Basicamente. É por isso que um é um array, funciona bem. claro que você também pode fazer uma lista. Isto não importa. Qualquer um. Um desses seria bom, certo? Mas isso seria para esta palestra olhando para o renderizador sprite. Claro, há mais algumas coisas sobre isso, mas como de costume, neste momento, este é um ponto de partida muito bom para o renderizador sprite pode ser realmente útil para alterar o sprite e também a cor. É bom olhar para isso, certo? Ok, então foi isso para esta palestra. Como sempre, espero que tenha achado útil. E se houver perguntas, sinta-se sempre à vontade para perguntar, eu vou ter certeza de responder. E sim. 62. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada colisadores de caixas ou colaborativos em geral. E a maneira como vamos fazer isso é antes de tudo, claro, criar uma nova cena aqui. L 19 colisões chamados litros. Eles vão, Vamos abrir isso e vamos também criar uma nova pasta aqui, et al. 19 colisores. E então, em vez de realmente vamos criar o script. E vamos chamar isso de script de colisões. Na verdade, está perto desta. Vamos abrir isto. O ego. Antes de fazermos qualquer coisa dentro daqui, nós vamos realmente criar uma espécie de cena agradável aqui. Mais uma vez, para os recursos eu tenho um particular ativos Kenny mais uma vez. E nós estamos realmente indo para criar um pouco de uma espécie de 2D maneira de fazer as coisas. Então vamos puxar esses sprites aqui. Então esta seria a frente verde alienígena, a caixa de caixa. Temos terra esquerda, MIT e direita, e temos a lava aqui. Agora, em teoria, esses devem estar em algum lugar por volta dos 28. Então, primeiro de tudo, na verdade, apenas marcar todos eles, selecionar todos eles, fazer todos eles apontar. E então vamos tentar 128 para os pixels por unidade para agora. E vamos fazer uma pequena plataforma aqui. Só por causa da discussão. Não vamos usar isso imediatamente, mas usaremos isso em breve. Quatro negativos e, em seguida, quatro negativos à esquerda. E então nós simplesmente precisamos mover isso por provavelmente um que está exatamente certo, menos um. E então este é mais um e um quatro negativo. E então temos uma pequena plataforma aqui, o que é muito bom. Podemos colocar o alienígena aqui, que na verdade é muito alto. Provavelmente 2,5 negativos, sim. Agora ele é realmente colocado nesta plataforma perfeitamente. E então nós também temos o ano da caixa, que só vai flutuar no ar em 2,5, nenhum lépton 25, 2,5 e menos três. E então a lava vai estar aqui só para que a tenhamos. Na verdade, vamos fazer isso um pouco maior também. Então, algo assim. Vamos fazer isso. 2.52.2.5, 725. Cara, isso é muito grande. 2.52.5 em dois negativos e três negativos. Vamos colocá-lo aqui. Sim, isso é muito bom. Então essa é a nossa cena agora. E o que estamos fazendo? O que, o que é, o que está acontecendo? Bem, o que faremos é o seguinte. Na verdade, vamos. Dê o, este. Então, em primeiro lugar, vamos renomear essas coisas jogador. Nós também vamos fazer um vazio, que vai ser o chão em que nós vamos apenas selecioná-los e arrastá-los para aqui para que o chão agora é não, não, não, não, eu não centralizá-lo. Isso não é que não é possível. Eu tenho que centralizar isso. Agora. Agora, agora está tudo bem. Onde o chão é aqui. A lava está bem e isto vai ser apenas uma caixa. Ok, agora o que podemos fazer? Bem, o jogador agora vai realmente obter os scripts de movimento que fizemos há muito, muito tempo para que possamos realmente movê-lo. E vamos ver, isto deve funcionar. Então, se eu pressionar WASD, eu posso realmente mover o jogador por aí. Agora, é claro, eu posso apenas movê-los através dessas coisas porque não, não há nada que não há nada que me impeça de fazer isso e também nada acontece. Então isso é meio interessante. Mas o que podemos fazer para basicamente nos permitir? Bem, temos algo que na verdade é antes de entrarmos no script, temos algo, temos outro componente que podemos usar. E isso é à vista do, se Sophie finalmente selecionar o jogador. E se dissermos adicionar componentes, então o que temos é que temos um colisor. Agora este colisor é em vez de Física 2D, e nós vamos usar o colisor de caixa neste caso, nós também poderíamos usar o colisor de cápsula. Isso provavelmente funcionaria, mas são basicamente diferentes. As diferentes formas, o colisor de caixa vai ficar bem. Agora, no nosso caso, como você pode ver, o colisor de caixa realmente é colocado, como em cima de toda a imagem aqui, que é um pouco grande demais. Então gostaríamos que o tamanho fosse um pouco diferente. Então, se eu mudar isso, então você pode ver que esta caixa verde ao redor deles muda. Vamos fazer algo como 1,25. E então o deslocamento basicamente muda onde isso está localizado. E se fizermos algo como ponto negativo para talvez façamos um. Desculpe, 35, 37, cinco, algo assim. Só por causa da discussão agora. Essa é uma caixa legal em torno deste personagem jogador. E agora tem um colisor de caixa. Então isso é muito legal. Agora. Isso nos leva a algum lugar? Quero dizer, agora, não porque nada mais tem um colisor. Então o que vamos fazer é selecionar todos esses caminhos de terra, suas plataformas de pedidos. E também vamos adicionar um colisor de caixa a esses. E se eu expandi-los agora, então podemos ver que tem alguns colisores aqui. Isso vai ficar bem. Porque agora só queremos ver de basicamente como fica se eu me mudasse para ele. Então vamos movê-los um pouco para cima. Dois negativos, de modo que ele flutua acima do solo. Porque agora o nosso movimento não é realmente um movimento para 2D. É um movimento para uma coisa de cima para baixo, mas vamos mudar isso dentro do tempo. Vamos também, apenas para que tenhamos um adicionado o colisor de caixa para a lava e nossa caixa. E vamos ajustar as configurações lá e um pouco. Então agora posso me mover. E agora o que acontece se eu tiver um colisor e o chão tiver um colisor, o que acontece se eu cair agora? Vamos ver o que acontece. Nada acontece. E a questão é, por que nada aconteceu? Porque isso tem um colisor e isso tem um colisor e eu pensei que isso seria uma espécie de colisão. Sim, mas precisamos de mais uma coisa porque para que a física funcione. E a coisa que precisamos está sob Física 2D aqui em baixo, e é chamado de corpo rígido 2D. Agora isso tem, como você pode ver, um monte de coisas também um monte de informações. Vamos diminuir a informação que vemos. E como podem ver, há muitas coisas aqui. E a primeira coisa que precisamos fazer, vamos falar sobre este corpo rígido 2D na próxima palestra com mais detalhes. Agora, a única coisa que precisamos fazer é basicamente colocar a escala de gravidade em 0. É tudo o que temos de fazer. E então basicamente coloque isso e não olhe de novo. No entanto, precisamos disso, caso contrário, nada disso funcionará. Mas agora, se eu tentar descer, fico preso. Eu fico preso em todas essas coisas. Porque agora esses colidem. Agora, o que é realmente engraçado. O que posso fazer é virar meu cara como você pode ver. E agora tudo está muito estranho. Vamos ter algo a ver com o corpo rígido também. Basicamente, podemos congelar a rotação. Nós vamos nos preocupar com isso, no entanto, como eu disse na próxima palestra. Então o colisor de caixa, o que podemos fazer agora? Por que isso é interessante? O que é assim, o que podemos fazer sobre isso no roteiro, certo? Então agora, basicamente, podemos colidir com todas essas coisas. Mas o que isso realmente nos dá? O que isso nos traz? Bem, você pode imaginar que se eu entrar na lava, isso vai doer. E talvez se eu tocar na caixa, eu só quero sair no console, Ei, você tocou na caixa. Digamos que essas são as duas coisas que eu quero. Como posso fazer isso? Bem, existem métodos para isso, e esses métodos serão vistos neste script de colisão. Assim, o script de colisão, podemos usar um método chamado em colisão entrar 2D. E como você pode ver, há alguns outros na saída de colisão na estadia de colisão, aqueles devem ser mais ou menos auto-explicativos na colisão entrar simplesmente significa que isso é chamado uma vez. Como você pode ver, uma vez que um colisor 2D ou um corpo rígido 2D começam a tocar. E sair simplesmente significa quando eles param de tocar e ficar é chamado como cada quadro que eles estão tocando. Isto dá-lhe uma colisão 2D. E com esta colisão 2D, nós realmente temos um monte de coisas que podemos chamar aqui. Como você pode ver, podemos chamar colider, contato, contagens de contatos ou quantos contextos existem. Podemos pegar os pontos de contato. Podemos pegar o corpo rígido, a transformação. Podemos conseguir muitas coisas. Neste momento, o que queremos é o colisor. E queremos o nome do colisor. E vamos verificar se isto é ou não uma caixa. Queremos saber se isto colidiu ou não com a caixa. E... É o caso. Então vamos simplesmente sair, hey, matiz, toque, você toca a caixa. E isso é tudo o que há para ele. Então esta é uma maneira de fazer a colisão em 2D, é claro. Então vamos ver se isso realmente funcionou bem antes de podermos ver se isso funciona ou não. Claro que também temos que adicionar o script de colisões aqui ao nosso, ao nosso jogador. Isso é muito importante. Não se esqueça disso. E então vamos ver o que acontece. Então, se eu tocar no chão, nada acontece. Se eu tocar na lava, nada acontece. No entanto, se eu tocar na caixa, como você pode ver, hey, você tocou em uma caixa. E cada vez que faço isso de novo, aumentamos esse contador. No entanto, se eu continuar fazendo isso, ele não funciona porque temos bem chamado O, nós implementamos o em colisão entrar método 2D e não para o estame. E há outra coisa. Então, dentro do colisor de caixa, se olharmos para isto. Então, se olharmos para a larva, por exemplo, há algumas coisas que podemos usar. Então editar colider simplesmente, podemos basicamente editar o colisor em um pouco mais de detalhes. Não precisamos fazer isso neste momento. O material de física não nos interessa no momento. Podemos, no entanto, usar este gatilho e isso é gatilho é uma coisa muito, muito interessante porque isso é acionado simplesmente remove fisicamente a maneira que podemos tocar isso. Por isso, vou mostrar-te isto. Então, enquanto o colisor normal colide com isso, e agora se isso é um gatilho, então assim que eu entro nele, eu não colido com ele porque é basicamente apenas um poço, é apenas um gatilho. É uma zona em particular na qual se eu entrar, ainda posso, algo pode acontecer. Mas eu não colido com ele. E este também seria um, outro método particular aqui. E isto é no Trigger Stay to D, por exemplo. Então há, mais uma vez, é claro, entrar nisso, ficar nisso, a saída para isso mais uma vez. Também muito importante. Certifique-se de que você usou o método 2D se estiver trabalhando com 2D, caso contrário, ele também não funcionará. E neste podemos basicamente fazer exatamente o mesmo. Como podem ver, há uma coisa estranha. Então isso ainda é chamado de colisão ou embora você tenha um colisor, eu não sei por que o por que eles ainda não consertaram o nome automático disso, mas eles vão. E então digamos que o nome do ponto colisor é igual a esta seria a lava. E se esse for o caso, então, por exemplo, você pode dizer que agora está ficando danificado. Danificados, eles vão para a direita. E então dentro daqui, é claro, o que você poderia fazer é se você tem uma referência ao script de saúde, por exemplo, você poderia dizer, hey, agora você está perdendo saúde e então em algum momento você poderia morrer se você estivesse no laboratório ou você morre imediatamente quando você está na lava ou algo assim. Mas agora, a única coisa que queremos é que enquanto o jogador fica dentro da lava, basicamente queremos que você receba saídas danificadas. Então vamos ver se isso funciona. E claro que sim. Isso é muito bom. Agora, o que é interessante é que por que ele continua? E se eu me mudar de novo, ele continua. Isso é por causa de uma das configurações em vez de um corpo rígido, como eu disse, na próxima palestra, vamos corrigir esse problema e algumas outras coisas. Eu também estou começando a dar uma olhada no corpo rígido em si. Mas por enquanto. E isso é realmente tudo o que eu queria mostrar para os próprios colisores. No geral, os colisadores são uma ferramenta incrivelmente útil e tão fácil de implementar e trabalhar. mesmo com basicamente os gatilhos aqui, que são uma ferramenta incrível para basicamente ter, você sabe, coisas diferentes acontecem em certos momentos sem sequer ter que ser algo para ser visto. Então, é claro, esse gatilho, nós também poderíamos simplesmente não ter um renderizador sprite sobre isso e então isso ainda funcionaria. Então há um monte de coisas que podemos fazer com isso, o que é muito legal. E sim, seria isso para os colisores. Como sempre, espero que tenha achado isso útil. E é claro que eu realmente apreciaria uma crítica sua. Caso contrário, se houver alguma pergunta como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 63. (Noções de Unity: Tudo bem, vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E esta palestra vamos dar uma olhada rápida no corpo rígido 2D. Então isso é uma espécie de parte do sistema físico de unidade. E já vimos isso antes. Eu disse que nós vamos para a última palestra que nós basicamente ignoramos isso e disse, bem, nós precisamos disso para a colisão funcionar. Mas agora vamos dar uma olhada em um pouco mais de detalhes. Então, as primeiras coisas. Primeiro, a primeira coisa que devemos fazer é falar sobre as restrições. As restrições devem ser bastante óbvias. Congelar a rotação simplesmente significa que este objeto de jogo específico, no nosso caso, o jogador não pode girar na direção z. Agora ainda podemos girá-los manualmente, mas o sistema de física não pode girá-lo. E nós realmente queremos fazer isso. Porque o que vimos anteriormente é que quando o jogador, Eu realmente colidiu com a caixa, então o jogador começa a girar. E isso definitivamente não é algo que queremos. Agora, há algumas coisas diferentes que podemos usar aqui. Então o tipo de corpo é a primeira coisa. E isso é entre não, dinâmico, cinemático e estático. E as principais diferenças aqui é basicamente estático significa simplesmente que não está mudando. Cinemática está se movendo e então dinâmica está se movendo com um pouco mais de dinam, dinamismo, veja, eu acho que um pouco mais de dinâmica. Acho que a massa é usada, calcule a força mais tarde na linha porque também podemos aplicar força a um corpo rígido. E a escala de gravidade simplesmente significa bem, escala de gravidade, mas o que você esperaria, então um, se você tem uma escala de gravidade de 1 e massa, então você cai quando você começa. Então, por exemplo, se eu fosse fazer isso e eu não me mexer, como você pode ver, de repente o jogador caiu. Então, se eu mover o jogador para cima, como você pode ver, o jogador cai agora e eu posso tentar mover para cima, mas isso realmente não funciona porque enquanto eu estou mudando minha posição, a gravidade está realmente me puxando para baixo novamente para que eu possa mover para a esquerda Certo. Isso funciona bem. Para baixo. Descer não faz sentido. E então subir também não faz sentido porque enquanto estou treinando minha posição, o sistema de física está lutando contra ele. E isso é basicamente também onde a parte onde você poderia pensar em um sistema de salto. Então isso é uma espécie de, é claro, uma plataforma e agora o movimento esquerdo e direito funciona totalmente bem. E agora implementar um salto pode ser algo que seria possível porque se você tem uma escala de gravidade, então quero dizer, isso é quase um salto, mas não é bem um tambor porque eu tenho que segurar a tecla W para manter movendo-se para cima basicamente. Então, provavelmente há uma maneira de fazer isso. Mas de qualquer maneira, o corpo rígido, tivemos um problema em que enquanto estávamos dentro disso e paramos de nos mover, de repente, não estávamos mais sendo danificados. Isso é por causa do modo de dormir. Então a ideia é começarmos acordados. Mas se pararmos de nos mover, então o sistema de física para o jogador começa a dormir. Basicamente. Se colocarmos isso para nunca dormir, então o que descobriremos é que uma vez que entrarmos aqui e ficarmos aqui, então ele continuará nos prejudicando. Claro, exatamente o que queríamos neste caso. Não queremos que isso durma naquele momento, certo? Algumas dessas coisas como a massa, o arrasto linear, linear e o arrasto angular, ou simplesmente exatamente essas coisas em termos de física. E em termos de componentes físicos ou, ou valores físicos. Eles são. Assim, a massa especialmente é, naturalmente, usada para calcular a força. Então, se eu colocasse força nesse objeto, dependendo da massa, ele mudaria. Então isso é simplesmente uma coisa muito normal da própria física. Basicamente, temos o interpelado é, como você pode ver, é o modo de atualização por quadro para o corpo. Podemos interpolar ou extrapolar ou você pode escolher nenhum. Normalmente eu diria que nada é o que você quer. Interpolação significa simplesmente que os passos entre eles são calculados. No geral. Eu acho que normalmente para a maioria das coisas que vamos fazer dentro daqui, na verdade não importa muito. mesmo com a detecção de colisão. Tão discreto significa simplesmente que está em passos discretos, modo que está em passos discretos. Contínuo significa que é contínuo, certo? Então vamos dar uma olhada rápida no, basicamente o corpo rígido dentro de scripts. Então, se formos para o, para o nosso script que tivemos aqui, as colisões do que o corpo rígido pode ser acessado por qualquer fazer não, na verdade, ele só pode ser acessado fazendo bom componente e, em seguida, Rígido, Corpo Rígido 2D. Então podemos salvar isso dentro de um corpo rígido 2D. Este seria corpo rígido 2D é igual list.rev obter componente. E então podemos pensar sobre o que podemos fazer aqui. Assim, por exemplo, corpo rígido, ponto 2D. E como podem ver, há um monte de coisas que podemos fazer. Então, em primeiro lugar, é claro, podemos e mudar todos os componentes que vimos no componente dentro do inspetor. Podemos, claro, também mudar algumas outras coisas e fazer alguns outros métodos realmente legais. Chame alguns métodos, por exemplo, em vigor. Assim, poderíamos, por exemplo, adicionar força em uma determinada direção. Então ponto vetorial, por exemplo, ou digamos, claro, vamos fazer ponto vetorial para cima por enquanto. Isso irá então adicionar uma força nessa direção. Então, em y, uma direção. Se fôssemos dizer, por exemplo, definir a escala de gravidade para 0 novamente. Vamos ver o que aconteceria agora. É que você pode ver que ele está se movendo muito, muito lentamente. Então esta é a força agora. Agora eu ainda posso movê-lo e eu ainda posso mudá-lo. A força ainda permanece. Porque se olharmos na informação aqui, você pode realmente ver que a velocidade é 0,02. E exatamente assim o, então a velocidade é o ponto 0 2. Então, basicamente, ponto 0, 2. Acho que um segundo seria a velocidade nesse caso. Então, se eu escalar isso para ser algo como vezes 20, modo que agora eu estou me movendo 20 vezes mais rápido. Deve ser 0,4, eu acho. E agora estão subindo um pouco mais rápido. Sim, ponto para isso é ótimo. E então, como você pode ver agora subindo muito rápido, nulo é claro, como eu disse, eu posso descer, sem problema. Mas neste caso, a força que foi adicionada lá é, sim, ela permanece basicamente. E isto é muito fixe. Podemos, naturalmente, também adicionar torque. Em teoria, podemos. O que mais há lá? Podemos calcular a distância entre isto e um colisor. Como você pode ver, há um monte de coisas que podemos fazer. Podemos mover a posição. Então isso move o corpo rígido para uma posição particular. Podemos olhar para a sobreposição. Então, há muitas coisas que podem ver que podemos fazer. Também podemos chamar o despertar para que ele desative o estado de sono. Mas a força publicitária é realmente a coisa muito interessante. Também podemos, creio eu, definir imediatamente a sua velocidade para algo. Então, como você pode ver, isso realmente diz isso. Então, se eu disser velocidade igual, eu acho que como eu disse, isso era um vetor 2D. É uma declaração secreta. Sim, este é um vetor 2D, então este seria um novo vetor, 2 D, por exemplo 0 e, em seguida, 0,15. Então, em vez de adicionar uma força, agora definimos a velocidade diretamente. Vamos fazer isto. Então vamos ver. E agora, como você pode ver, a velocidade agora é 0,15. Então essas são todas as coisas que estão na informação aqui, muito importantes também. Mas a razão pela qual nós não quereríamos necessariamente definir a velocidade por conta própria é por causa, claro, da massa. Se adicionarmos uma força, a massa determina qual é a velocidade no final. Então, às vezes você quer definir a velocidade, às vezes é melhor adicionar a força realmente depende de onde você quer ir com isso, quanto dos sistemas físicos você quer usar? Pessoalmente, eu diria que provavelmente faz mais sentido para não ter muito do sistema de física, mas realmente depende do tipo de jogo que você está tentando fazer. E uma última coisa que eu só queria mostrar, por exemplo, é se temos, por exemplo, algum arrasto linear. Digo, 50 é provavelmente um pouco demais. Vamos colocar em um, por enquanto. E coloquei uma força nele. Então o que você verá é que a velocidade diminui e de repente em algum momento é 0. Agora está tudo bem. Agora é muito lento, muito lento, muito lento. E então em algum momento é tão pequeno que eles basicamente não estão mais se movendo. E isso se torna 0. Quer dizer, isso já é basicamente 0. Porque o arrasto linear simplesmente significa que o que somos, nós temos algum arrasto logo antes de sermos basicamente apenas uma coisa flutuando no espaço sem qualquer resistência. E agora colocaríamos resistência ao ar. Então isso é, como você pode ver, o que diz. E sem amortecimento 0 significa sem amortecimento. Então isso é algo que você pode controlar com, por exemplo, o arrasto linear. E o mesmo com Angular Drag simplesmente para uma rotação nesse caso, certo? Isso seria para o corpo rígido em geral, há algumas coisas mais legais, é claro que pode fazer com ele. Mas eu acho que, como um olhar geral, é , é muito legal. E talvez o geral, em termos de uma idéia ou talvez você tenha agora uma idéia de como você pode ser capaz de basicamente adicionar uma espécie de mecânica de salto no jogo. Isso seria algo que você poderia, por exemplo, experimentar. Não é necessariamente necessário, mas seria uma boa ideia. Talvez consigas pensar em alguma coisa. Mas de qualquer forma, no geral, este seria para o corpo rígido 2D, espécie de uma breve visão geral dele. Como sempre, espero que tenha achado útil. E se ainda houver perguntas , sinta-se à vontade para perguntar e eu responderei. E sim. 64. (Noções básicas de Unity: Tudo bem, vamos continuar com a introdução básica da unidade para o curso da unidade. E nesta palestra, vamos dar uma olhada rápida em um texto muito, muito básico da interface do usuário. E a razão pela qual eu quero mostrar o texto básico da interface do usuário é que você tem uma estimativa aproximada da interface do usuário, pelo menos como exibir determinados textos. E depois, mais tarde, em outra seção, vamos dar um mergulho profundo na interface do usuário. Olhe para cada componente que existe, como usá-los e coisas assim. Eu acho que um texto básico da interface do usuário já pode fazer maravilhas. E para isso, vamos criar uma nova cena. Mais uma vez, l 21. Se não o fizer, se não estiver errado e acho que não estou. Vamos fazer um texto simples da interface do usuário. Textos, o ego. E vamos abrir isso imediatamente. E, em vez da pasta de scripts, uma nova pasta, L21, texto da interface do usuário, com um script C-sharp muito fácil chamado texto da interface do usuário. Quem teria adivinhado, há imediatamente começar isso. E vamos criar um novo, basicamente texto dentro do nosso jogo. Como podemos fazer isso? Bem, em uma espécie de hierarquia, clicando com o botão direito do mouse. E, em seguida, indo para UI e, em seguida, Vamos usar os textos normais agora. Como eu disse, todas as outras coisas, bem como o que este texto Mesh pro significa. Eu vou explicar em futuras palestras agora. Vamos apenas lidar com o texto normal e como podemos realmente fazer isso ser exibido. Então agora temos um novo texto e como podem ver, algumas coisas foram geradas. Um, o sistema de eventos, vamos precisar disso, não exclua isso, caso contrário, algumas coisas podem não funcionar. E o Canvas e Canvas é basicamente, você pode imaginar uma tela basicamente como um, como uma tela que você pintaria. E no nosso caso, nós não pintamos sobre isso, mas nossa interface é basicamente carimbada nesta tela. Agora, se reduzirmos um pouco, você verá que, em primeiro lugar, o texto é gigante e na tela também é muito, muito grande. E nós podemos mudar isso basicamente indo aqui para Canvas e, em seguida, mudando o modo de renderização para câmera de espaço de tela. E, em seguida, pegar a câmera principal e colocá-la nesta câmera renderizadora. E de repente, a tela é colocada no tamanho da câmera. E o nosso texto está no fundo aqui. E podemos redimensioná-lo com a ferramenta rect. Esta é a maneira mais fácil de fazer isso. Nós podemos basicamente redimensionar isso e tipo de colocá-lo como animal aqui em cima, por exemplo. E, em seguida, aumentar o tamanho da fonte no próprio texto. Isso é feito aqui. E então, de repente, vamos fazer algo assim. Centralizá-lo e eles, nós vamos, agora temos um novo texto. No geral. Esta é a única coisa que precisamos fazer no próprio Canvas. Como você pode ver, há um monte mais. Não vamos nos preocupar com isso por enquanto. Vamos nos preocupar apenas com o texto em si. Onde podemos, naturalmente, mudar o fundo. Em teoria, podemos alterar o tamanho da fonte, o estilo, o alinhamento. Portanto, tudo o que você também pode fazer é, por exemplo, no Word. E, claro, a cor também pode ser alterada para, vamos fazer esse tipo de cor branca. E se eu for para o jogo e você pode ver que o novo texto aparece lá sem problema. Eu posso mudar o texto aqui neste, neste campo de texto. Então, por exemplo, para 100. E o que vou fazer agora é adicionar o texto da interface do usuário como um componente para os dois exatamente este objeto de jogo de texto. E dentro dele, vamos ver como eu poderia mudar o texto via script. Então, para eu mudar o script, mudar a interface do usuário real via script, eu estarei usando o mecanismo Unity WI. Então este é um namespace que precisamos estar usando. E então vamos apenas, por exemplo, fazer uma variável de texto privada chamada texto de teste. E vamos fazer disso um campo sério só para que possamos ver o que está acontecendo. E esta é a interface do usuário, como você pode ver, o elemento UI, o mecanismo Unity, o texto wi ponto. E este é exatamente este componente aqui. Em teoria, este componente aqui é este texto. E o que podemos fazer é dizer se quisermos definir os textos, eles são teste, test.txt. Então, o texto é a variável de string que realmente é exibida. E podemos definir isso fazendo, por exemplo, se quisermos que isso defina para 300, se fizermos isso, então ele vai dizer, que não funciona porque nós realmente temos que dizer para string. Ou podemos, naturalmente, dizer algo como este veículo 300. Isto é, claro, ainda mais fácil. Então podemos definir isso para qualquer string que quiséssemos. E, claro, há também algumas outras coisas que podemos fazer para que possamos mudar a cor alinhada. Podemos rastrear a fonte em si, também pode alterar o tamanho da fonte. Então, basicamente, todas as coisas que vimos dentro do componente real, podemos mudar se o seu script também. Mas agora a única coisa que eu realmente quero fazer é basicamente mudar isso. Para mudar os cem, duzentos, trezentos, uma vez que eu começar. E nós realmente temos que definir isso aqui. Então, como podem ver, testem textos, nenhum agora. Então o que podemos fazer é apenas colocar em si mesmo ou dentro do script. Antes de começar, podemos dizer que tem textos como igual a este ponto obter texto componente. Então, fazendo uso do método componente da dívida mais uma vez para basicamente obter o texto no início. E se começarmos isso, você pode ver que se transforma em 300. Isso não é ótimo? Certo? E esta é uma forma muito, muito básica de implementar um texto e como podemos mudar isso. Mais uma vez, podemos simplesmente usar o método Get componente, a fim de basicamente acessar o texto e, em seguida, todas as variáveis associadas a ele. Não vamos olhar para muitas dessas coisas. Como eu disse, isso é algo que eu só queria mencionar rapidamente. Rapidamente mostrar-lhe para que você possa fazer muito, muito básico apenas texto da interface do usuário e nada mais realmente. Só para que tenhamos isso em nossa caixa de ferramentas para olhar, bem, fazendo nosso primeiro jogo basicamente, certo? Mas isso já era tudo para esta palestra. Espero que você achou útil como sempre, se houver alguma pergunta sempre tem que perguntar e eu vou ter certeza de responder. E sim. 65. (Basics da Unity: Ou vamos continuar com a introdução básica da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida em algumas ferramentas de depuração que você tem dentro do Unity. E vamos apenas criar uma nova cena, depuração L22. Agora, essas ferramentas de depuração seriam ferramentas que usam basicamente a classe Debug. Então esta é uma outra pasta, L22 depuração. E depois um guião aqui. Legal, o exemplo de depuração. Vamos abrir isso e vamos também fazer um objeto de jogo vazio chamado depuração. Centralizando-o, é claro, eles vão zeros 0000 e adicionando o script de exemplo de depuração a ele. E então vamos ver o que podemos ver. Então nós vamos apenas produzir algo. Quando eu pressionar aqui, vamos usar o código de tecla ponto d. Então, se eu pressionar D, então vamos depurar algo. Acho que isso faz sentido. E a primeira coisa que já sabemos é, claro, o log de pontos de depuração. Isso é algo que já vimos. Você já conhece esse, certo? Isso deve ser auto-explicativo, simplesmente bloqueia uma mensagem para o console. Há também o aviso de depuração. Agora vimos alguns avisos. Então isso pode ser, por exemplo, uma manhã que você escreve. E isso é algo que vimos algumas vezes antes com, por exemplo, variáveis que tinham sido atribuídas, mas não realmente frias em qualquer outro lugar. Mas eu não acredito que nós mesmos ligamos ou fizemos um aviso. E há também olhar, era. Esta é a única coisa que ele sempre sugere que às vezes é sugerido antes do log. Eu não tenho certeza por que isso mudou recentemente, digamos versões de unidade, mas qualquer que seja o caso, aqueles três, Digamos aqui. Isto é uma flecha. Claro que sim. Arrow, aí vai você. E vamos ver como isto fica se começarmos isto. Então, primeiro de tudo, bem, é claro que preciso apertar o botão. É por isso que nada aconteceu. Isso explicaria isso, naturalmente. D. E então, como pode ver, você já conhecia essa. Estou avisando, e este é um árabe. Há também, é claro, filtragem sobre o console. Eu já expliquei isso. E essas três coisas são basicamente algo que podemos fazer e podemos continuar pressionando isso. E como você pode ver, o número sobe. E isso é realmente útil porque é claro que você pode, tipo de, dependendo do que você quer expressar em seu código, você pode puxar para fora um aviso ou um erro. E isso é muito bom para fins de depuração. No entanto, o que eu quero dizer é que todas as ferramentas de depuração são muito caras, então todos eles devem ser retirados quando o jogo real é lançado ou comentado ou apenas certificando-se de que eles não estão mais lá. Eu não tenho certeza, na verdade, se eles estão frios durante o jogo ou se a depuração é algo que só é feito em vez do editor, Eu não tenho 100% de certeza. Mas de qualquer maneira, então. Há outra coisa que podemos fazer e que é uma linha de empate. O que é isto? Bem, este ponto transforma a posição do ponto. Então, começamos nesta posição e dizemos, por exemplo, que vamos daqui da nossa posição para a direita. Então vetor três vezes cinco. E então nós também podemos dizer, bem, nós queremos que isso seja colorido vermelho. E dez F significa que fica por dez segundos. Então isso é muito legal porque o que podemos fazer é apenas traçar uma linha. E enquanto o, você poderia dizer, bem, por que eu iria querer traçar uma linha? Vamos ver como isso parece. Não parece nada porque os aparelhos não estão ligados. Vamos ligar os aparelhos e, de repente, vemos esta linha vermelha. Fica lá por 10 segundos e depois desaparece. Como pode ver, aí está. Porque é que isto é tão fixe? Por que podemos usar isso? Bem, é realmente útil porque às vezes talvez o que você quer é saber o que está acontecendo com alguma coisa. Talvez você queira saber se algo está se movendo em direção ou algo assim. E, em seguida, desenhar uma linha com a ferramenta de depuração pode ser realmente útil. Agora eu posso desenhar um monte de linhas, é claro, e todos eles vão expirar em algum momento. Mas sim, então a linha de desenho, incrivelmente útil poderia ser. Quer dizer, eu acho que é muito útil. É por isso que eu queria mostrar. É muito fixe. Há também a exceção da fechadura. Se eu conseguir, exceção de bloqueio, aí vai você. Então, neste podemos, por exemplo, dizer sistema, uma nova exceção System.Out. E então isso diz, sim, é uma exceção. Então isso é apenas registrar uma exceção basicamente. E por último, mas não menos importante, o que eu também quero mostrar a vocês é o ponto de depuração, ponto. E isso simplesmente afirmam um particular condições bool. Então, se eu colocar em um verdadeiro aqui, então nada recebe saída. E vamos simplesmente ignorar isso. Se eu colocar um falso, veremos que a afirmação será falhada e teremos uma referência com esta linha. Então vamos ver como isso parece. Se eu guardei isso de novo, pressione D, como você pode ver. Então, primeiro de tudo, você já conhece este. Então estou avisando que temos uma flecha, este é o nosso próprio erro. Também podemos olhar uma exceção. Exceção. Sim, é uma exceção. E, em seguida, a asserção falhou, debug dot assertion bool. Então podemos basicamente afirmar certas coisas e dizer: “ Ei, se isso estiver correto, então continue. Se isso não for, então pare pode ser útil para, Vamos adicionar depuração. E sim, esse é o tipo de coisas que eu queria te mostrar. Claro, dentro da div, há mais algumas coisas que você pode olhar, mas no geral, essas são as que eu queria mostrar a vocês. Se há outras coisas que você precisa, você pode ir, é claro, olhar para a classe Debug você mesmo e olhar para algumas coisas, mas essas são as que eu achei mais úteis para mim mesmo. E sim, isso já seria para esta palestra e esta seção. E espero que tenha achado útil como sempre. Se tiver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 66. (Clicador de queijo: Bem-vindos ao “Cheese Clicker “para o curso de união. E nesta palestra, eu só queria mostrar rapidamente o que vamos criar nesta seção do curso. Queremos criar um clicker de queijo. Há uma espécie de Cookie Clicker, mas com queijo. Foi essa a ideia que tive. E porque Cookie Clicker é um conceito muito fácil de entender, eu pensei que, em seguida, torná-lo em queijo também faria sentido. E esperançosamente seria mais fácil de seguir porque o conceito é tão fácil. No entanto, ainda podemos criar um sistema muito bem interessante com isso. E nós também podemos criar quem vai. Então, neste caso, isso já está terminado. Neste caso aqui, eu queria te mostrar isso e vamos ver como funciona. Então, a maneira como ele joga é que basicamente temos a capacidade criar novos edifícios para que possamos construir um edifício clicker e um prédio de estação de ordenha. Também temos atualizações que são geradas que implementamos. E se clicarmos no queijo, então, como você pode ver, o número de queijo aqui em cima aumenta. E se tivermos queijo suficiente para construir algo, então os botões reais aqui também virarão para que possamos clicar nele e então podemos clicar, por exemplo, no clicker. O número aqui aumentaria e esse número também aumentará. Assim, o custo aumentará, bem como o número de edifícios que temos deste tipo. O clicker irá gerar para nós um queijo por segundo. Podemos então, por exemplo, por uma atualização aqui em baixo, e então o clicker vai de repente nos levar ao queijo por segundo. E quando tivermos, por exemplo, uma estação de ordenha aqui, isso nos dará cinco queijos a cada dois segundos. Certo? Então é assim que o jogo parece. Também temos alguns truques embutidos. Então, se eu pressionar mais, então vamos aumentar o queijo. Se um mais menos, então vamos diminuir o queijo. Então isso é muito legal. E tudo isso será construído sobre as próximas palestras. Primeiro de tudo, o queijo para clicar neles vai olhar para os edifícios. Nós vamos adicionar uma interface simples a ele que podemos basicamente usar. E por último, vamos adicionar o sistema de atualização. Basicamente, tudo aqui. Como de costume. O, tanto isso como um pacote está disponível para você baixar, bem como cada um dos sprites aqui estão disponíveis como um recurso. E yum, como você quiser usar isso. Basicamente, você pode basicamente obter o seu, todo o projeto aqui, baixá-lo, e então olhar para o código enquanto eu estou escrevendo, enquanto eu estou explicando, ou você pode basicamente escrevê-lo em paralelo comigo. Há, claro, algo para você decidir como você pode entender melhor isso e como você pode ver melhor como isso funciona. Mas no geral, será isso para esta palestra. Agora, eu espero que você se divirta para as próximas palestras onde nós realmente criamos nosso próprio primeiro jogo, o clicker de queijo. E sim, seria isso. E espero que se divirtam nas próximas palestras. E eu diria, se houver alguma pergunta, é claro, durante a tomada deste jogo, então sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 67. (Clicador de queijo: Muito bem, bem-vindos a criar o clicker de queijo aqui para o curso de união. E nesta palestra, vamos fazer um queijo que possamos clicar. E também um objeto de jogo onde podemos armazenar nosso queijo. Então basicamente um depósito de queijo, por assim dizer. E para isso, a primeira coisa que eu já preparei, a pasta de scripts e a pasta sprites aqui. Isso não deve ser nada louco ou completamente novo para você. E vamos pegar o queijo. Então este é o recurso sprite que eu tenho. Basicamente tão disponível como um recurso. E nós vamos mudar se vocês números aqui. Então, primeiro de tudo, os pixels por unidade vai ser um 150. Vamos fazer este ponto de modo de filtro para que tenhamos uma espécie de imagem nítida e a compressão será definida como nenhuma por causa disso, algum básico, não é uma seta como um aviso aqui. Então a compressão nenhuma e, em seguida, o aviso desaparecerá. Certo? Agora que temos o nosso queijo, podemos arrastá-lo para a nossa cena e agora temos um queijo aqui. Vamos localizar isto em algum lugar como 00, negativo 0,5. Diga que é um bom local para isso. E nós vamos renomear o queijo para o clicker de queijo porque isso é basicamente as árvores que vamos clicar. E também vamos criar dois scripts. Mas antes de fazer isso, vamos para o nosso editor de configurações do projeto e, em seguida, para o nosso namespace raiz e o namespace raiz. Neste caso, vai ser “clicker “de queijo, certo? Então, tendo isso como um espaço raiz, namespace irá gerar o namespace como você provavelmente viu dentro de. Dentro da palestra de namespace dentro da introdução em C, certo? Então vamos criar nossos scripts C, C. O primeiro script que vamos criar é o queijo Flickr. Então este é o clique real do queijo. E então criaremos imediatamente outro script. E isso seria o, podemos chamar isso de “Ela está armazenando”. Acho que é uma boa ideia. E nós sabemos que ok, em uma espécie de depósito de queijo lá, nós armazenamos nosso queijo por assim dizer. E vamos abrir isto. E uma vez aberta, podemos voltar imediatamente para o clicker de queijo. E agora temos os dois arquivos abertos. Então vamos pensar sobre o que precisamos para o próprio clicker de queijo. Então, vamos primeiro ser capazes de basicamente clicar no queijo. Na verdade, há uma coisa muito boa que podemos fazer. E isso vai ser, nós estamos em primeiro lugar, nós realmente não precisamos nem do início nem do método de atualização aqui. E o que vamos usar é dois métodos que estão disponíveis porque este é um comportamento mono. E isso será no mouse para baixo, como você pode ver. Assim, no mouse para baixo e, em seguida, com tab podemos basicamente auto-completar isso e no mouse para baixo, o que isso faz, como você pode ver, é chamado quando o usuário pressionou o botão do mouse enquanto sobre o elemento GUI ou colider. Então este é um elemento GUI, este será um colisor. Portanto, o que vamos fazer agora é aumentar. Basicamente, só para sabermos que isso funciona. E uma coisa que nós também vamos fazer é dizer, vamos ter um novo método aqui, que vai redimensionar o queijo. Porque agora, na verdade, vamos primeiro olhar para isto e depois vamos resolver isto. Então aumentou o queijo. Então, quando clicamos neste Clicker queijo, então queremos aumentar o queijo. Agora isso é, naturalmente, não implementado ainda, mas o, pelo menos a saída deve funcionar. Então este clicker de queijo, vamos colocar o, não o armazenamento, mas a cintilação de queijo lá e ver se quando clicarmos nele, se obtemos ou não uma saída de console. Então eu e nada acontece. Então isso é meio estranho. Por que é esse o caso? Bem, ele disse que precisa de um colisor. Então há duas maneiras de fazermos isso. Podemos adicionar um colisor aqui, certo? Indo para Physics 2D caixa colisor, por exemplo, ou um colisor de polígono. Ou podemos fazer outra coisa. Então eu vou remover o script por apenas um segundo aqui. E o que eu posso fazer é subir aqui, colocar os suportes e dizer exigir componente. Então isso basicamente diz, Ei, essa classe, onde quer que esse comportamento moral esteja ligado ao objeto do jogo, requer também esse componente. E então eu posso dizer tipo de Colider que leve muito fundo. E isso irá então adicionar um colisor assim que eu adicionei este comportamento moral para o real, para o objeto de jogo real. Então o que vamos ver é se eu adicionar isso agora, como você pode ver, adicionar um componente falhou porque precisamos de uma caixa ou algumas dessas coisas, e precisamos adicionar a isso primeiro. Então, se agora entrarmos aqui e vamos pegar o colisor de polígono e ele vai fazer basicamente o contorno perfeito aqui para que não possamos realmente clicar fora dele. Vamos manter como está e ficar bem com isso. E uma vez que adicionamos o colisor de polígonos, agora adicionamos o clicker de queijo, conhecemos Era, e sabemos que tudo funciona totalmente bem. Então, isso é basicamente para garantir que um determinado script realmente funciona usando este componente exigem. Ok, vamos tentar isso e ver se quando eu clicar nele, funciona e funciona. Então, se eu clicar nele, como você pode ver, um aumento de queijo é impresso, o que é realmente bom. Então sabemos que o mouse para baixo funciona. Agora, como você viu, não há realmente uma indicação visual lá. E o que vamos fazer é basicamente redimensionar o queijo. E para isso vamos fazer um novo método privado aqui, queijo vazio privado redimensionar. E isso vai levar um vetor 3, que vai ser o novo tamanho. Então a idéia aqui é que nós vamos basicamente colocar em um vetor neste método e, em seguida, ele vai mudar esta escala local é igual a novo tamanho, novo tamanho. E nós vamos fazer isso uma vez no começo aqui, assim que eu comecei com o mouse para baixo. Então vamos redimensionar o queijo para basicamente, bem, tamanho é agora um, então este seria seu tamanho original. E então vamos dizer algo como 0,9, por exemplo. Isso seria viável. E então, é claro, precisamos disso para crescer novamente. Caso contrário, não vai funcionar. Então agora podemos usar o outro método do mouse. Então isso será no mouse para cima. E mais uma vez, este é um método cortesia do comportamento do modelo aqui, vamos redimensionar o queijo com o vetor três pontos um. Então, isso basicamente irá redefini-lo para o seu tamanho original 10, 11. E isso já deve funcionar. Então vamos ver se isso funciona e temos um efeito visual legal aqui. Então o que vamos fazer é, é claro que a escala vai mudar agora. Então vamos ver se esse é realmente o caso. E é o caso. Se eu mantê-lo pressionado, então funciona. E assim que eu soltar o botão , ele também funciona. Agora o que acontece? Por exemplo, se eu fosse sair da vista da tela, como você pode ver, ainda funciona bastante bem. Acredito que há maneiras que você provavelmente pode enganar o sistema. Eu acho que se eu pressionar agora, não, se eu pressionar a tecla Windows, ele ainda funciona muito bem. Então isso é realmente muito bom. E então agora temos indicação visual disso. Claro, você sempre pode mudar isso de pé. Talvez queiras que isto seja um pouco mais sutil. Então talvez você queira mudá-lo para cerca de 95 por cento do seu tamanho original ou outra coisa. No geral, eu acho que isso vai ficar bem. Certo? Então vamos fazer o seguinte. Vamos realmente pensar sobre isso. Bem, agora, de alguma forma, queremos que o depósito de queijo seja capaz de armazenar queijo, certo? Portanto, há algumas coisas que precisamos fazer no armazenamento de software agora. E, no entanto, a primeira coisa, é claro, vai ser um int privado chamado queijo, certo? Então esse queijo, lá vai você. E isso vai guardar quanto queijo temos. Vamos fazer isso um campos serializados para que possamos realmente vê-lo dentro do construtor também. E então nós vamos fazer algo que é bem, talvez não muito de vocês sabem, mas isso seria um, isso é basicamente um padrão de design C afiado, e isso é chamado de padrão singleton. A idéia é que temos uma variável estática de armazenamento de queijo aqui. Vamos chamar isso de “Os Mets “, chamar isso de “depósito de queijo”. E este será sempre, bem, o que está dentro do nosso jogo. Como podemos garantir isso? Bem, se o armazenamento de queijo, então esta variável estática é igual a null. Então, se não há nada escrito dentro dele, então vamos simplesmente dizer que ela está armazenada. Então, então a variável estática para isso. E isso garantirá que o número 1, exista apenas um depósito em particular disponível. E então também que podemos acessar isso de qualquer lugar, basicamente usando a classe. Então, ela armazenamento, armazenamento, talvez o nome possa ser mudado no geral, eu acho que isso é bom. Ela provavelmente vai ficar bem. Vamos realmente renomear isso para que possamos pressionar Control R para renomear isso. Vamos chamar essa instância de armazenamento de queijo porque isso realmente é um nome melhor para isso. E então o que eu também vou adicionar também vai adicionar três eventos aqui. Então nós vimos isso muito em breve no final da introdução em C acentuado. Então nós vamos primeiro fazer um delegado, e isso vai ser chamado na quantidade de queijo mudança. Então isso é basicamente um delegado. Isto é, eles são se uma quantidade de queijo muda e então nós vamos fazer três eventos estáticos. Então público estático, evento estático. Um deles é legal. Então, todos eles na quantidade de queijo mudam. Um deles chamou em queijo adicionado. Então este seria o que é chamado quando há mais que ela é adicionada. Então vamos copiar isto duas vezes. Um deles em Ela é removido, digamos que também pode ser em queijo, subtraído, algo assim. E então nós também vamos ter um nele. Ela mudou, mudou, eles vão. Então a idéia é que queremos chamar isso quando adicionamos um queijo, quando removemos um queijo e isso vai ser chamado em qualquer um desses. Eu diria que isso é algum, mais uma vez, como eu disse na introdução C-sharp sobre eventos, você realmente não tem um negativo em adicionar mais eventos. Penso que isto vai correr bem e sabe-se lá o que queremos acrescentar mais tarde, na linha em que poderemos precisar de todos esses acontecimentos. por isso que os adicionei. E sim, então agora vamos pensar sobre o que mais precisamos? Uh, então nós queremos, basicamente, se pensarmos sobre isso para os métodos públicos desta vez, certo, que pode ser chamado e aqueles seriam e ela é taxa. Então fomos de algum lugar para adicionar um queijo com uma quantidade particular, é claro, certo? Então isso eu acho, faria sentido. Mas é como um, Eu quero uma quantidade particular de queijo e isso é então salvo neste perímetro quantidade. E o que aconteceria é que este queijo ponto-ponto seria apenas mais igual à quantidade. Mas isso, deve ser bastante fácil de entender. E então, claro, nós também queremos chamar os eventos aqui. E podemos chamar esses eventos com uma coisa particular e que vai ser no queijo adicionado, por exemplo, porque suas realidades, e se colocarmos em um ponto ponto de interrogação invocar e dizer queijo, então esta pergunta marca basicamente se certifica de que há pelo menos um assinante lá, caso contrário, ele não vai disparar. Então isso é basicamente o mesmo que se eu dissesse, se ela é adicionado é desigual a nulo, e então dizer sobre ela adicionou queijo. E eu acredito que se eu fizer isso, então ele vai realmente dizer, hey, nós podemos simplificar isso exatamente para este aqui. E como você pode ver, isso é exatamente o mesmo. Bem, precisamos fazer o mesmo aqui porque ela mudou também. E então estamos realmente felizes com isso. Nós vamos simplesmente copiar isso e então nós vamos dizer que isso seria árvores removidas. Isso é, então, ser isso ela é quantidade negativa. E então, em vez de adicionado, nós removemos. Agora, é claro, nós , neste cenário, poderíamos remover árvores que não temos. Para que pudéssemos dar negativo. Mas não vamos nos preocupar com isso no momento. Agora, vamos apenas adicionar queijo de qualquer maneira com o clique. Então, vai ficar tudo bem. E agora a última coisa que precisamos fazer é de alguma forma, bem, ter o método de adicionar queijo ser chamado de queijos em serviço, pequenos e clicker, e então estamos bem. E podemos fazer isso simplesmente entrando aqui e dizendo, bem, eu sei que posso pegar meu queijo. Vamos fazer isso aqui no fundo. Posso dizer, por exemplo, queijo. Instância de armazenamento de pontos. Então esta é a instância. Então esta é basicamente a mesma coisa que eu estaria recebendo se eu fosse fazer ponto jogo encontrar armazenamento barato. Mas agora porque a instância estática é salva dentro da própria classe, podemos simplesmente fazê-lo assim no queijo e depois dizer um. E na esperança de que isso funcione, que isso seria muito legal. Então vamos ver, não precisamos mais da depuração. E vamos ver se isso realmente funciona como pretendido. Ok, vamos começar isso e ver agora primeiro de tudo, é claro, precisamos adicionar um depósito de queijo aqui. Isso seria muito inteligente. Então ela é um depósito. E vamos adicionar este armazenamento. Aqui vão eles. Como você pode ver, 0 árvore está atualmente lá. E vamos esperar que isso aumente quando eu clicar nisso. E faz, não é ótimo? Então aumenta cada vez que eu clico e nós estamos recebendo, ela é como, ninguém nunca comeu queijo antes simplesmente clicando este queijo em uma balança? Não foi visto desde então. Eu não sei. Não sei quando começaram a fazer queijo, mas sim. Então isso seria realmente para o clique do queijo. Então temos cada temporada que podemos clicar agora. Temos também um armazenamento de queijos onde podemos adicionar queijo e remover queijo. E agora realmente se resume a, você sabe, adicionar alguns extras. Então, um dos extras que vamos adicionar imediatamente é apenas para que possamos testar isso é tipo de trapaças. Então, em vez do método de atualização do nosso armazenamento de queijo, vamos fazer a entrada para cima, obter a chave para baixo. E então ele código ponto teclado. Vou usar o teclado mais. Então, a vantagem no teclado, eles geralmente à direita do seu teclado. O que vamos fazer é dizer a instância ponto adicionar queijo. Digamos que cerca de 10. Nós só vamos adicionar 10 queijo a ele. E depois vamos copiar isto. E o que eu vou dizer tecla, teclado, manter em menos. E então nós vamos simplesmente fazer ponto remover queijo. E isso seria 10. Agora é importante que nós realmente não temos que passar este número negativo aqui. Queremos passar este um número positivo, que você poderia, naturalmente, também fazer é passar, adicionar queijo, um número negativo. E isso também funcionaria. Embora, claro, então, o queijo adicionado teria uma espécie de problema aqui. Então isso seria algo que você poderia adicionar também. Então isso não vai ser totalmente sólido, mas eu queria mencionar isso. Então, não é muito fácil fazer com um cheque de um se nesse caso. Mas sim. Sim. Então, na verdade, seria isso. Vamos, hum, vamos ver isso em ação o mais e o menos para que possamos basicamente adicionar e remover árvores aqui sem clicar no queijo real. Então, vamos clicar nisso algumas vezes. E então vamos dizer primeiro o mais, e então eu recebo 10 queijo imediatamente sem um problema. E eu também posso remover queijo. E se você ver isso, então nós podemos realmente ir para os negativos sem um problema aqui. Então eu posso voltar com a vantagem, basicamente apenas adicionando e removendo queijo. Isso é bom para adicionar este tipo de prata apenas para fins de depuração para que você possa experimentar. Ok. Eu preciso, se você talvez se quisermos adicionar algo que custe o Sheets para fazer, então o que podemos fazer é basicamente adicionar um monte de queijo. Estamos no depósito. E então nós vamos ficar bem e nós não temos que esperar e clicar como 1000 vezes até termos 1000 queijo para fazer alguma coisa. E então o número, claro, também pode mudar. Mas sim, seria isso para esta palestra. Adicionando um queijo para clicar e, em seguida, obter o queijo, armazenando-o dentro do nosso armazenamento aqui. Espero que você tenha achado esta palestra útil como sempre, se houver alguma dúvida, sinta-se livre para perguntar. Eu vou ter certeza de responder. E sim. 68. (Clicador de queijo: Tudo bem, vamos continuar com o nosso clicker de queijo aqui para o curso de união. E nesta palestra vamos adicionar a capacidade de construir os edifícios que nos gerarão queijo sem que tenhamos que fazer nada. Então queijo passivo, o que poderia ser melhor? Eu não sei. Então vamos pensar sobre isso. Vamos primeiro fazer uma nova pasta dentro de nossos scripts aqui chamados edifícios. Então isso vai exatamente como é todos os roteiros em que nossos edifícios vão estar. E vamos antes de tudo criar uma nova classe chamada Construção. Então construindo lá está, sim. E esta vai ser uma aula abstrata. Então vamos abrir isso e pensar sobre isso por um momento. Então, antes de tudo, isso não herdará de um comportamento mono. Então esta classe será uma espécie de, bem apenas a classe de dados. Você poderia pensar nisso assim. E também vamos adicionar os prédios aqui ao nosso namespace também. Então, tudo isso estará dentro do espaço de nomes dos edifícios. E o edifício vai ser uma classe abstrata porque nunca queremos um edifício específico. Só queremos as classes herdadas. Então, cada vez que vamos criar um novo edifício, vamos torná-lo herdar desta classe de construção. E então vamos pensar sobre isso. O que realmente precisamos para um prédio? Que tipo de componentes de um edifício? A primeira coisa que precisamos é de uma taxa de custo. Então vamos fazer com que isso tenha propriedades basicamente. Então nós vamos ter uma base de custo basicamente para estes edifícios cívicos. Então, isso é quanto queijo custará. Nós também vamos, se eu for apenas copiar esta propriedade, nós também vamos ter cada ganho de Ele. Isto é simplesmente o que ganharemos em termos de árvores. E então teremos uma propriedade flutuante aqui, que vamos chamar de intervalo de tempo. E a idéia aqui é que o tempo estar aqui, a idéia aqui é que nós vamos simplesmente ter este tempo como você tem este queijo ganhar cada intervalo de tempo basicamente. Esses são os três fundamentos que precisamos para um prédio. Talvez possas arranjar mais alguns. Mas agora vamos fazer isso assim. E há também alguns eventos que eu estava pensando. Um dos eventos seria, em primeiro lugar, um delegado, delegado público, vazio. Este é simplesmente o manipulador de edifícios com um edifício específico. Então construindo, construindo. E então podemos ter que eventos que são ambos de manipulador de construção. Um deles está na construção, então no edifício construído. Então isso é basicamente quando estamos construindo algo e, em seguida, nós também temos na construção de fluxo de caixa que nós vamos olhar. Então o fluxo de caixa basicamente é quando adicionamos o ganho de queijo. Então esses seriam os dois eventos que eu inventei. Claro, há provavelmente alguns mais em que se pode pensar, mas neste momento eu acho que isso seria suficiente. E, e vamos pensar um pouco mais nesta aula de construção. Então vamos ter um protegido o construtor. Prédio com exatamente essas três propriedades aqui. Então o custo, vamos ter o ganho de queijo e vamos ter o intervalo de tempo flutuante. E essas serão simplesmente definidas para exatamente essas propriedades. Então esse custo de ponto é igual a custo. Este ganho de queijo ponto é igual ao ganho de queijo. E então esse intervalo de tempo é igual a intervalo de tempo, intervalo de tempo. Este, eles vão, certo. E bem, está tudo bem. E bem, há mais uma coisa que precisamos, é claro, do fluxo de caixa abstrato público. Então este é basicamente o método abstrato que cada uma das classes herdadas precisa implementar, a fim de que eles sejam como edifícios apropriados. Porque precisamos basicamente desse fluxo de caixa para ser chamado de cada vez. Bem, exatamente isso acontece. Então, quando o intervalo de tempo é feito, então vamos chamar este método. E cada um dos edifícios terá um tipo diferente de método de fluxo de caixa. talvez seja retornando ou não, simplesmente devolvendo dez queijos, ou talvez haja algumas partes diferentes. Então talvez você tenha prédios diferentes. E quando você tem um desses, um de construção a e um de Edifício B, o tipo de influência uns aos outros ou mais tarde abaixo da linha quando criamos upgrades para edifícios específicos do que esses métodos de fluxo de caixa podem mudar para edifícios. É por isso que este é um método abstrato neste caso. Então, eu acho que no geral, isso é uma espécie de final pronto. Agora vamos pensar em mais duas coisas. Talvez se construirmos vários edifícios, então queremos uma espécie de modificador pelo qual o custo aumenta. E porque temos armazenado ou queijo em uma espécie de CI, armazenamento como um inteiro, provavelmente vamos ter este ser um modificador que também é um inteiro. E este vai ser o modificador de custo de dois. Então nós vamos apenas aumentar o preço duas vezes, uma vez que o edifício real é construído. Também podemos querer uma lista de todos os edifícios. Então esta vai ser uma lista estática do tipo um edifício chamado de edifícios. E isso será acessível através de duas coisas específicas. Um deles vai ser uma propriedade. Então nós vamos ter realmente uma propriedade estática chamada lista. Então esta vai ser uma lista de edifícios chamado edifício, nota de construção. Agora que vai ser a construção em instâncias de construção. E isso vai ter um get ou uma maneira de obter os edifícios. E ele só vai retornar como edifícios. No entanto, isso é claro, ele tem um problema porque talvez isso seja nulo porque ele aqui em cima, nós realmente não fizemos nada com ele. Então precisamos de uma maneira de inicializá-lo também. E para isso vamos fazer um método de construção de listas estáticas privadas. Então isso vai ser edifícios, construção, que é, nós vamos chamar de construir todas as instâncias de construção. Então a idéia é que nós sempre vamos ter apenas uma instância de um edifício e, em seguida, adicionar isso a uma lista dentro do nosso armazenamento de queijo, por exemplo. Então, mais tarde, quando formos lá, teremos uma lista de prédios aqui que são construídos. E dentro daqui, basicamente, só temos uma lista. Então este seria o edifício da lista. Resultado é igual a resultado. Esta nova lista corretamente de construção e, em seguida, retornar resultado. E no meio aqui, vamos adicionar um prédio. Então, cada vez que adicionamos um novo edifício, nós adicionamos este edifício em particular aqui. E vamos então, por exemplo, e também torná-lo de modo que, se edifícios é igual a nulo, então se faturamento não foi definido ainda, então nós vamos defini-lo apenas chamando construir todas as instâncias de construção. Certo? Então, por agora, isso é provavelmente um passo acima de complexidade neste momento. Agora há algumas coisas aqui, e isso não foi apenas, digamos, escolhido por um capricho. Há, é claro, um monte de pensamento sobre isso, digamos. E agora, podemos pensar, pensar nisso assim. Temos o edifício de classe abstrata e podemos então ter uma lista de edifícios. Então vamos, se tivermos, por exemplo, um clicker, vamos criar um edifício clicker que clica automaticamente. Vamos dizer. A maioria de vocês provavelmente já jogou Cookie Clicker. Esta é basicamente a primeira, mas a primeira coisa que você pode fazer lá. E este edifício Cookie Clicker, basicamente, vamos adicionar através de um novo. Então vamos fazer uma nova turma, ter isto herdado do edifício. E então nós vamos adicionar isso a esta lista aqui. E então nós temos uma instância disso e nós nunca vamos usar o novo clique que eu recebo. Então, isso é basicamente, nós teremos uma instância aqui e, em seguida, sempre passaremos essas instâncias para alguma lista que vamos fazer mais tarde na linha dentro do nosso armazenamento CI. E como armazenamento de queijo será então basicamente precisa , em seguida, chamar o fluxo de caixa de cada um dos edifícios que temos dado para o armazenamento de queijo. E então teremos nossos lucros de queijo, digamos. Então. Vamos, então vamos fazer um novo prédio aqui. Então vamos criar uma nova classe chamada clicker. E vamos abrir isto. Certifique-se de que isto está debaixo de edifícios também. E então isso vai realmente herdar da construção bem aqui. E a primeira coisa que podemos ver, é claro, são correções potenciais. Então implemente classe abstrata. Portanto, precisamos implementar este método de fluxo de caixa, é claro, caso contrário, não funcionará. Certo? E o que vamos fazer é simplesmente fazer o seguinte. Então, toda vez que esse fluxo de caixa é. Frio. O que vamos fazer é dizer armazenamento de queijo, instância de armazenamento de ponto ci, adicionar um queijo agora. Então vamos fazer isso muito, digamos, facilmente feito assim. E então também vamos fazer é na construção de fluxo de caixa. interrogação invocar. E então isso, porque este é o prédio que está basicamente recebendo esse fluxo de caixa. E também precisamos de um, precisamos de uma leitura exatamente o parâmetro não dentro do construtor. Então precisamos de um novo construtor aqui. Então clicker público com custo, o, desculpe, o ganho de queijo inteiro, ela ganha e o intervalo de tempo flutuante. E o melhor é que podemos fazer agora é colocar um cólon aqui chamado base. Então isso vai chamar o intervalo de tempo base. Intervalo de tempo eles vão, Isto vai chamar o construtor de base para o edifício real. Então, dentro daqui, não precisamos fazer mais nada. E este seria o edifício, como eu o construiria. É claro que há inúmeras maneiras pelas quais poderíamos fazer isso de forma diferente. Então, por exemplo, em vez de chamar a instância de armazenamento CI aqui, imediatamente, poderíamos retornar um inteiro com quanto fluxo de caixa esse edifício gera. Portanto, esta não é a única maneira de você fazer isso por qualquer meio. Como se existissem, quero dizer, 1000 maneiras para Roma basicamente. Então todos, todos os caminhos levam a Roma. É incrível quantas maneiras você pode fazer isso é apenas um exemplo disso. E vamos ver. Se voltarmos para o armazém da CI. Basicamente, aqui agora queremos uma lista dos edifícios que foram construídos. Então vamos criar uma nova lista aqui. Então vamos fazer disso uma lista privada de tipo edifício. Por isso, precisamos agora de usar um edifício de edifícios. Nós também podemos simplesmente fazer usando os edifícios de dados clicker de Ela. Isso deve ser um pouco mais fácil agora. E podemos usar todas as aulas lá dentro. E isso também deve ser bom. Certo? Vamos fazer todos os prédios. Então vamos fazer todos os edifícios construídos. Sim, vamos fazer isso. E vamos inicializar isso em vez do método de início. Então, todos os edifícios construídos equivale a uma nova lista de edifícios, modo que isto é inicializado. E então podemos basicamente adicionar a esta lista em particular. Uma vez que temos um, bem, uma vez que construímos um edifício, agora para isso, é claro que precisamos de um novo método. Vou chamar isto de vazio público. Construir, construir, construir. Lá vai você. Com uma instância de um edifício particular. Então construindo um novo prédio. Construir neste ponto já parece uma palavra bastante interessante. Mas acho que está tudo bem. E agora há algumas coisas que precisamos fazer, certo? Então pense sobre isso, ok, o que precisamos fazer para construir um prédio? Bem, precisamos ver, ver se é possível, certo? Então essa é a primeira coisa que precisamos fazer e que deve ser, bem, isso, nós só precisamos ver, ok, o custo do edifício real deve ser menor do que a quantidade de queijo que temos. Então o que podemos fazer é se o novo custo do ponto de construção é basicamente menor ou igual ao queijo que temos. Então podemos construir. Então isso é basicamente olhar como este. Lá vai você, construa. E se não for esse o caso, então podemos dizer algo como não construa algo assim, certo? E assim, sim, espero que isso faça sentido. Então a idéia é que se o edifício custa mais, ou neste caso, custa menos do que o queijo que temos ou é igual ao queijo que temos, então podemos construí-lo. Caso contrário, não podemos. É claro que também temos de subtrair isto. Então, há algum adere, talvez pudéssemos. Basicamente, a única coisa que precisamos fazer é dizer, ok, remover o queijo. Então remova o queijo no auge do custo do novo edifício, certo? Então, simplesmente removemos o queijo com exatamente quanto custa o edifício. Então nós, é claro, queremos adicionar este edifício. Então, todos os edifícios ou construir edifícios agora adicionar um novo edifício. Então isto deve realmente construir o ego. Então, vamos adicionar este edifício dado com este método e adicionado em nossas listas aqui. E então o que vamos fazer é fazer o seguinte. Vamos basicamente usar algo que ainda não vimos antes, que é uma co-rotina. E isso vai ser realmente bastante simples. Então vamos remover as árvores. Nós adicionamos o novo edifício, e agora precisamos de alguma forma ser capazes de ter isso. Tenha o intervalo de tempo, verifique e adicione ao nosso queijo equilibrado, por assim dizer, escreva. E a maneira que podemos fazer isso é definir um a, um enumerador de olhos. Vou explicar rapidamente depois de termos feito isso. Então esta é uma turnê I enumerar. Então este aqui, vamos chamar isso de fluxo de caixa do edifício com um edifício particular dentro do seu prédio como parâmetro. E a grande coisa sobre este numerador de íons é que podemos fazer algo chamado retorno de rendimento. Voltar. E então podemos fazer um novo peso quatro segundos. E esta é a coisa muito fixe. Então podemos esperar por uma quantidade particular de segundos. Então, este método leva um flutuador por segundos. E o que podemos fazer agora é porque estamos dando um prédio a ele. Podemos dizer o intervalo de tempo do ponto de construção. Então ele vai esperar exatamente pelo intervalo de tempo do edifício particular dado aqui. E depois que isso for feito, então, se depois disso for feito, então ele continuará com esse método. Então vai esperar aqui. Neste método em particular, tudo o resto ainda vai funcionar, então é uma espécie de paralelo. Isso vai esperar até os segundos ou mais. E uma vez que isso acabe, isso vai continuar. Então, vamos dizer que isto é Building Dot fluxo de caixa, na verdade. Fluxo de caixa eles vão. E porque isso adiciona o queijo, como eu disse, neste caso, nós também podemos simplesmente devolver um inteiro e adicionar o queijo aqui. Ambos funcionariam. Vamos fazer assim por enquanto. E isso é totalmente bom. E depois, no final disto, porque o que vamos fazer é só chamar este de dentro de si mesmo. Vamos ligar para isso outra hora. Então este seria, este é o método de co-rotina inicial. E dentro dele, nós simplesmente chamamos de construção de fluxo de caixa. E exatamente isso que queremos colocar aqui também. Então este é um comportamento mono. Este é, claro, um edifício novo. Agora o ego. O que é um tipo de co-rotina no que dizemos? Então a idéia de uma co-rotina é que vimos isso, o método invoke para antes. Isso era parte do comportamento do modelo. E o método invoke nos permitiu basicamente chamar um determinado método um certo número de vezes, você sabe, a cada x segundos, por assim dizer. E a co-rotina é algo muito parecido com isso. Em vez de uma co-rotina, se é uma espécie de um, você pode pensar que este é um tipo de método assíncrono que pode esperar por um determinado segundo. E, em seguida, podemos também, se apenas dar uma olhada neste rendimento retornar novo peso para o final da atualização de quadro fixo. Podemos esperar até, podemos fazer esperar um pouco e, em seguida, também com segundos em tempo real. Então, há algumas coisas que podemos fazer com isso. Agora mesmo. Nós só vamos usá-lo basicamente, dois vão gerar nosso fluxo de caixa. Isso também é algo que poderia ser feito dentro do próprio edifício. Então podemos adicionar esses fluxos de caixa dentro do próprio prédio e começar lá. Neste momento, acrescentámos aqui, e penso que isso também vai ficar bem. Também faremos um aviso de log de pontos de depuração. Não posso construir porque não há queijo. Então isso é só uma pequena mensagem aqui. Nós sabemos que, hey, nós não podemos realmente construir este edifício. modo geral, penso que isto deve ser basicamente tudo o que temos de fazer para construir este edifício. Agora, há mais algumas coisas que precisamos acrescentar. Então número um, é claro que precisamos adicionar que a instância aqui. Então, dentro do nosso resultado, adicione novo clicker. Então, aqui mesmo, vamos adicionar um novo clicker. Esta é a única vez que vamos realmente chamar este novo clicker aqui. E então queremos adicionar isso com custo particular, ganho de queijo e um intervalo de tempo. Então vamos apenas dizer que isso custa 10 e vai ganhar um novo queijo por segundo. Então isso é o que isso significa neste caso. Então o custo é 10. 10, temos o ganho seria um por segundo por 1 segundo. Vamos fazer assim. Sim, eles vão. E, claro, isso é personalizável. Você pode pensar sobre isso porque, é claro, isso precisa ser ajustado para o equilíbrio, por exemplo, certo? Se você tem vários edifícios, então talvez eles queiram lançar diferentes e seu ganho poderia ser diferente também. E aqui é basicamente onde você faria, no nosso caso aqui, a maneira que eu construí e a maneira como você provavelmente irá construí-lo. É assim que fazemos aqui. Claro, mais uma vez, há um milhão de maneiras de fazer isso. E há uma última coisa que precisamos fazer, porque agora estamos apenas recebendo o custo e não vamos mudá-lo. Então, há várias maneiras de fazermos isso. Podemos dizer, bem, podemos mudá-lo aqui, ou poderíamos ter outro método aqui. Vamos realmente fazer o seguinte. Vamos realmente adicionar um int privado porque, em vez desta forma, lá vai você. Custo privado. Sim, exatamente. E então nós vamos, em vez de um edifício mudar o custo aqui, na verdade nós podemos mudar a constante, tudo bem. Vamos mudar esta propriedade um pouco para cima. Então isso vai ser um custo de retorno, certo? Então, vamos apenas devolver um custo aqui. E a única configuração, o que vamos fazer é dizer que o custo é igual ao valor. Então isso é apenas para que tenhamos uma variável extra privada aqui. E então podemos basicamente mudar este. Então o que podemos fazer é agora adicionar um novo método aqui que vai ser público, inteiro público, recebe custo e aumentar o custo. Vamos chamá-lo assim. Isso é bom. Então o que vamos fazer é ter o custo igual aos custos reais aqui, devolvendo isso depois. E exatamente, então nós basicamente salvamos isso antes de aumentá-lo. Então vamos dizer, podemos dizer que o custo é igual a, podemos apenas dizer vezes iguais ao modificador real, modificador. Eles vão, certo. E então se chamarmos isso, nós dois obtemos o custo e também aumenta. Então vamos fazer isso dentro do armazenamento em uma espécie de armazenamento de queijo em vez de aqui, basta dizer remover o queijo pelos tempos de custo. Na verdade, vamos dizer tempo, obter custos e aumentar custos também. Certo? Então, como podem ver, há muitas coisas acontecendo aqui. É um pouco, mas um passo de cada vez, e acho que vai ficar tudo bem. Então, por agora, o que vamos fazer é simplesmente adicionar um, uma entrada onde podemos basicamente construir este edifício. E então vamos fazer um novo objeto de jogo que podemos, podemos clicar. Mas agora vamos apenas adicionar um código basicamente chave. Então este seria o código chave. Veja, digamos para Clicker, é claro. E quando pressionarmos isso, vamos querer acontecer? Bem, nós queremos que isto seja construído, um edifício para ser chamado basicamente e então agora precisamos de um edifício lá. Ok, deixe-me pensar sobre isso. De onde podemos conseguir esse prédio? Bem, temos uma lista de prédios aqui, certo? E então nós adicionamos a isso, e isso é estática pública. Então, em teoria, se pensarmos sobre isso, devemos ser capazes de acessar essa lista de todas as instâncias. E sabemos que o clicker agora é a primeira instância. Então este seria básico ou o primeiro edifício dentro desta lista. Então isso deve ser viável fazendo um prédio. Então este é o ponto da classe. E então temos instâncias de construção. Esta é a lista. E, em seguida, apenas obtendo o um no índice 0. Então isso retornará exatamente essa classe aqui que criamos. E se tudo funcionar, então este é o clicker e o custo será, bem, dez. Se tivermos estes dez queijos, vamos construí-lo. E então ele vai remover isso, aumentar o custo deste edifício. Vamos adicionar isto à nossa lista de edifícios. E então também vamos começar a co-rotina de fluxo de caixa, que vai ser executado a cada segundo no nosso caso. Bem, vamos esperar que isso realmente funcione e que realmente faça o que queríamos fazer. Há um monte de coisas como um monte de peças entrelaçadas neste caso. E sim, acho que podemos começar e tentar isso. Então a primeira coisa que fazemos é claro que agora temos um queijo 0. E se eu pressionar a tecla C, o que esperaríamos é dizer, não posso construir um prédio porque não tenho queijo suficiente. Então vamos ver e não podemos construir porque nodo queijo. Então isso é muito bom e ela também não aumenta por conta própria. Então eu posso agora pressionar a tecla de mais e eu tenho dez queijo aqui mesmo. E agora a grande coisa é, funciona ou não funciona? Então eu pressiono C e bem, diminuiu o número de queijos que temos. E como você pode ver agora, nosso queijo está aumentando em um a cada segundo. Agora, a grande coisa é que ganham antes disso. Bem, isso é apenas remover nossos dez Jesus novamente com a chave de menos. E se eu ver de novo agora, bem, como você pode ver dois, então eu ainda não tenho dinheiro suficiente agora ou queijo suficiente agora às dez, eu deveria ter o suficiente. Mas como você pode ver, não funciona porque eu modifico nosso direito aumentado, então agora custa 20 queijos e se eu pressioná-lo agora, como você pode ver, ele construiu e agora nós estamos realmente chegando ao queijo por segundo, porque agora nós temos dois esses clickers, clique a cada segundo. Cada um de nós basicamente comprando um queijo por segundo, certo? Isso é ótimo. Isso realmente funcionou. Quero dizer, totalmente bem. Como você pode ver claramente, podemos ter vários edifícios do mesmo tipo. E agora adicionando um edifício, e isso é basicamente o que é uma das coisas mais importantes quando você faz algo assim, você sempre precisa pensar sobre sua capacidade de adicionar mais coisas que você quer adicionar , certo? Então a questão habitual pode ser, bem, nós poderíamos complicar essa loucura. E para alguns deles, para algumas das ideias. Se você ver isso da primeira vez, você pode ser como, Uau, isso é realmente muito de uma vez e eu não discordo. É pode ser muito no começo. Mas passo a passo, se você pensar em cada uma das partes individuais que não são tão complicadas, apenas para montar, eles podem criar algo que é realmente bastante complexo. E sim. Agora, como você adicionaria um novo prédio se você estivesse nesta fase, como você adicionaria um prédio? Bem, você só precisa de uma nova aula aqui, certo? Então nós podemos realmente fazer isso apenas por causa do argumento, apenas para que uma vez que você tem um tipo de terreno com coisas fundamentais configuradas, quão fácil poderia ser adicionar um edifício. Então vamos fazer um novo prédio e vamos chamar isso de estação de ordenha. Porque é isso que eu quero dizer, foi isso que eu inventei. Acho que é a melhor explicação que tenho. Isto é claro, mais uma vez, dentro do espaço de nomes dos edifícios e este será um edifício. E a grande coisa agora é que, bem, nós podemos meio que apenas o clicker aqui, apenas por um momento. É claro que esta será a estação de construção aqui. E o fluxo de caixa, basicamente exatamente o mesmo, mas talvez queiramos um número diferente de queijo ou isso também é uma coisa interessante. Na verdade, adicionei um aqui. Isto devia ser este ponto. Ela ganhou. Não é como se isso não fosse um problema que possa se deparar, mas tudo bem. E então dentro daqui, vamos fazer a mesma coisa, este.Tab ganho de queijo. E já é isso. Então este é o número um, passo 1, passo 2, adicionando isso aqui para que possamos copiar isso e dizer estação de ordenha. E então nós só precisamos saber, ok, quanto vai custar, quanto vamos conseguir por segundo? Então, digamos que isso custe 25. E neste caso o que vamos conseguir é, digamos que vamos ter cinco queijos, mas apenas a cada dois segundos. Então podemos dizer que o custo é de 25 a 50, cinco queijos a cada dois segundos. Então, é claro que isso é realmente um valor melhor no primeiro caso em comparação com o clicker. Mas sim, isso é muito bom. Mas é claro que você precisa 25 queijos para construí-lo. Em teoria. Se agora adicionarmos um novo tipo de chave que, para que possamos construí-la. Por isso, vamos fazer-me aqui. Agora sabemos que a instância existe um. Isso, claro, também poderia ser um, isso também poderia ser um dicionário, certo? Onde você, em vez de fazer isso com o interior, com os índices, você poderia fazer isso com uma enumeração. Então você teria enumeração de um edifício e ter cada um dos edifícios lá também e poderia acessá-los como isso tudo funcionaria. Basicamente, a mesma ideia. Então, agora, se eu pressionar M, eu imaginaria construir um, uma estação de ordenha agora. Certo. Então vamos ver se conseguimos realmente fazer isso. E sim, foi isso por adicionar o novo prédio. Se você quer coisas especiais acontecendo com este edifício em particular , é claro, então é um pouco mais complicado. Mas, neste momento, isto deve funcionar. Então vamos ver se isso realmente funciona. Então, primeiro de tudo, pressionando a tecla M , eu não tenho queijo suficiente para isso. Então vamos pegar 30 queijo e então eu vou pressionar o conjunto vazio subtraiu 25. Ela é, e como você pode ver, cada dois segundos nós vamos pegar cinco queijos. Então isso funciona perfeitamente bem também. E isso é muito bom. Agora, é claro, não temos nenhum indicador visual ainda. Nós realmente não temos uma interface do usuário porque nós não somos realmente, nós não falamos sobre a interface do usuário realmente. Podemos pensar em adicionar apenas uma espécie de texto simples, claro, porque vimos a adição de textos simples, que, que funcionaria. Mas, no geral, isso já funciona. Então, se eu percebo um monte de vezes agora, agora não funciona mais porque agora me custa realmente 80 eu acho que já porque eu construí muitos. E agora, como podem ver, o queijo está entrando assim sem fazer mais nada. Então isso é muito bom, isso é muito bom. E sim, isso seria para a palestra sobre como adicionar prédios. Mais uma vez, esta é uma das maneiras que você pode fazer isso. Quero dizer, provavelmente há mais 1000 maneiras de você fazer isso. Mas eu estou bastante feliz porque isso é muito expansível. E você pode expandir isso. Claro, há poucas coisas que você pode adicionar, especialmente mais um ou mais alguns edifícios por conta própria. Mas sim, foi isso para esta palestra. Da próxima vez vamos adicionar um GameObject que podemos clicar para basicamente construir nossos edifícios. E isso é algo que estamos mais tarde na linha. Eu vou então me transformar em uma interface de usuário. Então, vamos adicionar algumas coisas aqui. Próxima palestra. E sim, mas foi isso para esta palestra. Espero que você tenha achado útil se há alguns pontos em que isso tenha sido um pouco confuso porque nós pulamos um pouco de classe em classe e assim por diante. Então sinta-se livre para, número um, eu primeiro diria, você sabe, o que deveria novamente, talvez pensar sobre isso um pouco. Olhe para a classe. Se você baixá-lo ou se você programou para simultaneamente, então talvez olhe um pouco, tente entender cada uma dessas etapas e cada um dos métodos que implementamos e pense nisso assim. E se as perguntas permanecerem, é claro, sinta-se sempre à vontade para perguntar e eu vou ter certeza de responder. E sim. 69. (Clicador de queijo: Tudo bem, vamos continuar com o clicker de queijo aqui para o curso de união. Nesta palestra, vamos adicionar uma interface muito simples, bem como a possibilidade de adicionar os edifícios através de um clique em um objeto de jogo. E esses objetos do jogo serão elementos da interface do usuário, principalmente botões. E eles vão bem então apenas funcionar uma forma onde podemos clicar em cada um deles para cada um dos edifícios que temos. E eles vão, então, basicamente, desovar em um prédio. E eles também mudarão. Assim, eles vão exibir basicamente o custo e também quantos edifícios existem, cada tipo particular. E também teremos um texto que mostra a quantidade de queijo que temos no momento atual. Então, basicamente h, ele é contra, você poderia dizer, primeira coisa, nós queremos o queijo, a interface de armazenamento de queijo. Então, pessoalmente, eu sempre termino meus scripts de interface do usuário com UI. E depois, no início, sejam lá o que forem. E isso vai ser queijo decker você, eu é claro, como em termos de namespace, nós também estaremos usando Unity engine dot IM para isso. A primeira coisa que precisamos é de um texto privado. Segure o queijo. Vamos apenas dizer, veja, eu posso conseguir mensagens de armazenamento. Lá vai você. Isso é um, isso é um bocadinho, um ir. E isso será simplesmente enquanto entramos aqui. Então isso vai ser se o texto de armazenamento de queijo é nulo, então vamos apenas definir o armazenamento vinculado a este ponto obter texto componente. Então vamos usar o componente Get neste script propriamente dito. E, em seguida, ele simplesmente obtém o componente do objeto de jogo do texto do tipo que este script específico está anexado. E então vamos para o ponto de armazenamento de queijo na quantidade de queijo. Então ela mudou. Então esta é a ideia. Se o queijo mudar, então vamos chamar um método específico. Isso vai ser apenas alterar o método de número. Isso vai chamá-lo. Não precisamos do método de atualização aqui neste vazio privado do transportador. Alterar um número com uma nova quantidade porque este é exatamente o este é exatamente a assinatura método que precisamos para a quantidade de queijo de mudança delegado aqui. E o que isso vai simplesmente fazer é que ele vai obter os textos de armazenamento de queijo, textos iguais a uma nova quantidade que é ToString. Então vamos simplesmente mudar o texto aqui cada vez que o queijo mudar. É por isso que eu disse que essa é uma boa idéia adicionar aqueles eventos que você nunca sabe quando você vai precisar deles. Claro, você sempre pode adicioná-los mais tarde na linha também. No entanto, neste caso, vai ficar tudo bem. Então vamos pensar sobre isso, adicionando um elemento de interface do usuário aqui. Então, clique com o botão direito do mouse dentro de nossa interface de usuário de hierarquia e, em Então, é claro, precisamos mudar a tela mais uma vez para a câmera de espaço de tela e arrastar a câmera principal para cá. E então o nosso texto está em baixo. Eles são muito pequenos e vamos torná-lo um pouco maior. E então também torná-lo o texto real um pouco maior, algo como talvez 50. Ah, isso é muito pequeno. Um 120, adorei. E nós teremos na verdade dois textos, então vamos duplicar este Controle D. Este vai ser o rótulo do queijo, digamos. E isso vai ser só queijo. E o outro é o texto de armazenamento de queijo. Sim, isso é bom. Vai ser um 0 por enquanto. E então nós também vamos fazer isso um pouco mais bonito. Então vamos fazer algo assim. Este é o texto do queijo. Lá vai você. E então este também pode ser um pouco menor. Eles vão, certo? Então agora temos isso. Nós também vamos fazer ambos os brancos apenas para que possamos ver isso um pouco melhor. Sim, acho que está tudo bem. E então se isso fosse sim, então isso funciona bastante bem. E para esses textos de armazenamento de queijo C, vamos simplesmente adicionar o script de interface do usuário que fizemos aqui. Lá vai você. Isto não é advogado? Bem, veja o ego. Sempre abre o material. Eles são uma espécie de barulho para ir. Ok. Ela está armazenada para mim agora está lá. E isso deve realmente já funcionar totalmente bem, porque nós adicionamos este evento. E como isso funciona através do evento, tudo deve funcionar imediatamente. Isto é, como eu disse, os delegados sobre os eventos realmente útil para o para a capacidade de expansão do seu projeto. Então adicionar isso foi bastante fácil. Então vamos ver se isso realmente funciona. Então, se eu clicar nisso, como você pode ver, ele aumenta para dois. Eu também posso trapacear. Então, se eu pressionar o mais e o negativo, isso também funciona. E se eu agora fosse, por exemplo, adicionar um clicker pressionando C, ele irá subtrair isso. E agora a cada segundo ele irá atualizar o seu também. E isso é muito melhor do que ter isso em uma espécie de método de atualização onde verifica cada quadro. Porque não precisamos alterar a interface do usuário de cada quadro porque ele não muda cada quadro. E essa é uma espécie de idéia por que este evento, o evento, um sistema delicado neste caso, é como incrivelmente superior a qualquer outra coisa que poderíamos implementar nesse caso. Certo? E agora nós basicamente queremos jogar objetos que podemos clicar em vez de pressionar C e pressionar M para criar novos edifícios que você está escrevendo, nós vamos realmente criar uma interface real para isso neste caso. Então eu vou tipo de levar um pouco para o futuro do que vamos ver um pouco mais tarde na linha. Algumas dessas coisas podem não ser 100% compreensíveis, mas estou tentando explicá-las da melhor maneira que eu vou. Então, a primeira coisa que queremos é que queremos algo que é chamado de UI de construção. Então este edifício UI é basicamente vai ser a classe que vai tipo de, isso vai garantir que nós sabemos, ok, Que tipo de edifícios nós temos e podemos construir? E também permitirá e desabilitará certas coisas de serem construídas com base no custo. Então, para isso, temos botões. Então, há uma maneira muito fácil de fazermos isso. Vamos adicionar algo ao nosso Canvas. Então clique com o botão direito do mouse na interface do usuário e, em seguida, vamos adicionar um painel aqui. O painel é apenas uma espécie de fundo e nós vamos adicionar isso ao lado aqui. Eu gosto disso. E depois vamos ter que ir a este painel. Vamos adicionar outro painel louco o suficiente e fazer isso um pouco menor bem aqui. Então eu acho que isso é bom. Este seria o painel dos edifícios. E este é então um edifício painéis. Então este é o painel de um edifício em particular neste caso. E nós também vamos adicionar alguns ativos aqui. Então eu tenho um clicker, eu tenho uma vaca para a estação de ordenha, e eu também tenho um barril para outra coisa que poderíamos querer adicionar. Então estes são os barris, vamos ver aqui. Então nós temos os barris a que nós realmente queremos cerca de 500 pixels aqui, modo que eles são um pouco menores também, claro, não bi-linear eletrônico, bem, eu acho que são grandes o suficiente. A vaca e o clicker. Então, a conta do clicker deve ser 150. E vamos mantê-lo por linear, bem como porque é bastante grande e o clicker que é 250 e este é definitivamente ponto. Sem compressão. Sim. Então agora podemos pensar sobre isso. Ok, este é um painel para um edifício em particular. E também podemos pensar nisso como um botão. Então nós queremos basicamente fazer este um botão que podemos clicar e, em seguida, ter este bem construído ou edifício, se isso é possível. Então agora, isso é apenas um painel, mas podemos simplesmente ir para Adicionar Componente, ir para seus olhos e adicionar um botão. E agora isso seria um botão. E isso pode desclicar, fazer algo específico. E isso vai fazer o que realmente dissermos para fazer. Mas não queremos adicionar isso manualmente. Queremos adicionar isso com 0. Não podemos manualmente, mas nós realmente gostaríamos adicionar isso com o script real. Neste caso, vamos somar isso manualmente, então vamos chamar isso de outro script. Então vamos chamar isso de Build UI. Então é um monte de scripts diferentes, mais uma vez que precisamos, vamos realmente fechar de alguns aqui agora porque nós realmente não precisamos deles no momento. E essa interface de usuário de compilação será basicamente a única que determina, ok, o que acontece aqui, qual edifício é construído. E podemos basicamente fazer algo assim. Podemos basicamente dar uma chance a isso. Vamos realmente fazer o seguinte. Então vamos fazer isso. Podemos apenas dizer público, construção vazia. E isso vai ter um, um índice particular aqui. E isso simplesmente fará o seguinte. Então nós vamos adicionar, simplesmente indo para dizer instância de ponto de armazenamento de queijo. Então nós vamos pegar a instância do depósito de queijo e então nós temos o prédio de construção aqui. E então, é claro, precisamos dar um novo prédio. Mas podemos fazer isso, em primeiro lugar, indo aqui usando os prédios de ponto clicker de Ela. Também. Apenas certificando-se de que isso está sob UI para que tenhamos tudo limpo e arrumado. E, dentro daqui, podemos dizer um prédio. Instâncias de construção de pontos. Index, eles vão. Assim, podemos especificar um índice particular de um edifício que deve ser construído dentro da instância de armazenamento de chave. Então isso é exatamente a mesma coisa. Se olharmos para o nosso armazenamento de queijos assim que isso for recarregado, podemos ver que isso é exatamente o que fizemos aqui. Então nós chamamos isso em outro roteiro. Foi tudo o que fizemos. E então também as instâncias de construção que, na verdade, é tudo o que realmente estamos fazendo aqui. E estamos fazendo isso com esse painel em particular. Então e, em seguida, o que fazemos é adicionar esta interface de usuário de compilação para este painel aqui. Uma vez que isso é realmente adicionado, Vamos ver. Lá vai você. Agora está aqui. E então nós podemos fazer é este tipo de campo onclick aqui. Se pressionarmos isso mais, então podemos dizer, então podemos olhar para este e clicar neste ponto lá e dizer, Bem, eu quero que este seja o edifício UI. E agora onclick, e, em seguida a interface do usuário do edifício vai ser executado ou algo assim então lá. E como você pode ver, e nós realmente não temos isso porque eu, claro, porque nós não podemos realmente fazer a interface do usuário do edifício, nós realmente, que é meio estranho, nós realmente temos que adicionar a ele. Então nós realmente temos que pegar este painel de construção e arrastá-lo aqui para que agora os painéis de construção lá dentro. E, em seguida, se olharmos aqui, o Build UI e, em seguida, construído com um inteiro particular , neste caso, 0 é exatamente certo porque o primeiro vai ser o clicker. E agora vamos tornar isto um pouco mais visualmente atraente. Então vamos adicionar algumas coisas aqui. Então, em primeiro lugar, clique com o botão direito do mouse no texto da interface do painel de construção, tornando isso um pouco maior aqui. E então vamos dizer font-size 50. Sim, isso parece certo. Vamos torná-lo um pouco maior. 70, tudo bem. Este vai ser o clicker. E vamos também centralizar este tipo de aqui. Poderíamos, por exemplo, acrescentar também o montante do custo, algo assim. Mas agora, vamos realmente apenas adicionar o clicker por enquanto para que tenhamos algo em que possamos clicar. E vamos também adicionar uma pequena imagem agradável. Então esta é a imagem aqui. E podemos fazer isso um pouco maior. Podemos escalá-lo. Pressionando velho, podemos escalá-lo a partir do meio. E então eu estou pressionando Shift. Podemos fazer isso o específico O que você diria resolução varas e inserir a imagem aqui. Podemos dizer “sprite”. Então podemos simplesmente pegar o clicker, colocá-lo lá, e eles vão. Agora nós realmente temos isso como um bom homenzinho que podemos clicar. E uma vez que clicarmos nisso, devemos criar um novo clicker. Vamos ver se isso é tudo o que precisamos fazer. Mas eu estou realmente bastante certo de que nós, que este é agora construir UI. E sim, então vamos tentar isso. Então isso já deve funcionar. Então agora se eu clicar nisso, devemos pegar, eu não tenho queijo suficiente. Como você pode ver, junto com nenhum queijo. Vamos nos enganar dez queijos. E se eu clicar nisso de novo, devemos ver o queijo ser subtraído. E então o clicker construiu o objetivo e ele funciona. Bem, isso é muito legal. Isso já funciona. Agora a maneira e isso é, isso é muito legal. Como eu disse, podemos adicionar mais algumas coisas a isso agora. Então vamos realmente, vamos realmente mover isso um pouco para cima e, em seguida, adicionar um pouco mais de texto aqui. Então, o primeiro texto que vamos realmente, vamos apenas copiar o clicker. Então, mais uma vez, selecionando isso e controlando um D2, basta copiar isso. Vamos fazer um grande número aqui. Este vai ser o número de clickers que temos. Então este seria, digamos, números, número, edifício, camisa número edifício. Por que não? Então esta seria a etiqueta de nome que estou construindo. Então, certifique-se sempre de que você tem um nome apropriado aqui. Porque se você olhar para isso talvez um pouco mais tarde na linha, então você vai dizer, o que foi isso? Esta é a imagem do edifício. Esse é o número que está construindo este 0. E vamos fazer isso um pouco maior. Então vamos fazer isso como um 100. Sim, isso é ótimo. Como 100 mil, certificando-se de que isso não desapareça. E então também podemos adicionar um custo. Então isto seria, mais uma vez, copiando este ano, estamos duplicando de A para D. Este seria então o custo. E vamos apenas adicionar 0 aqui também. Vamos, na verdade, 10. Então esse é o custo que sabemos. Ainda assim. Vamos mantê-lo assim por enquanto. Isso, como eu disse, parece, não parece muito legal ou, você sabe, nós realmente não temos nenhum rótulo lá ainda. Mas isso vai ficar bem. Vamos então, em nossa visão de nossa pasta de ativos, adicionar uma nova pasta chamada prefabs. Agora nós já vimos isso porque o que vamos fazer agora é fazer um pré-fab deste painel de construção aqui. Então nós estamos indo para rapidamente scooted até lá o painel de construção do ego. E a grande coisa sobre isso é que agora podemos simplesmente adicionar isso novamente aqui. Então, temos isso duas vezes. Este seria, a propósito, o painel de construção clicker. E este é agora o painel do edifício da ordenha. Vamos mover o painel de ordenha um pouco para baixo e mudar as coisas que precisamos mudar aqui. Então a primeira coisa que queremos mudar é que a imagem, é claro. Então esta vai ser a vaca. Agora, desde o clicker aqui, vamos ter a vaca. Quero dizer, isso não é tão incrível. E em vez do nome aqui, vamos ter a estação de ordenha. Então isso é um pouco grande, então vamos aumentar o tamanho aqui um pouco. E o objetivo, o custo também vai começar em 25. E agora nós de alguma forma, de alguma forma, esse é o verdadeiro ponto aqui. Precisamos mudar as coisas individuais lá dentro. E como fazemos isso? Bem, vamos fazer isso com essa interface de usuário de construção que já criamos, mas ainda não usada. E isso mais uma vez, como eu disse, pode ser um pouco mais complicado. Vamos primeiro de tudo fazer UI aqui para que tenhamos isso dentro do namespace certo. E sim, vamos começar e eu vou. Vou explicar à medida que avançamos. Então, primeiro de tudo, vamos ter um dicionário de construção. Na verdade, precisamos. Usando esse namespace também. Então isso vai ser, ela está piscando fora de prédios. E este vai ser um dicionário de construção para GameObject. E isso vai ser construindo coisa Bill para basicamente durante a construção para painel de construção. Vamos chamá-lo assim. Sim, isso é bom. Vamos inicializar isso dentro do método de início com um novo dicionário. Então, isso é muito fácil de fazer. E então vamos pensar sobre isso. Então, agora temos um dicionário. Podemos basicamente uma mudança. Algumas coisas aqui. Por que precisaríamos de dicionário? Bem, a ideia é que teremos um edifício em particular que está sendo um painel em particular que está sendo clicado e que está associado ao prédio. Nós também podemos ter a associação ao contrário basicamente. No nosso caso, não tenho 100% de certeza de que precisamos disso ainda, mas é bom ter isso aqui já. E vamos ver, int I é igual a 0. I é igual a contagem de filhos transform.py. Então vamos contar as crianças. E então o que vamos fazer é ver o painel de edifícios, um painel adicionar. E vamos ver prédios construindo instâncias de ponto. I é igual ao filho transform.py de I dot GameObject. Isso pode parecer loucura o que estamos fazendo aqui. Mas a ideia real do que estamos fazendo é que estamos passando pelo número de crianças que esse objeto de jogo em particular tem, e então adicionando as instâncias. Então este é simplesmente um edifício de nossas instâncias de construção com o mesmo, digamos índice aqui, então o índice filho. Então, a ideia é que se adicionarmos este edifício UI para os edifícios reais, eles vão para este painel de edifícios reais. E podemos pensar, bem, as crianças são mais uma vez, o painel de construção clicker e o painel de construção de ordenha. Então essas são as crianças, a criança 0. Esta é a criança 1. Ok. Isso, na verdade, eu meio que entendo, espero. E estes são então simplesmente associados com o edifício dentro da nossa lista de instâncias de construção. Então, sim, e agora se voltarmos aqui, isso é simplesmente salvar neste dicionário. E isso é realmente tudo o que há para ele. E o que vamos fazer no começo aqui é que vamos passar por isso mais uma vez. Então vamos dizer 0, eu é menor do que. E agora vamos passar pela contagem de instâncias de construção aqui. O que deve ser, então, em teoria, esta contagem e esta contagem devem ser sempre a mesma, porque para cada edifício teremos sempre um painel diferente. E para cada painel, é claro, teremos um edifício associado a ele. E nós podemos, então, basicamente , na verdade , então nós podemos muito bem passar por isso através do painel de derramamento, certo? Então. Podemos conseguir isto. E então com os colchetes pode dizer , ok, deixe-me pegar as instâncias I. Então por que isso é uma construção tão louca? Bem, precisamos dar a isto o edifício que está associado a ele. Há um dicionário. Temos de lhe dar um edifício. E então teremos de volta um objeto de mira específico. Então nós vamos realmente recuperar o objeto do jogo, o próprio painel, e este painel, nós teremos que obter o componente de um botão, certo? E então nós vamos fazer é que vamos dizer o botão é claro, requer motor Unity, usando Unity motor que UI I-lo. E este botão, vamos simplesmente dizer interactable é igual a false. Agora, por que fazemos isso? Quero dizer, em primeiro lugar, todos também, podemos simplesmente fazê-lo neste também. Então não é como se tivéssemos que fazer isso aqui. Este é apenas um exemplo de como você acessaria o dicionário basicamente. Mas sim, então por que definir o interactable igual a falso? Bem, para que possamos interagir com o real com o botão real. Porque só devemos ser capazes de interagir com este botão. E quando tivermos queijo suficiente no banco, certo? Porque isso seria inteligente. Nós temos o aviso e isso é bom também. Mas não seria ótimo se só pudéssemos interagir com o botão e apenas construir o edifício real se tivéssemos queijo suficiente no banco. E isso é basicamente o que queremos implementar aqui. Então teremos algumas coisas que realmente queremos. Então, a primeira coisa é que basicamente temos o edifício construído edifícios, então em construção construído em vez vai ser adicionado quatro a um ou um método específico é adicionado a este evento. E este vai ser o número de atualização de edifícios. Então, isto é, vamos implementar este método em breve. E, em seguida, outro método que queremos, que é até o host de atualização. Então essas duas coisas vão atualizá-lo dentro do olho. Estes já são atualizados dentro do custo de atualização especialmente é atualizado dentro dos edifícios em si já. Mas agora queremos vê-lo visualmente. E também temos o ponto de armazenamento de queijo em que ela mudou. Então, se a quantidade de queijo muda, então podemos querer atualizar a capacidade de cliques. Acho que está escrito corretamente. Espero que sim. Certo? Então esses são três dos métodos que queríamos adicionar aqui. Então o primeiro, número de edifícios, podemos basicamente clicar com o botão direito do mouse em ações rápidas e, em seguida, apenas dizer Gerar método aqui. Lá vamos nós. Vamos também gerar esse método, e vamos gerar esse método. Por último, mas não menos importante. Lá vai você. E sempre temos isso com a assinatura do método correto também. Deixe-me realmente mudar isso um pouco, porque eu, em minha referência, em minhas referências, eu tenho isso um pouco diferente. Então, vamos começar realmente no topo. Atualize o número de edifícios. Bem, como no mundo podemos atualizar o número de edifícios? Então é exatamente isso que temos aqui, certo? Então, temos este campo de texto de construção de número que queremos adicionar ou alterar dependendo. Muitos edifícios que são de um tipo particular. Como é que isso vai funcionar? Vamos ser reais. Isso é loucura. Bem, na verdade não é tão ruim. O que vamos fazer é fazer um loop foreach. E isso para cada loop vai passar pelo par de valores de chave. Isto é exatamente o que é armazenado dentro de um dicionário aqui de construção e GameObject. Então, queremos passar pelos pares de valor de chave. Então par chave-valor, nós vamos apenas chamá-lo assim dentro de nossos edifícios para construir painéis. Então vamos passar pelo dicionário com um loop foreach. E então vamos dizer se o par de valores de chave real que temos aqui, direita e esquerda é igual ao prédio que estamos passando. Então podemos fazer coisas. Agora, quando é que isto é verdade? Isto é verdade. Então, basicamente, vamos passar por cada um dos prédios. Vamos ver cada um dos painéis que temos agora. Só temos dois painéis, certo? Então não temos tantos painéis, mas temos dois painéis. E nós vamos dizer, ok, se o novo edifício que foi construído é igual a alguns painéis. Então digamos que construímos uma nova estação de ordenha, então será igual a este painel e a este painel que será então teremos acesso a este painel, exatamente isso. Então, temos acesso a este painel fazendo valor de par chave-valor. Porque agora sabemos, ok, o edifício que foi construído era a estação de ordenha. Isso é igual à chave. Portanto, bam, vamos. E o que vamos dizer é transform.py criança 0. Então, isso é muito realmente obter texto de ponto de texto do tipo componente. E então vamos dizer, vamos realmente precisar, é claro, avaliar esse número? Então o que vamos dizer é que vamos ter um novo número aqui, número inteiro. Isso é basicamente isso, certo? Então, o que já está escrito nele, que não precisamos salvá-lo em nenhum outro lugar. Assim, adote textos, é claro. Eu vou explicar isso também. Então, na análise simplesmente pega um, uma string e converte-o em um inteiro se for um inteiro real, certo? Então, em vez deste texto aqui, o que queremos é que isto seja, temos um 0 salvo e também precisamos ter cuidado com o Aya real. Claro que sim. Temos também de ter cuidado com a verdadeira posição desta situação. Então vamos mudar isso em vez de uma pré-fabricada novamente. E diga, ok, o número do prédio está na verdade no topo. Então esta seria uma criança 0. Em seguida, o nome da etiqueta vai ser Criança 1. Então, com o índice um, então teremos o custo. E então a imagem vai ser no final. Agora a imagem não muda. Talvez queiramos que a imagem mude em algum momento, mas agora a imagem não mudará. A única coisa que é uma espécie de mutável é o custo do edifício e o número do edifício. Então vamos mudar isso. E então, como você pode ver, ele realmente também mudou aqui porque esses dois GameObjects estão associados a este prefab. E uma vez que alteramos o prefab, também vamos alterá-los para objetos de jogo. Ok, vamos pensar sobre isso. Então agora, basicamente, temos exatamente isso. O primeiro objeto de jogo lá. E os textos lá é o número de é o número de objetos. De é igual ao número de edifícios que são uma espécie de inexistência. E então nós simplesmente vamos dizer, bem, este número deve ser apenas mais igual a um. Então nós queremos economizar, então nós só queremos aumentar esse número em um e então salvar isso de volta exatamente para isso. Mais uma vez, há outra maneira de fazermos isso. Por exemplo, poderíamos simplesmente salvar dentro de um edifício uma variável quantos edifícios de um tipo específico existem. Mas nós realmente não precisamos. Isso também funciona. Calculando isso em tempo real também funciona. Agora isso já é isso, isso já deve funcionar. E creio que já devemos conseguir ver isso. Se não estou enganado. Agora, a coisa é, nós ainda vamos ter uma exceção realmente não implementada. Então, na verdade, não vamos fazer isso. Vamos primeiro de tudo obter o método de custo de atualização aqui também. Então isso vai ser muito parecido com isso. Então vamos realmente copiar isso só por causa da discussão. Isto continuará a ser o mesmo. Então o if, o if declaração aqui é o mesmo. E então a única coisa que vamos fazer aqui é o valor do par de chaves valor, transformar, ponto obter filho. Então isso, é claro, é basicamente codificar a posição de coisas particulares. Porque agora temos, se olharmos para isto de novo, temos isto às 012. Então o custo que sabemos está na posição 2. Portanto, precisamos levar a criança para. Isso, como eu disse, está codificando isso neste caso, provavelmente haveria um pouco, você poderia torná-lo um pouco melhor. Mas agora, a capacidade de expansão aqui realmente é, não é grande coisa. Eu conseguiria componente. Portanto, queremos mais uma vez no componente textos do texto de custo. E vamos definir isso para building.com ponto toString. Então estamos apenas construindo que foi construído. Lembre-se que o método de custo de atualização é chamado toda vez que um edifício foi construído através da construção de um evento construído sobre edifício construído. E esse custo de atualização então tem o edifício como um parâmetro. E nós vamos simplesmente definir o texto para o custo real do edifício depois que ele foi construído. Agora, o que é interessante é que nós realmente não chamamos isso de edifício construído evento ainda. Na verdade, precisamos fazer isso ainda. E isso é feito dentro do depósito de queijo bem aqui. Então nós adicionamos o edifício aqui, mas nós realmente não temos isso ainda. E isso, isso é realmente tão fácil como simplesmente dizer Construindo ponto no edifício construído. interrogação, invocar com novo edifício. Lá vai você. É tudo o que precisamos fazer. E agora isso também é frio. Então isso é realmente muito, muito bom. Então, sim, esta foi a interface construída que funcionou perfeitamente bem também. Há mais uma coisa para o Build UI que realmente precisamos mudar e que está dentro de nossa ordenha um painel de construção. Oh, não, não, não, não, não, não mexa que você está louco. Eles vão, precisamos mudar este 0 para um 1. Por causa, é claro, a estação de ordenha está no índice um e nó no índice 0. Então isso é meio importante. Mas depois de termos feito isso, vamos pensar sobre o resto da interface do usuário do edifício. Fizemos o seguinte. Se construímos um prédio, vamos ligar para o número de atualizações de edifícios. Isso funcionou bem. Também atualizaremos o custo. E agora, por último, mas não menos importante, queremos basicamente atualizar a clickability aqui. E isso também vai ser bastante fácil. Mais uma vez, vamos passar com um método ForEach aqui. E neste caso, nós realmente não queremos a declaração if. Não precisamos disso. Nós só queremos dois, basicamente obter o valor e então basicamente fazer exatamente o mesmo que fizemos aqui, certo? Então isso é basicamente o que queremos. Queremos obter o componente de GameObject. Podemos fazer isso simplesmente dizendo, Bem, valor ponto obter botão Componente porque queremos que o botão e queremos mudar a intractabilidade bem para verdadeiro, mas apenas sob certas condições. Agora podemos pensar qual é a condição? Bem, basicamente, queremos ver o prédio em si. Então este seria o custo do par chave-valor ponto, ky, ponto. Menor ou igual ao queijo. Queijo de armazenamento de ponto instância dot cheese. Isto é, na verdade, não podemos acessar quanto queijo temos? Este é um, este é realmente um arrependimento, Vamos para o armazenamento de queijo aqui por um momento. Vamos, na verdade, só por uma questão de argumento, tornar isso público agora. Há uma maneira mais fácil de fazer isso. Na verdade, não, não vamos fazer isso. Vamos fazer isto. E vamos simplesmente fazer um queijo inteiro público. Isso vai receber retorno, devolver queijo. E isso não tem um conjunto neste momento porque nós realmente não precisamos ter isso como um conjunto. Nós só queremos acessar o queijo lá. Então vamos fazer isso. Ela está, lá vai você. E agora tudo isso é ótimo e bom, mas como vocês podem ver claramente, vamos primeiro testar isso e então vamos refatorar um pouco do código porque provavelmente muitos de vocês dirão, quero dizer, eu escrevo... par de valor, eu não sei o que está acontecendo aqui em tudo. Estou muito confusa. Eu posso entender isso. Vamos primeiro tentar isso. Vamos refatorar isso e depois garanto que vai conseguir muito mais. O que você vai dizer? Limpar? Vai ficar mais claro. Lá vai você. Ok. Acredito que tudo deveria ter sido feito. Agora isso é sempre, você sabe, vamos, vamos ver se tudo funciona. Se isso é realmente factível e vamos ver. Então, em primeiro lugar, parece bem. Não podemos clicar em nenhum desses, então isso é muito bom, isso é um bom sinal. Agora, se adicionarmos um queijo 10 clicando no mais, vamos ver se isso fica clicável. Agora, como você pode ver, ele realmente fez. Então, a clickability de atualização definitivamente funcionou. Tivemos este brilho e se eu passar por cima dele, fica um pouco mais escuro. Na verdade, posso maximizar isso rapidamente. É quase imperceptível. Mas agora eu devo ser capaz de clicar nisso e ele vai adicionar um 1 aqui. Remova o 10 queijo, vamos fazer isso, chega a 20 e vamos adicionar queijo continuamente. Então vamos ver se isso funciona. E tudo funcionou. Isso não é ótimo? Então isso é muito legal. Agora adicionamos um novo edifício Clicker. Basicamente, nós também ajustamos o preço. E assim que chegarmos a 20 aqui, isto vai acender novamente e devemos ser capazes de comprar o próximo clicker. Vamos ver se é esse o caso. E aí está. Podemos comprar no próximo clicker. E o mesmo deve ir para a estação de ordenha. Então, uma vez que tivemos 25, lá vai você. E se eu clicar nisso, então isso também altera o preço. Nós também adicionamos um a isso, e agora vamos obter os cinco queijos a cada dois segundos para isso também. Sim. E só para ter certeza de que isso funciona, eles vão para e, em seguida, 40 funciona muito bem e verificar. Então isso é muito legal em termos de uma interface do usuário. Então isso já funciona. Vamos também desabilitar a maximização no jogo porque eu não quero necessariamente que cada vez. E sim, então funciona. Mas como eu já disse, alguns de vocês podem dizer, bem, quero dizer, tudo bem, mas eu, eu não sei o que está acontecendo aqui. Ok. E agora isso é uma espécie de, eu diria, apenas um prettify isso. Então, para tornar isso um pouco mais legível, nós vamos realmente adicionar algumas variáveis locais aqui. A idéia é que, bem, ok, então nós temos essa chave de par de valores e o que isso significa? Eu não sei. Ok, vamos pensar sobre isso. Isto é um edifício. Então nós podemos realmente, se você tem tudo isso, podemos ver que este é um edifício porque é claro que esta é a chave do, do nosso dicionário. E então podemos simplesmente dizer, ok, vamos fazer disso um prédio. Este é o edifício em uma espécie de nosso salvo aqui. Então o edifício dentro do como um parâmetro, esse é o edifício que está sendo construído. Ou porque isso é chamado, o método é chamado em um edifício construído. Então este é o prédio. Podemos mudar esse nome. Então vamos renomear este primeiro controle, RR. Este é um edifício a ser construído, digamos. Então sabemos, ok, este é o prédio a ser construído. E isto é uma espécie de edifício seguro. Ou como podemos chamar isso de chave aqui? Bem, este é basicamente o tipo de edifício que usamos para procurar, certo? Então vamos chamar esse prédio para pesquisa agora. Não é o nome mais claro, mas acho que vai ficar tudo bem. E isso é igual ao par de valor chave Schottky, certo? E então, em vez de usar isso, podemos realmente usar essa variável aqui. E então construindo para pesquisa, é como Ok, Ok, então a chave é o prédio para pesquisa. Eu entendo isso, isso faz sentido. Agora, qual é esse valor? Eu não entendo qual é esse valor, certo? Então não é um problema. Este é um objeto de jogo. E lembramos que o dicionário é o edifício para o painel de construção. Então este é simplesmente um painel Gilbane Building. Então, podemos dizer GameObject construção projeto fazendo painel é igual ao valor da chave, par valor chave, valor do ponto. E agora podemos ir ainda mais longe porque podemos ver, bem, nós só usamos o transformador. Nós podemos realmente obter a transformação disso também. Então, podemos dizer Transformar e dizer basicamente o painel de construção, construção de painel de transformação é então igual ao painel de construção transformar ponto. E então, em vez de apenas substituir isso, nós podemos realmente substituir a coisa toda aqui por esta transformação aqui também. E agora vamos ver que, bem, quero dizer, nós dois temos o 0º filho aqui, então nós podemos realmente substituir isso bem e então até ir mais longe. Na verdade, estamos sempre recebendo o mesmo componente de texto. Então, em teoria, podemos conseguir isso também. E eu digo que sim, por que não? Então nós podemos realmente dizer texto e dizer, Este é o painel de construção. Este seria o número do painel de construção do texto de construção. Então este é um nome de variável muito longo, mas não fique muito louco com isso. Por que não tem isso? E este seria este aqui. Então nós podemos realmente salvar isso lá e, em seguida, substituir isso por isso, e substituir isso por isso. Certo? E agora, enquanto podemos dizer, bem, quero dizer, você também pode juntar isso. Sim, mas se olharmos para isto agora podemos ver, ok, par chave-valor de ponto é o painel de faturamento, ok, claro que esse é o painel de construção que fizemos. E então obtemos a transformação dele. Ok? Sim. Ok, a transformação, é basicamente o que você pode dizer. Bem, ok, talvez isso possa ser excluído e nós podemos dizer, bem, realmente painel de construção. Quero dizer, eu sei o que é o painel do edifício. Então, vamos pegar este. Então isso porque a transformação e o GameObject são muito semelhantes entre si. Então você pode dizer, Ok, a transformação de penalidade de construção, eu vou conseguir isso, isso é totalmente bom. E então a coisa é, então, eu vou obter o texto associado a ele. Que tipo de texto é esse? O número do painel do edifício dos textos dos edifícios? Sim, claro, isso me diz quantos prédios de um prédio em particular foram construídos. E então nós apenas analisamos o texto deste, e então nós lemos um re-salvar o número que estava lá mais um nele. E esta é basicamente uma maneira muito fácil, digamos para mudar isso e ser L2, leia isso um pouco melhor. Então vamos fazer este e vamos também mudar isto para edifício, para ser construído. Certo? E, em seguida, baixa chave, mas apenas em iguais. temos o edifício transformado aqui, mas só precisamos dele uma vez. Então não precisamos de receber o texto neste caso. Eu acho que isso seria totalmente bom. E isso faz muito mais sentido. Você pode, é claro, também a propósito, fazer o mesmo com, por exemplo, este custo aqui, certo? Então você pode dizer, bem, quero dizer, na verdade, quando pensamos sobre isso, qual é esse prédio para ser construído custo? O que é isto? Este é, na verdade, o novo custo que queremos ter. Então podemos apenas dizer novos custos e podemos realmente imediatamente colocar isso em uma corda. Isso é ainda melhor, o novo custo Nº 2 string. E então podemos pensar sobre isso e colocá-lo aqui. Então fica ainda mais fácil de ler. E dizemos que o novo custo é igual ao edifício real que está sendo construído custo porque isso já foi atualizado para nós. E depois conhecemos o nosso caso. Nós apenas pegamos os textos reais, eles são um atualizado com o novo custo. Portanto, o custo de atualização faz sentido. Atualize clickability, muito semelhante a isso. Neste caso, podemos conseguir o prédio aqui. Na verdade, nós apenas o edifício que precisamos o. Um GameObject neste caso. Então nós realmente queremos mudar isso um pouco. Então este é o objeto do jogo, este é o painel de construção. E, em seguida, no final, em vez de escrever GameObject, nós também podemos apenas ir e, em seguida, dizer valor de ponto. E então este vai colocar aqui. Assim, o painel de construção GameObject ponto obter Intratabilidade botão Componente. Também podemos pegar o botão imediatamente. Acho que está tudo bem por enquanto. E então toda essa provação aqui, nós definitivamente devemos fazer um booleano com isso. Então este é o Bool em apuros no ato terrorista. Eles podem ir. E então podemos colocar isso aqui. E, e desta forma. E então a grande coisa é que nós também podemos apenas fazer pegar o prédio aqui, colocar isso aqui, construir para pesquisa, e então nós podemos mudar este edifício para o custo do ponto de login. E então diga interactable bem aqui, o ego. E agora é muito mais fácil de ler. Eu queria basicamente mostrar-lhe isso como uma espécie de exemplo real de como você pode mudar o script ou alterar o código, refatorar o código. Então é um pouco mais fácil de ler. E agora isso é muito mais fácil de ler porque, claro, par de valor chave, chave. O que é isso? Você tem que se lembrar de novo, não, basta colocá-lo em uma v 70. (Clicador de queijo: Tudo bem, vamos continuar com o clicker de queijo aqui para o curso de união. E nesta palestra vamos criar um sistema de atualização muito, digamos, fácil que você pode implementar. Mais uma vez, inspirando-se no Cookie Clicker, onde você também pode obter certas atualizações que são aplicadas a edifícios específicos. E vamos ver se conseguimos criar algo lá. Então, primeiro de tudo, vamos criar uma nova pasta dentro de nossa pasta de scripts chamada upgrades. E lá dentro teremos o script de atualização lindamente nomeado. Então a pasta sendo plural e a classe real sendo apenas singular. Agora isso não será herdar do comportamento moral e vai estar dentro de atualizações. Bem, sem o ponto e vírgula Diego. E há um monte de coisas que precisaremos adicionar aqui. Então, vamos. Então, primeiro de tudo, eu já preparei algumas idéias de um tipo de atualização que vamos ter e estes serão salvos à vista de Um tipo de atualização enum. E esses serão os clicker de bronze. Teremos o clicker prateado. Temos o clicker dourado, a platina, Flickr platina, assim como o leite de bronze. Claro, você poderia ter adivinhado o leite prateado. E se você conhece os outros, você receberá um biscoito ou outro pedaço de queijo, leite de platina. Lá vai você. Esses são todos os tipos de atualizações. Vamos fazer uma construção muito semelhante à que fizemos com os edifícios. Então, onde temos uma lista estática privada de atualização tipo dentro daqui, que vai ser todas as atualizações. E então teremos isso dentro de uma propriedade estática, que também é uma lista de atualização chamada todos os upgrades, upgrades. E nós teremos um getter aqui que vai fazer retornar todas as atualizações. E se esse não for o caso, então o que queremos é gerá-los. Então vamos ter outra lista pública estática de atualização. Gerar todas as atualizações, atualizações que eles atrás. E isso é, então, exatamente o público não está escrito corretamente. Eles passam estáticos públicos, geram todas as atualizações. E isso é basicamente o mesmo que fizemos com a lista de prédios dentro da classe de construção. Então este é o resultado é igual a uma nova lista de edifícios. Vamos retornar este resultado. Vá. E então vamos preencher isso em breve. Primeiro de tudo, vamos fazer a verificação aqui. Então, se a variável estática real é igual a null, então nós, primeiro de tudo temos que configurá-lo com exatamente o método all upgrades. Certo? Isso é como eu disse, alguns deles nós já fizemos isso para os próprios edifícios. Então isso não deve ser uma surpresa muito louca. Agora a grande questão vem, bem, que tipo de coisas estão dentro de uma nota de laboratório? O que é o que são as propriedades de uma atualização? Bem, em primeiro lugar, obviamente vamos ter um tipo de atualização, certo? E isso vai ser um tipo de atualização com um getter e um conjunto privado. Só por que não? Então também teremos um modificador público. Este é o modificador, modificador, o 0. Este é o modificador que estamos indo para vezes foram para multiplicar com o ganho real de queijo que teremos. Então este é o modificador de B, terá um que. Então também temos, naturalmente, um custo associado a ele. Conjunto privado aqui. E então uma outra coisa, e isso seria um bool público e isso é chamado é um bot. Então isso simplesmente verifica se este particular foi comprado, pois as atualizações que vamos criar aqui só poderão ser compradas e então elas se foram. E então para essas coisas, é claro, também precisamos de um, precisamos gerar um construtor muito bom. Podemos fazer isso, é claro, pressionando o ponto de controle de pontos. É pontos de controle, claro, Gerar, Construtor e tipo de. Essas são exatamente todas as coisas que eu quero aqui. E também há mais uma coisa que queremos. Na verdade, esqueci completamente disso. Uau, isso é embaraçoso. Precisamos de saber o que é um edifício. Então nós realmente queríamos começar a usar o namespace de edifícios de ponto de clicker cheese. E depois queremos um edifício para construir. E isso tem um get e um set privado novamente. E isto também está aqui. Então construindo. E depois para construir, certo? E nós não queremos é comprado por sinal, porque isso é algo que é sempre falso no começo. E então para a construção, vai ser para a construção, para a construção, construção. Está bem. O que é isto? Qual é o processo de pensamento por trás disso? Bem, é claro, uma atualização é sempre específica para um específico para um tipo de edifício. É por isso que isto tem uma referência de construção aqui. E o é comprado simplesmente diz, ok, é falso no início. E então uma vez que compramos, então uma vez que o vazio público por método é resfriado, e vamos dizer que é comprado é igual a falso. Bastante verdade. Desculpe, lá vai você. Claro, lá vai você. Assim que comprarmos isto, isto é comprado. E com este quadro nós basicamente verificamos, ok, nós podemos tipo de nós compramos o que nós só queríamos ter este soviético nós sabemos, ok, esta atualização foi comprada e esta para cima não foi comprada. E no futuro, por exemplo, poderíamos dizer, Ei, todos os upgrades comprados e, em seguida, filtrar facilmente para é comprado em que, que seria uma das coisas que podemos fazer. Mas agora nós podemos realmente criar essas atualizações dentro desta lista aqui. Agora o que eu vou fazer é realmente copiar. Eu realmente vou criar uma nova atualização aqui, e então eu vou copiar sobre o resto deles porque eles são um pouco mais complicados do que os edifícios. Então, temos resultados ponto adicionar, e, em seguida, uma nova atualização. E agora, em vez desta atualização, primeiro precisamos de um tipo de atualização Clicker bronze. Então queremos o modificador, neste caso, o motor Fire, por exemplo. Na verdade, vamos virar isso. Então, primeiro, vamos obter o custo e, em seguida, o modificador, caso contrário, a cópia não funcionará. O custo, digamos que o bronze custa 25 e ele vai realmente dobrar as coisas que vamos obter com o clique real. E então para que prédio? Bem, nós podemos obter os edifícios mais uma vez fazendo construção, um edifício instâncias. E, em seguida, um 0 aqui. Porque isso, claro, funciona porque isso mais uma vez é o clicker e isso é especificamente para o clicker. E agora podemos simplesmente copiar. Isto é realmente bastante fácil também. E diga “clicker “prateado. Este, então, custa, digamos 500. Então isso é um custo muito maior. E, em seguida, ele também dobra o, ele dobra o ganho de queijo. E depois temos o clicker de ouro. Este custa 1000, 500. Esses são, claro, números arbitrários, certo? Você pode escolher o seu próprio e alterá-los também. E este vai ser o clicker de platina com 5000 e isso vai para tempos para ele. Agora, esses são, claro, multiplicativos. Então, se eu tiver o bronze e o clicker prateado, nós vamos obter quatro vezes mais, tanto queijo fora dele. E então se eu tiver isso, então vamos olhar para oito vezes e então teremos 32 vezes se eu tiver todas as atualizações. Então, essas escalam muito rápido, na verdade. Agora, os outros eu vou realmente pegar e vamos fazer isso de uma maneira diferente. Então, e nós, na verdade, como você pode ver, Coleção é inicialização. Lá vai você, pode ser simplificado. E nós vamos apenas clicar nisso e vamos ver que isso parece um pouco diferente do que já vimos antes, mas no geral não deve ser muito louco. Então, basicamente temos o tipo de inicialização em linha aqui. Em vez de adicionar aqueles com o método add, podemos apenas ter isso aqui. E então torna o meu trabalho um pouco mais fácil simplesmente copiando isto aqui. Isto é criar instâncias. A cópia não funcionou. Lá vai você. Isso é o que é, certo? Então, mais uma vez, você pode, naturalmente, escolher seu próprio upgrade para custos e modificadores aqui. No nosso caso também o modificador seria um inteiro. Porque começamos com uma entrevista. Claro, ambos podem torná-lo um flutuador e, em seguida, basicamente, apenas ter o resultado mais tarde. Ou selar ou fazer ou florir, certo? Para que você possa arredondá-lo para cima ou para baixo. Mas agora eu acho que isso é bom como um exemplo, digamos. E a última coisa, há duas últimas coisas que queremos. Bem, uma das coisas que queremos é. E basicamente queremos um método estático que nos permita basicamente obter os modificadores relevantes. Então este é o modificador relevante. E isto é para um edifício particular neste caso. Então, o que queríamos aqui? Bem, basicamente, em primeiro lugar, vamos fazer modificador igual a 1 e, em seguida, retornar modificador. Então a idéia é que, dado um determinado edifício, queríamos o modificador que está associado a ele. Então, se nós temos o Bronze clique no Clicker prata, então se nós dermos este método no edifício clicker, então o que nós queremos voltar é basicamente o modificador que nós precisamos aplicar a isso nesse caso então para, então, para isso vamos fazer um novo for-loop que passa por todas as atualizações, contagem de pontos. E uma vez que passar por todas as notas ópticas, o que vamos fazer é perguntar, ok, se a atualização real que estamos procurando agora, eu realmente não poderia ser. Sim, vamos fazer um loop foreach, na verdade, isso é um pouco melhor. Então isso seria uma atualização. Refrigerado, diferente de zero, desculpe. Não, ainda não está certo. Upgrade. Está bem. Vamos fazer isso assim. Atualizar, atualizar em todas as atualizações Will opera o ego. Eu o que nós vamos dizer é se a atualização é para a construção, então se nós pegamos o prédio e então nós vamos, o que nós vamos fazer é usar o método get type. Isto simplesmente, você pode basicamente obter, tomar o método de tipo do get chamado igual sobre isso e, em seguida, dizer ponto de construção recebe tipo também. E isso então compara o tipo de tipo, a classe realmente assim com esta madeira, então há um tipo de ponto do sistema, como você pode ver, que é o tipo de retorno. E isso simplesmente uma comparação da classe ou do tipo de dados, por assim dizer. Então ele compara se este edifício que estava sendo dado é ou não, por exemplo, o clicker. E se esses coincidirem, fim, a atualização é comprada. Então isso também é meio importante. Então foi aí que perguntamos se era ou não. Então o que vamos fazer é modificar nossos tempos é igual a atualização de ponto modificador. Lá vai você. Então, vamos realmente ser capazes de multiplicar o modificador para ele. Sim, no geral, quero dizer, isso não deve ser muito louco. Estamos apenas à procura do edifício em particular. Se as atualizações lá foram compradas e se elas foram compradas para este edifício, então vamos simplesmente adicionar ou não adicionar isso ao modificador, mas multiplicá-lo para o modificador, certo? E também para adicionar isso, modo que isso realmente começa algum trabalho. Precisamos mudar o clicker e a estação de ordenha aqui. E isso não vai ser muito louco. Nós simplesmente fazemos um total que ela ganhou aqui, e este vai ser o ganho de queijo que temos. Assim, a pele de carneiro da estação de ordenha, este caso vezes. E então vamos usar. Atualizações do Flickr dot, precisamos usar esse namespace. Em seguida, dentro daqui podemos ver atualizado ensinado, obter modificador relevante para isso. E é por isso que eu gosto desse método criativo, porque isso torna muito fácil fazer isso. E então podemos dizer ganho total de queijo. E nós podemos copiar isso, colocar isso aqui, e então também dizer ganho total de queijo. Eles vão. E também certificando-se de que estamos usando o namespace correto apareceu. Ela é atualizações de pontos clicker. Neste momento, o fluxo de caixa em si já deve funcionar. Então modificar o fluxo de caixa pelos upgrades aqui deve funcionar totalmente bem. A única questão é que não podemos comprar as atualizações ainda e estamos a favor disso vamos fazer uma nova atualização. Você eu realmente agora vamos fazer isso. Só para o inferno. Então eu ouço você. Eu então esta é a UI de atualização. Vou fazer isto um pouco diferente. Sei que foi um pouco rápido demais. Agora ele vai abrir outra Instância Visual Studio. Só um segundo. Um “go”. Vamos fechar isso de novo. Obrigado. Então abra isso no correto, por favor. Lá vai você. Isto é, naturalmente, sob o seu olho e nós definitivamente estaremos usando o namespace de atualizações de ponto de clicker queijo. Deixe-me dar uma olhada rapidamente aqui. A primeira coisa que precisaremos é de uma lista pública de Sprite. Então agora nós vamos realmente ter um sprites associado a ele. Esses, é claro, estão disponíveis como um recurso e vamos vê-los em breve. Então teremos um dicionário semelhante aos prédios. Nós vamos ter uma atualização para o dicionário de objetos do jogo aqui. E nós também vamos chamá-lo assim, atualizar para um objeto de dois jogos. Objeto. Eles vão com um getter e um setor privado. E, em seguida, por último, mas não menos importante, teremos um objeto público que vai ser a atualização UI prefab. Mas não vamos ter isso com um ano de sublinhado, assim como este. Ok, Primeiro de tudo, o dicionário de objetos de jogo de atualização será inicializado aqui no método de início. Então o que vamos fazer é antes de dentro do painel de edifícios, nós realmente adicionamos a penalidade particular nós mesmos, então manualmente. E agora vamos basicamente ter os particulares gerados desta vez. Então nós vamos dizer painel, e nós vamos apenas adicionar um pequeno painel aqui em baixo. E nós estamos basicamente indo apenas para gerar esses. Então vamos este seria o painel de atualização. Painel de atualização. Lá vai você. Vamos adicionar a interface do usuário de atualização a ele. E então vamos também adicionar os sprites. Então vamos fazer em vez de nossos sprites uma nova pasta. Estas serão as atualizações. Vamos também criar uma nova pasta chamada construção de edifícios, e simplesmente adicionar todos os nossos sprites a eles. E dentro das atualizações, vamos adicionar todas as coisas douradas. Como eu disse, todos eles estão disponíveis como um recurso. Copiamos isso e deixa-me verificar rapidamente, certo? Você não precisa mudar nada por eles. Como você pode ver, Bronx escorregar ou máquina de cheiro errado, Flickr, aquela máquina. Platina e prata também. - Sim. Então, mais uma vez, estes estão, naturalmente, disponíveis como um recurso. E, em seguida, vamos ver, painel de atualização. Então, basicamente, não queremos criar nada de louco ano. E com a criação, eu sou realmente mau como se fôssemos criar isso. Portanto, a própria UI de atualização não deve ser muito louca. Teríamos que criar este. Então nós temos o prefab e, em seguida, nós podemos basicamente colocar o prefab lá dentro. Então isto vai ser simplesmente uma imagem deste. Então, isto é uma imagem. Vamos fazer isso um pouco menor. Isso provavelmente vai ficar bem. E, em seguida, esta imagem vai ser a UI de atualização. E isso também terá um botão associado a ele. Então isso vai ser um botão aqui. E eu acredito que isso já é basicamente. E então nós simplesmente precisamos mudar as coisas nele. Então, a atualização de suas ilhotas, coloque isso dentro da pré-fabricada aqui. Então, como pré-fabricada, agora, está aqui. E podemos, em seguida, basicamente excluídos e certifique-se que o prefab atualização UI aqui é definido dentro do script. E então eu acredito que isso deve ser tudo. Então nós simplesmente precisamos criá-lo fazendo um novo método, private void create, upgrade UIs com um índice particular aqui. Vamos ver. Lá vai você. Porque queremos chamar esse método dentro de um loop for. Então, basicamente, vamos passar por todas as melhorias que temos. Na verdade, todas as atualizações em espécie de fim de semana, na verdade, já fazem isso. Então, para loop com i e, em seguida, isso é atualização, atualizações, contagem de pontos. Então vamos passar por todas as atualizações, atualizações, ou acertar sua diagonal. E nós vamos dizer Criar, classificar seus olhos. Eu vou. E dentro daqui vamos criar isso. Então o objeto do jogo 30, ou digamos que o termo de atualização é igual a instanciar esses prefab UI com a ajuda desta transformação aqui. Eu vou dizer que a atualização vai ser. Então, primeiro de tudo, obter imagem componente. Precisamos do pacote de IU aqui, é claro. Então, usando o motor Unity wi, isso seria muito bom. E então a imagem, nós realmente não vimos isso como eu disse antes, mas isso vai ficar bem. Assim, o sprite aqui pode ser configurado exatamente como com o, basicamente o renderizador sprite. E então este seria o índice. Então nós vamos apenas obter o sprite em um determinado índice aqui. E então vamos fazer algo que nunca vimos antes. E vamos basicamente mudar o que acontece quando pressionamos o botão. Então antes de termos visto é que acabamos de adicionar o. Uma funcionalidade de botão por se olharmos para isso, se olharmos para isso, Há também tem um botão. Nós adicionamos o onclick e tivemos a coisa particular aqui e frio um determinado método ou função lá. Mas o que vamos fazer agora é que vamos realmente fazer isso via código. E para fazer isso nós vamos obter o componente botão aqui. Então, botão onclick. Então isso é exatamente o que tínhamos lá e movimento de carvão adicionar ouvinte. E assim este ouvinte de anúncios, precisamos adicionar uma nova expressão lambda. Então isso simplesmente se eu passar o mouse sobre isso, como você pode ver, este é um chamado de ação de unidade. E podemos fazer isso como uma expressão lambda. Então tudo o que eu coloco depois disso é basicamente o que acontece depois. Então atualizar todas as atualizações índice ponto por. Então eu quero chamar o método aqui para esta atualização em particular, um quando isso é clicado. E o que eu também quero fazer é que eu quero definir o objeto de jogo real em si. Assim, a atualização é o objeto do jogo definido ativo como falso para que ele basicamente desaparece. E, em seguida, por último, mas não menos importante, Eu quero atualizar para GameObject o dicionário. Eu quero adicionar as atualizações reais a ele. Então, em primeiro lugar, quero dizer, sim, tudo bem. Quero dizer, isso não é tão ruim. Todas as atualizações. Índice aqui. Índice. Oh, não, isso não está certo. Indexar um ir. E, em seguida, também o objeto do jogo, que é chamado Upgrade. Lá vai você. Certo? Isso seria a criação da interface do usuário. Agora há uma coisa que é um pouco, bem, eu não diria um problema, mas vai criar todos os y uns sobre os outros, o que, claro, não é bem o que queremos. O que gostaríamos é, claro, e tê-los separados um pouco. Então vamos tentar isso. Deixe-me ver que isso deve realmente funcionar já e, pelo menos, gerá-los. Claro, precisamos definir os sprites aqui, e precisamos colocá-los na ordem correta. Então este é o clicker de bronze. Vamos fazer isto. Clicker. E depois o clicker prateado. Acredito que agora isso certamente não funciona muito bem. Então vamos fazer como dizer que você vai prateado clicker, e então nós temos o clicker ouro e então nós temos o clicker platina. Sim, lá vai você. E então, claro, a máquina de medalha de bronze, máquina de prata. Temos a máquina de leite dourado e, por último, mas não menos importante, platina. Lá vai você. Portanto, é claro que estes também precisam ser definidos. E então eu acredito que deve pelo menos gerar os objetos reais do jogo. Vamos ver se isso já funciona. Ele cria os objetos do jogo. Como podem ver, estão todos na mesma posição. Se entrarmos em cena, como podem ver, estamos na mesma posição. Você precisaria separá-los desse jeito. Isso, é claro, não funciona. Isto não é bem o que queremos. Mas sim, como é que isso funciona? Então, como podemos fazer isso? Bem, podemos, por exemplo, dizer, bem, vamos fazer o ponto de atualização, transformar a posição do ponto. E então basicamente apenas igual. Bem, também podemos dizer que mais é igual ao novo vetor três. Digamos que alguém como Arnold, 15 F 0. Bem, isso também funciona. Lá vai você. Algo assim. Vamos ver como essa se parece, se isso mudaria ou não. Mas é melhor tomar a posição local. Porque é claro que estamos atualmente sob Nova transformação. Vamos ver se isso realmente funciona. Isso irá, naturalmente, mover tudo neste caso, porque precisamos vezes isso pelo índice. Então índice vezes isso. E isso definitivamente precisa ser um pouco mais. Então digamos algo como 25. Agora, por que, o que é isso? O que é que estamos a fazer? Basicamente, dependendo do índice. Então, é claro que para a primeira atualização vamos ter um índice 0. Então isso vai ser em, a posição em si vai ser em 000 000. E, em seguida, o próximo upgrade de prazo , a posição será em 25 000 e, em seguida, índice dois será 50 000, 000 e assim por diante e assim por diante. Agora isso definitivamente vai ser fora do, fora deste painel superior direito. Nós estamos indo basicamente ok, É realmente precisa mesmo um pouco mais, mas tudo bem. Podemos basicamente tentar isso um pouco e encontrar um número que funcione aqui. Temos que fazer isso, Digamos que de forma um pouco complicada, porque ainda não vimos como podemos ter o layout de uma interface do usuário gerar-se. Isto é algo que vamos ver quando olharmos para o real, o que dizemos para vocês um pouco mais em profundidade. Agora mesmo. Acho que vai ficar tudo bem. Não parece o melhor, mas é funcional neste momento. Mais uma coisa que precisamos fazer na UI de atualização aqui, nós realmente queremos que esta cor realçada seja um pouco mais perceptível. Então vamos, vamos realmente adicionar isso aqui. Note que não precisamos adicionar o servidor, tudo bem. Vamos apenas fazer cores normais, completamente brancas. E então esta cor realçada um pouco mais escura. E o resto da coisa vai ficar bem. Vamos ver se isso adiciona um pouco mais de efeito. Sim, agora nós podemos realmente ver se nós pairamos sobre eles, o que funciona. E então se eu clicar neles, eles já devem funcionar. Agora. Podemos clicar neles quando quiser, mas deve funcionar. Então, vamos realmente tentar isso. Então vamos pegar dez queijos no clicker. E agora, é claro, isso vai aumentar em um a cada segundo. E se eu conseguir o Clicker de bronze, então isso agora deve aumentar em dois. E como você pode ver, funciona perfeitamente. Se eu clicar nisso agora ele deve aumentar em quatro e ele faz. Não se preocupe. E agora eu posso, claro, pegar os outros clickers também. E eu ia aumentar em 32, acredito que era a cada segundo. Então isso é muito louco. Então, como você pode ver, trabalhando muito, muito bem. Agora, é claro, o que ainda precisamos é basicamente verificar se isso pode ou não ser comprado. Assim, a atualização ainda pode ser comprada. Por isso. Claro, a única coisa que realmente precisamos fazer é que estávamos em primeiro lugar, queremos definir todas as habilidades intactas para o bem, não sendo intratável. Então, podemos apenas fazer Get botão Componente. Na terceira vez aqui, nós quase poderíamos pensar em pegar isso e fazer uma variável fora dele. Neste momento, não vou fazer isso porque não é. Necessário, mas isso seria algo que provavelmente faria sentido. Então vamos definir o botão para não sermos intratáveis. E então dentro daqui, vamos dizer mais uma vez, quando o queijo mudou em fraudes mudou vai ser atualização, atualização, clique mobilidade. E isso vai fazer exatamente a mesma coisa que fizemos no, vamos implementar este método de geração. Coloque isso no fundo aqui. A mesma coisa que fizemos com a interface do usuário de construção na atualização clickability. Então nós simplesmente vamos passar por eles rapidamente, vamos copiar isso porque nós já vimos isso basicamente. Nós estamos indo apenas para percorrer os pares de valor chave nos objetos do jogo aqui. E se isso for interactable, então vamos interagir com ele. Se, se o interactable, se o custo é menor ou igual à nova quantidade de queijo que está disponível. E agora isso deve funcionar também. Vamos fazer o Buchla. Deveríamos ser capazes de ver isto imediatamente. Sim, agora a cor está desativada, como você pode ver. E uma vez que eu tenho meus dez queijos, na verdade eu preciso 25, eu acredito, para a primeira atualização, então ele fica vermelho ou, você sabe, ele se torna normal para que possamos realmente clicar nele. E uma vez que clicamos, ele se foi e agora o clicker está aqui. Mas como você pode ver, ele realmente não removeu ou queijo. Claro que não era isso que queríamos. Queríamos remover o nosso queijo. Então o que podemos fazer é adicioná-lo aqui ou podemos adicioná-lo dentro do botão Upgrade. Isso provavelmente fará mais sentido. Então podemos dizer armazenamento de queijo, instância de ponto, ponto, remover árvores. E isso seria esse custo de ponto. E isso já é isso que nós, tudo o que realmente precisamos fazer porque o método de ligação está sendo chamado de qualquer maneira quando compramos a atualização e então o queijo será subtraído disso. Removido em vez disso, sim. Então vamos, você sabe, ou você também pode apenas fazer a vantagem aqui, chamar isso, e então as 25 árvores são removidas. A atualização, como você pode ver, a interface do usuário aqui foi definida para ativar basicamente porque o ascendente foi comprado, está feito. E sim, isso é basicamente como adicionar as atualizações. No geral, o jogo em si não parece muito grande, e há mais algumas coisas, claro, que poderiam ser resolvidas. Mas acredito que isto é o que vos deixaria neste momento. Há mais uma coisa. Há os barris, claro, que você poderia acrescentar. Esta é uma espécie de exercício sugerido que eu tenho também onde você adicionar mais alguns de seus próprios edifícios e se você mais de seus próprios upgrades basicamente. Mas este é o tipo de estado que eu deixaria com este jogo em particular. Ele pode ser jogado na sua totalidade. E talvez o que vamos fazer é quando olharmos para a interface do usuário, talvez queiramos mudar algumas coisas aqui. Então nós provavelmente vamos dar outra olhada tanto na atualização quanto no painel de edifícios apenas para que eles sejam ordenados corretamente. Então, no final da seção UI deste curso, mas agora eu diria que isso é uma espécie de isso para o xi clicker. Espero que todo o processo de construção tenha sido útil para você. Eu sei que em alguns momentos foi muito. Então não é como se isso fosse algo que você possa ser capaz de digerir imediatamente em sua totalidade. Especialmente se você é completamente novo na programação Unity, então isso é provavelmente, você sabe, foi um pouco. Mas tenha certeza que o que eu diria é que a melhor coisa a fazer, sabe, brincar com o que você tem aqui. Eu diria que esta é uma grande oportunidade para você adicionar apenas alguns edifícios. Faça algumas coisas que você quer fazer. Pense em, talvez algumas, algumas idéias que você, o que você quer adicionar. Talvez o que você queira fazer é adicionar mais visuais a ele. Então, se você adicionar, você recebe clickers, então talvez real como mouses aparecem. E se você tiver, se você clicar na estação de ordenha, talvez você queira que o som toque ou algo assim. Então há tantas coisas que você pode adicionar aqui. E eu quero que você use este projeto basicamente como uma introdução muito boa como uma espécie de, é o tipo de jogo, certo? Então você tem uma ótima base. Eu acho que você pode expandir. E isso é o que a idéia do clicker de queijo realmente é. Então todo esse projeto basicamente. Mas sim, foi isso para esta palestra e o clicker de queijo em si, como eu disse, definitivamente vamos voltar a isso mais uma vez depois termos feito através da interface do usuário e então nós vamos fazer isso um pouco. Eu não diria mais bonita, mas torná-lo um pouco mais fácil para basicamente classificar a própria interface do usuário. Mas isso seria tudo por isso. E como sempre, espero que tenha achado útil. E se houver alguma pergunta, então sinta-se à vontade para perguntar e eu responderei. E sim. 71. (Unity UI) Adicionando uma tela: Muito bem, bem-vindos à Unidade, apresento-vos aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada em telas ou o objeto do jogo Canvas, digamos. E antes de tudo, é claro, em um novo projeto, como sempre, vamos criar nossa boa pasta de scripts antiga. E então vamos colocar imediatamente em uma nova pasta, L1. Pode isso, vamos chamá-lo de Canvas. Isso é bom. E lá, Vamos imediatamente fazer o script também. Agora, o roteiro não vai ser realmente tão interessante neste caso, porque geralmente isso é apenas algo que eu tenho visto pessoalmente. Você não muda muito as telas. Pelo menos eu realmente não mudo muitas coisas no Canvas através de scripts. Mas eu preparei algo aqui onde temos alguns comentários mais tarde depois de terminarmos com isso. Portanto, o método de atualização não é necessário. E vamos investigar isso em breve. Mas agora o que vamos fazer é adicionar uma tela à cena. Então vamos, primeiro de tudo, vamos, vamos renomear essa cena para L1 Canvas pode isso e, em seguida, recarregar isso. Então agora estamos em L1 Canvas e clicando com o botão direito do mouse na interface do usuário e, em seguida, adicionando uma tela aqui. Agora, já vimos um pouco disso quando adicionamos o texto na interface muito simples , vamos dizer que são. Adicionamos o texto e a Tela foi gerada automaticamente. Então isso foi algo que foi interessante. Mas agora vamos realmente olhar para os componentes Canvas aqui. O que é que nós temos? Então, em primeiro lugar, temos o modo aleatório. E há três modos aleatórios disponíveis. Agora. Anteriormente, temos realmente colocá-lo para câmera espaço de tela. Mas o que é a sobreposição do espaço da tela? Bem, é claro que o padrão que começa com. E a idéia é que você poderia colocar como displays head-up aqui. E este é um modo de sobreposição basicamente. Então podemos diminuir um pouco. Como você pode ver, isso é gigante, certo? Então esta é uma tela gigante neste momento porque é exatamente o tamanho aqui. E só para que tenhamos qualquer coisa para olhar, podemos apenas adicionar um texto aqui, caso contrário, nós nem sequer vemos nada. Vamos fazer como um texto gigante aqui no meio para que pelo menos tenhamos algo na tela que possamos ver. Agora, como você pode ver aqui, os textos realmente exibe a camada direita no meio da câmera. Neste caso, porque a sobreposição é exatamente isso. É uma sobreposição na tela basicamente. É por isso que, você sabe, tão balanços como as cabeças para cima exibições. Talvez quando você jogou Minecraft, conheça o Tao, o bar no fundo, algo assim, certo? Então, exibições head-up que você pode usar para mostrar algumas coisas, é aí que a sobreposição baseada em telas pode funcionar. A câmera do espaço da tela, assim que estamos colocando isso e mostra escolhendo a câmera principal aqui. Como vejo, fica muito, muito pequeno. Além disso, o que é muito importante quando você está na sobreposição de espaço de tela, você não pode. Altere a transformação direta aqui para que você não possa redimensionar a tela em si. Aqui. No entanto, aqui você também pode escrever, então algumas coisas são feitas pela tela. Isso é por causa do fator de escala, que vamos analisar em pouco tempo. E então, agora, nada realmente mudou. Como você pode ver, a idéia das sobreposições que isso funcionaria para cada câmera. E este só funcionaria para uma câmera em particular que você é. Basicamente colocando aqui. Também a sobreposição, sobreposições sobre tudo e a câmera de espaço da tela. Você pode realmente procurar isso. Lá vai você. Você pode realmente colocar a distância do plano lá e também ter uma camada de ordenação lá também. Tão certo. Então, todos eles são basicamente renderizados a uma certa distância da câmera. Isso pessoalmente é uma preferência minha. Eu costumo usar quase sempre a câmera do espaço da tela. Há também um espaço mundial e ele vai espaço, como você pode ver, agora podemos realmente mudar o direto aqui. E se formos para a tela e o movermos, e você vai ver isso, ok, a tela está lá. Mas se eu agora realmente mover a câmera para a direita, como você pode ver que Texas agora meio que no espaço mundial. Então, agora, se temos este espaço mundial, então a tela real é um GameObject que faz parte de um mundo. Você poderia, por exemplo, imaginar se você tem inimigos andando por aí e tem como barras de saúde ou uma barra de nomes acima de sua cabeça. Isso funcionaria, por exemplo, com este nó aleatório do espaço mundial. Certo? Vamos voltar para o espaço da tela aqui só por causa da discussão agora. E sim, o resto deve ser quase auto-explicativo. Então a distância do plano é apenas a distância do, basicamente a posição y. Então, isso levaria mais uma vez em conta o plano de corte da câmera principal, que já vimos. Mas então, se alguém estiver mais perto do que 0.03.3, então não será renderizado. Então este é exatamente este. E a distância do avião aqui, 100 seria bom. Em ordem na camada também funciona com o renderizador sprite. Então, se isso estiver abaixo de um determinado renderizador de sprite do que um componente de outro objeto de jogo, então ele estaria acima disso. Se estiver abaixo disso, então não, seria abaixo disso. Então isso funciona exatamente assim também. Você também pode colocar aqui canais de trader adicionais. Eu realmente não brinquei muito com isso. E agora, eu não me preocuparia com isso. A escala, no entanto, é, na verdade, há mais uma coisa, este pixel perfeito. Quase me esqueci. Na verdade, isso é meio importante. O pixel-perfeito é, como você pode ver, ele está disponível em ambos os espaços da tela, mas não no espaço do mundo, modo aleatório. E o pixel-perfect é basicamente teve a idéia de que o Canvas vai se alinhar com os pixels perfeitamente. É por isso que é perfeito para pixels. E se você habilitar isso, basicamente pode tornar certos elementos mais nítidos e evitar a desfocagem nos elementos. No entanto, o que é realmente importante é se você tem uma espécie de animação dentro de sua tela. E seus elementos, basicamente os elementos de interface do usuário, então pode ser melhor se você desativá-lo porque ele pode ser suave ou sem ele. Porque se ele tem que se alinhar perfeitamente com o pixel, então o movimento às vezes pode ser um pouco confuso. Mas normalmente isso é bom. Sim, é isso que seria para a própria tela. Então vem o scaler de lona, que é realmente o pão e manteiga aqui. Então, o modo de escala de interface do usuário, há três deles também, tamanho de pixel constante, temos escala com tamanho de tela e tamanho físico constante. Então, por que precisamos nos preocupar com a escala de qualquer coisa? Bem, vamos ver isto. Então, temos a janela do jogo aqui agora, certo? Se nós, por exemplo, levássemos isso para fora e se eu pudesse realmente conseguir, sim, agora eu tenho isso de forma independente, então eu posso dimensionar isso certo? E como você pode ver, bem, tudo bem, o texto real permanece lá, não importa o que eu faça. Então, isso já não é tão ruim. Mas o que isso tem é que tem um tamanho de pixel constante, então isso vai ficar assim. E porque a resolução aqui é tão alta, isso não é um problema. Mas se dissermos vamos para três aspectos. Agora, este é o nosso verdadeiro Deixe-me ver. Vamos lá. Sim, baixa resolução. Então, como você pode ver agora, bem, é o mesmo tamanho de pixel, qualquer que seja o aspecto. Então, se estamos em, vamos fazer não, não mais baixo. Então 1609 e 1610, bem, funciona um pouco melhor, mas não realmente. Então, como você pode ver, dependendo do tamanho agora, porque agora o aspecto tem que ser o mesmo. Os textos reais, não está realmente escalando muito bem para o que temos. Então, se temos um display de telefone, quero dizer, então tudo simplesmente, não funciona. Então tamanho de pixel constante pode ser usado, certo? No entanto, como eu disse, os elementos da interface do usuário que estão abaixo nesta tela basicamente mantêm seu tamanho de pixel, independentemente do que a tela faz. É para que eles não vão basicamente eles não vão escalar. A escala com o tamanho da tela é muito interessante. E eles são, eles basicamente escalam com uma certa resolução de referência. Então geralmente se você tem um, 1920 por 1080, por exemplo. E então, de repente, este é muito interessante porque o aspecto é sempre 16 a 9. Mas como você pode, é claro, lá vai você. Agora ele realmente escala com ele. Agora só depois de ter realmente tomado isso. Então você pode ver que isso já funciona bastante bem. Você também pode olhar para o que é suposto combinar. Então, ou a largura ou a altura. Você também pode colocá-lo em 0,5 e, em seguida, ele vai basicamente torná-lo de modo que ambos coincide com a largura ea altura mesma. Ali. Você também pode colocar uma expansão e também colocar em psiquiatra aqui, se você quiser. Eu costumo mantê-lo em, se eu conseguir fazer isso funcionar, lá vai você. Eu geralmente mantê-lo em 0.5 jogo com o modo de correspondência de tela de largura ou altura. Pixels de referência é. Vamos ver se podemos realmente obter qualquer ego é um sprite, tem a configuração de pixels por unidade do que um pixel no sprite, vamos cobrir uma unidade na interface do usuário. Então isso na verdade deve ser muito auto-explicativo. Se você se lembra, nós olhamos para os sprites e lá fomos capazes de definir basicamente os Nossos pixels por unidade para alguns de nossos sprites. E o último é o tamanho físico constante. Então isso significa que ele vai realmente olhar para centímetros, milímetros, polegadas pontos, ou nos escolher no site na tela. Isso significa que levará o tamanho físico original. Então você poderia literalmente tirar uma régua, colocá-lo em sua tela, e isso sempre vai levar o mesmo tamanho. Agora em seus itens não vai realmente escalar bem. Mas se você quiser, por exemplo, algo para ser exatamente como uma polegada por uma polegada, tipo de em uma tela de celular ou mesmo em um, em uma tela de PC, então esse seria o modo que você precisaria escolher. Pessoalmente, acho que a escala com o tamanho da tela é a que faz mais sentido. Ainda faz algum divertimento, especialmente se entrarmos em diferentes aspectos, certo? Porque agora nós pegamos um aspecto 1920 por 1080, que seria de 16 a 9. E se fôssemos para 16 para 10, bem, isso ainda funcionaria. Mas se é loucura ou aspectos como se tivéssemos um aspecto livre aqui, então, em algum momento, isso definitivamente vai falhar, como você pode ver. Então, se temos mais ou menos um smartphone, então, você sabe, não funciona muito se, você sabe, dependendo do tipo de smartphone que possa ser. Mas sim, no geral, ainda é basicamente o scaler de tela lá. E deixe-me colocar a janela do jogo de volta e colocá-lo de volta para, digamos 16 por 9 aspecto. Tudo bem, certo? Então essas são algumas das coisas que podemos fazer aqui. A melhor coisa, você sabe, geralmente você também recebe boas dicas de ferramentas aqui também. Então, na verdade, isso também é muito bom. E eu também tenho isso mais uma vez, se eu apenas abrir o script real, eu definitivamente aconselharia você a olhar para o script que já foi feito. Então isso é fornecido no, no pacote exportado porque isso terá basicamente tudo isso dentro dele também. E então, claro, também precisávamos do Canvas aqui em cima, para ir. Então, apenas alguns truques e dicas e truques basicamente. Então, há algumas coisas aqui só para que você entenda cada uma dessas coisas. Nós, é claro, também precisamos estar usando a interface do ponto do mecanismo Unity. Lá vai você. E, em seguida, o scaler de tela também pode ser acessível. Última coisa, ou múltiplas telas. Então, há um pouco de um debate acontecendo basicamente. Está bem. É melhor se você tem várias telas ou é melhor se você tem muitas? Uma tela e tudo está lá? Bem, depende, e essa é a coisa. Então você pode pensar sobre isso assim. Se um elemento mudar, então toda a tela deve ser redesenhada. Então, se eu tiver 1000 textos nesta tela e eles mudarem como a cada segundo, não importa, mesmo que eu tenha 1000 fotos na mudança, elas não mudam. Eles ainda precisam ser redesenhados. Portanto, faz sentido. Você tem várias telas. Eu tomei isso aqui. Portanto, faz sentido dividir elementos dinâmicos e estáticos em telas diferentes. Então, se você tem uma interface que basicamente nunca muda, então você pode colocar isso em um Canvas. E então a interface do usuário onde talvez você queira exibir sua saúde ou algum tipo de sistemas, então isso seria algo que você colocaria em uma tela que não muda. Então dividindo os elementos dinâmicos e estáticos da interface do usuário, certo? Mas já seria isso para esta palestra. Não há mais nada para ver. Nós também podemos apenas adicionar este script para a tela aqui. Mas não há nenhum sentido em tentar isso. Basicamente coloca tudo em cada um dos modos possíveis aqui, apenas para que você possa ver que você poderia, por exemplo, colocar isso ou mudar isso via script. Pessoalmente, nunca fiz isso. É sempre uma coisa que você basicamente coloca a tela em qualquer configuração que você quiser e então você deixá-la em paz. Mas sim, talvez sua quilometragem possa variar. Então, quem sabe? Mas isso já seria para a palestra de Canvas. Espero que você tenha achado isso útil e você aprenda algo novo. Como sempre. Se houver alguma dúvida, sinta-se à vontade para perguntar. Eu vou ter certeza de responder. E sim. 72. (Unity UI) Painéis e texto: Tudo bem, vamos continuar com a introdução do Unity UI aqui para o curso de unidade. E nesta palestra vamos dar uma olhada em painéis e texto. Então, o que já vimos em termos de textos foi um, você sabe, adicionar o texto e depois mudá-lo via script. E os painéis que adicionamos o que realmente não falamos sobre eles. Então vamos dar uma olhada nisso. Primeiro de tudo, não vamos criar uma nova cena, mas vamos duplicar esse Control D enquanto selecionamos. E então podemos fazer o texto dos painéis L2. Claro, por que não? E, em seguida, também clique duas vezes para basicamente abri-lo. E em vez da pasta de scripts, vamos fazer uma nova pasta, painéis L2 texto dentro disso também. Claro, um novo roteiro. Também vamos chamar o texto deste painel, certo? E então vamos realmente abrir isso também. E vamos fechar o script de exemplo de tela. Não precisamos mais disso. Não precisaremos do método de atualização mais uma vez. E dentro daqui podemos realmente já começar a usar o mecanismo Unity wi namespace, porque esse é o namespace que definitivamente vamos precisar porque vamos usar o exemplo de texto. Vamos fazer um exemplo de texto. Isso é bom. E depois vamos ver como isto funciona daqui a pouco. Mas primeiro, vamos voltar para a nossa tela aqui. Vamos apagar este texto. Por que não? E, em seguida, vamos adicionar um novo elemento de interface do usuário. E isso vai ser um painel aqui em baixo. Então, um painel é basicamente apenas um pano de fundo com uma certa imagem de fundo aqui. E alguns certos, alguns já específicos, você sabe, preencheram valores para certas variáveis aqui que Então a cor já é colocado um em apenas um 100 em termos de opacidade. Então, há algumas coisas que são colocadas aqui. E é basicamente deve agir como uma espécie de pano de fundo, certo? Então, se eu quiser dizer que eu quero ter uma interface aqui embaixo, então eu poderia colocá-lo aqui. E então, como você pode ver agora eu tenho uma espécie de marcador visual aqui, um fundo. E é basicamente para isso que os painéis são usados porque agora se eu adicionar um novo elemento, o novo elemento de interface do usuário para trabalhar no próprio painel, então ele é adicionado como um filho ao painel. E como você pode ver agora, é basicamente eu não diria que é dependente do painel. Eu também posso colocá-lo lá fora, mas isso é uma espécie de uma boa maneira de como você deve estruturar sua interface geral. Você deve ter alguns painéis e, basicamente, ter seus filhos sempre em cima deles. Certo? O que podemos fazer é fazer algumas coisas legais em baixo. E isso seria o seguinte. Então, o que eu quero mostrar a vocês é que agora nós colocamos isso aqui. E com toda a escala anterior e tudo isso. Bem, o que pode acontecer é que isso vai escalar com ele. Então isso é muito legal. Se tivermos esse aspecto livre. Agora ele se foi, eu acho. Bem, isso não é isso não é a melhor coisa. Se eu conseguir tirar a janela do jogo daqui, então o que vamos ver é que, você sabe, funciona, mas também meio que não funciona como sempre. Então isso é um pouco estranho, certo? Então, com os textos que funcionaram bastante bem, mas agora se tivermos um aspecto livre, isso vai ser um pouco de cerveja, e é aí que entra a Transformação Rect. Eu só quero mostrar isso rapidamente. Há um monte de coisas que podemos basicamente colocar aqui. Mas como você pode ver, isso é absolutamente enlouquecedor. Leia isso parece loucura. E eu concordo com você porque nós também podemos segurar Shift e segurar Alt para basicamente ter duas coisas diferentes. Então, podemos mudar também define o pivô e deve também define o posicionamento. Então, podemos basicamente fazê-lo para que ele esteja ancorado até um certo ponto. Agora, no nosso caso, o que queremos é que queremos que isto seja ancorado no canto inferior direito? Porque até o ponto de fundo meio que começa a ser o, o que você diria? Pode ser o, a âncora e também o ponto de referência, certo? Então, isso se torna um ponto de referência. Então, se eu fosse definir, por exemplo, isso, bem como o pivô para o fundo, direita. Então, nada mudou agora. Você vai ser como eles, certo? Que nada mudou. Mas se eu fosse agora levar esta janela do jogo mais uma vez para fora, agora como você pode ver, mesmo se eu redimensionar isso, ele vai ficar na parte inferior da tela. E isso também é uma das coisas. E vai escalar com a tela real. Então, essa é uma das maneiras que você também pode facilitar o posicionamento correto de seus elementos de interface do usuário. Neste não tem que ser painéis, também pode ser textos e todas as outras coisas. E, claro, se eu fosse agora, por exemplo, se eu segurar Alt, então a posição também será definida. E se eu colocar a posição, por exemplo, na parte superior esquerda, como você pode ver agora ela é colocada no canto superior esquerdo de seu primeiro pai. Assim, ele não obtém, o texto em si, não é colocado no canto superior esquerdo da tela, mas no canto superior esquerdo do painel. Então isso também é muito importante notar sobre essas âncoras. Eu não diria que vamos olhar para isso por muito mais tempo. No geral. Eles podem ser um pouco assustadores porque isso poderia ser como, oh meu Deus, eu nem sei o que está acontecendo aqui. Totalmente compreensível. Mas eu não me preocuparia muito com isso. E por enquanto, eu só queria mencionar que você pode basicamente ancorar o objeto do jogo em uma parte específica da tela basicamente. Bem, vamos continuar com o resto do painel vai, esta é basicamente uma imagem como você pode ver. Então isso tem simplesmente um componente de imagem. Antecedentes particulares. Então este é o plano de fundo, o plano de fundo do painel, e tem uma cor predefinida. E então todas as outras coisas que uma imagem também tem. Então isso é basicamente o que o painel é e o texto que já vimos. Há muitas coisas que devem ser familiares para você se você usou um programa de processamento de texto como o Word, por exemplo, ou eu não sei, como o Google Docs. Você pode definir uma fonte. Você pode alterar o estilo da fonte, o tamanho, até mesmo o espaçamento entre linhas pode ser alterado. Então vamos fazer isso um pouco maior. Por exemplo, o espaçamento entre linhas pode ser alterado, o que, naturalmente, não faz nada porque só temos uma linha neste ponto. Temos um alinhamento para o texto em si. Também podemos dizer melhor ajuste. Então ele vai basicamente redimensionar o tamanho da fonte para o que queremos que seja. Podemos especificar um tamanho mínimo e máximo. Também podemos alterar a cor do texto real. Agora, isso, é claro, também pode ser alterado através de um script. Então vamos apenas colocar o texto dos painéis no próprio objeto do jogo real. E vamos abri-lo. E apenas por uma questão de argumento, digamos que o texto de exemplo é igual a este ponto obter texto componente. Portanto, há o método componente é mais uma vez usar o exemplo de texto dot txt. Então este é um segundo eu apenas a mudança do texto através de um script que já vimos antes, onde mudamos o texto de 100 para 300. E, claro, o que também podemos mudar a cor. E então aqui nós poderíamos, por exemplo, dizer aleatório cor ponto HSV, e então ter isso ser realmente, vamos apenas colocar no método de atualização aqui também. Se a entrada schottky para baixo código de teclado ponto c. e, em seguida, podemos basicamente apenas mudar a cor novamente. Neste momento, eu não vou realmente extrair isso para um método diferente. Eu só queria mostrar que isso é, por exemplo, algo que também poderíamos fazer. Agora mudou o vértice. Nós somos tela. Se eu pressionar a tecla C, então o, a cor do texto também mudará. Então isso é muito legal, na verdade. Meio engraçado. Sim, mas esta é a maneira normal que podemos basicamente acessar os elementos ou as propriedades deste componente em particular. E sim, isso já seria para o texto normal e os painéis. E na próxima palestra vamos realmente dar uma olhada em um texto melhor mesmo. E este vai ser o texto Mesh Pro, que eu aconselharia você a usar em vez dos textos normais, porque às vezes os textos normais podem ser um pouco. Bem, eu diria que não tem tantas opções. Isso é algo que vamos ver na próxima palestra. Por enquanto, Isso foi tudo para texto e painéis. Como eu disse, os painéis não são nada muito complicados lá. Apenas uma imagem que deve ser usada como fundo e texto. Bem, nós já vimos um pouco disso. E o resto é basicamente apenas normalmente acessível através de um script. E algumas das coisas. Por exemplo, o melhor ajuste pode ser realmente útil para ainda redimensionar o texto conforme você avança, certo? Então foi isso para esta palestra. Espero que, como sempre, tenha achado útil. E se houver alguma pergunta, sinta-se à vontade para perguntar e eu responderei. E sim. 73. (Unity UI) TextMashPro para obter texto melhor: Tudo bem, vamos continuar a introdução da UI do Unity aqui para o curso da unidade. E nesta palestra vamos dar uma olhada no texto Mesh Pro. Este é basicamente um pacote que vem com o próprio Unity, onde você não poderia ter amine muito melhor controle sobre o seu texto. Então vamos apenas duplicar a cena de texto deste painel mais uma vez, controlar D enquanto selecionamos. E L3 vai ser, vamos fazer o texto Mesh pro. Sim, TMP, sonda txt mesh. E vamos também abri-lo, certificando-se de que esta é realmente a cena em que estamos trabalhando. E vamos apenas adicionar um novo texto Mesh pro para o, para os candidatos. Portanto, clique com o botão direito do mouse na interface E em vez de escolher texto, vamos escolher texto, teste Mesh de texto. E o que deve acontecer é que um determinado ano de janela deve abrir este importador de TMP que vamos importar são os essenciais. Então você simplesmente clica neste botão e, em seguida, ele vai fazer alguma coisa, talvez abrir o Visual Studio, mas isso realmente não é necessário. E lá vai você. Então agora deve ser importado. Como você pode ver aqui em baixo, texto Mesh Pro. E podemos realmente fechar isso de novo. E agora temos este texto em e, em seguida, entre parênteses TMP aqui. E como você pode ver, esse texto da interface do usuário parece um pouco diferente. Então isso não é parte dela, mas isso é parte dela. Algumas coisas, como você pode ver, são diferentes. Então, primeiro de tudo, temos um pouco mais de dois para o tamanho da fonte. Nós também temos alguns bens mais carinhosos eles mesmos. Aquelas vêm com materiais. Esses são, nós vamos como rapidamente ignorar para o momento. Há também alguns têxteis que podemos escolher. Por exemplo, títulos, títulos específicos. Aqui. Podemos ter citações, eles são título e coisas assim. Existem configurações principais. Essas são principalmente a fonte. Podemos ter o estilo de fonte escrever itálico sublinhado. Podemos até ter uma linha de passagem, tudo em maiúsculas, tudo em minúsculas, algo assim. tamanho também funciona da maneira que o tamanho automático funciona. É um pouco que eu não sei. Não é tão bom aqui. Às vezes você tem que fazer o inspetor um pouco maior para que você possa escolher o mínimo e o máximo corretamente. Cor de vértice, mais uma vez , é simplesmente o, o real, vamos realmente desativar os aparelhos por um momento é simplesmente a cor do texto. Nesse caso, também há gradiente de cor. Então nós podemos realmente colocar em gradientes aqui também. Então eu não sei algo como verde no canto superior esquerdo e então nós temos como um vermelho eles são. E então, como um azul, eles são. Então, como você pode ver, nós podemos fazer alguns efeitos loucos aqui. Se for necessário. Há também gradiente vertical e um gradiente horizontal ou apenas um único, certo? Podemos anular o imposto. Na verdade, não tenho 100% de certeza se a configuração de cor substitui a tag de cor. Nunca brinquei com essa. Então eu não posso mesmo dizer o que esse elemento é usado para as opções de espaçamento. Então, basicamente, se eu tiver algo escrito aqui, eu provavelmente também posso fazer isso. Então eu tenho um editor normal aqui. E então o espaçamento, espaçamento entre os personagens. Temos o espaçamento entre as próprias palavras. Nós temos o espaçamento entre parágrafos e eu também estou espaçamento entre as linhas. Então as opções de alinhamento são basicamente todas iguais. Também temos a opção justificada, uma opção de descarga e até mesmo uma opção de centro geométrico. Então, há mais alguns aqui, bem como ter linha de base, linha média e a linha de limite se isso for necessário. Então, se você precisa de muito mais, basicamente, controle sobre seu texto do que o texto Mesh Pro é uma obrigação. Modo de empacotamento simplesmente significa, ok, isso, como isso embrulha? Então, agora, isso não faz nada. Mas se eu habilitá-lo agora, como você pode ver, ele automaticamente se aproxima para a próxima linha aqui. mesmo com o transbordamento. Há algumas coisas que você pode fazer com o estouro tem elipses, eles estão mascarando, não faz nada trunca, então ele simplesmente não mostra isso. Então há algumas coisas lá que você pode fazer. E então mapeamento horizontal. Então, como é que isso se parece? Na verdade, não muda nada neste momento. Mas o que é realmente interessante agora são as configurações extras aqui. Então, há margens que você pode colocar. Então basicamente a margem em termos do próprio GameObject e há alguma classificação geométrica. Eu realmente não acredito que isso faz alguma coisa, não. E o que é interessante, no entanto, é o texto rico. Eu definitivamente usaria o Rich Text, seu geral, que é uma espécie de coisas interessantes nas configurações extras. O que é muito interessante aqui é também o material. Então o material, nós não vamos entrar muito nele, mas o material que basicamente também muda alguns dos, alguns do texto em si. Assim, por exemplo, a cor aqui também pode ser escolhida com o próprio material. E o que você também pode fazer agora é ter um esboço que é muito, muito legal. Então você pode, por exemplo, ter um contorno aqui, como você pode ver, agora este texto realmente tem um contorno ou um underlay. Eu acredito que isso é uma espécie de sombra, eu acredito. Vamos ver se consigo. Sim, lá vai você. Então você vai realmente ter uma sombra em seu texto também. Lá vai você. Isso seria a base, certo? Então há algumas coisas que você pode fazer com este material, que você pode mudar também. Assim, o geral, os projetos de malha de texto dá a você um enorme controle sobre seu texto. E também o que geralmente é um pouco mais nítido dentro do jogo. Então, se fôssemos apenas, vamos fazer isso um pouco maior aqui. Geralmente é legível. Um pouco mais legível, certo? Vamos também apenas por uma questão de argumento, reabra o texto dos painéis aqui e eu vou apenas adicionar o texto Mesh Pro, bem, idéia a ele. Então, geralmente temos usado o texto isso não podemos comer mais uso para outros livros didáticos sonda precisamos estar usando TMP Pro ou TM Pro. Este é o namespace que precisamos usar. E para obter o texto, precisamos estar usando o texto sublinhado TMP. Então este é o TMP txt. Basicamente, vamos fazer assim. Tmp txt. Na verdade, vamos fazer assim. Sim, assim é melhor. Mas, no geral, o texto em si é basicamente quase o mesmo. Então, como você pode ver, podemos escolher a cor do gradiente, habilitá-lo e desabilitá-lo. Podemos alterar a fonte e dot txt mais uma vez é simplesmente a string que está associada com os textos. Então mudar de texto é a mesma coisa. Lá vai você. Então isso é tudo o que realmente precisamos saber sobre o importante que não usamos mais a classe de texto, mas a classe de imposto TMP sublinhado. Mas se você manter isso em mente que qualquer outra coisa é realmente a mesma, nós ainda podemos mudar basicamente todas essas coisas aqui, como gostaríamos de escrever e isso já seria tudo para esta palestra. Apenas um rápido Mostrar que o texto Mesh pro text é basicamente um superior em quase todos os sentidos para o texto. No entanto, se você realmente só precisa usar como símbolos coisas, ou você realmente só quer depurar algumas coisas em termos de um texto da interface do usuário, então os textos normais também serão suficientes para isso. Mas sim, o TMP txt lhe dará muito mais controle sobre a aparência do seu texto, certo? Então foi isso para esta palestra. Como sempre, espero que tenha achado útil e aprenda algo novo. Se houver alguma pergunta como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 74. (Unity UI) Adicionando imagens à nossa UI: Tudo bem, vamos continuar com a introdução do Unity UI aqui para o curso de unidade. E nesta palestra vamos dar uma olhada nas imagens da interface do usuário ou como adicionar imagens aos seus olhos. Nós vimos isso também em um momento muito curto quando estamos fazendo nossa interface do usuário para o clicker queijo. Então o que nós vamos fazer é, primeiro de tudo, adicionar uma nova pasta aqui, e esta vai ser a nossa pasta sprites. Vamos adicionar o clicker. Por exemplo. Você, claro, também pode adicionar um elemento diferente aqui. Assim, você pode adicionar um ativo diferente. E eu vou apenas definir o modo de filtro para apontar e a compressão para nenhum. E então o que eu posso fazer é, por exemplo, neste painel, em primeiro lugar, claro, vamos duplicar a cena. Isto seria imagens L4. Vamos abrir isso e vamos em nosso painel em um novo elemento de interface do usuário. E essa seria a imagem aqui. E aí está, a imagem. E vai ser loucura, mas na verdade é bastante semelhante ao renderizador sprite. Então, se colocarmos isso aqui, o sprite, como podem ver, aí está. E é basicamente isso. Quero dizer, eu não quero ser muito louco com isso, mas no geral, isso é basicamente, você pode redimensionar aqui também. Então, se formos imagem, agora podemos redimensioná-la. Que seja, você sabe, loucura ou apenas normal. Agora, também podemos, é claro, mudar a cor. Então esta é uma espécie de cor de sobreposição em cima do que quer que o sprite real seja. E isso é realmente a única coisa interessante para imagens. Vamos dar uma olhada em um novo script também. Então L4, eu não consegui aquela nova pasta L4. Lá vai você. L4. Isso seria imagens. E então esta seria a imagem. Vamos fazer um exemplo de imagem, certo? É um bom nome. Exemplo. Sim. Vamos também adicionar isso à imagem em si. Eles vão e depois vamos abrir e ver o que podemos ver. Bem, a idéia aqui é que mais uma vez, nós temos, por exemplo, primeiro de tudo, nós precisamos, nós precisamos estar usando o mecanismo Unity que você conhece, não acessibilidade neste caso, mas IU. Lá vai você. E nós, por exemplo, temos uma imagem privada, a imagem de interface do usuário, por exemplo, a imagem de exemplo aqui. E então nós também poderíamos ter um sprite, por exemplo, mas nós realmente não precisamos disso. Já temos isso. Exemplo de imagem é igual a esta imagem de componente get ponto. Então é assim que obtemos o componente de imagem. Isso não deve ser muito surpreendente, porque mais uma vez, a imagem aqui vai. A imagem aqui é mais uma vez, apenas um componente normal e é realmente muito facilmente acessível. Então, como podemos mudar esses sprite? Bem, nós só fazemos Dot Sprite. Isso é tudo o que é. Este é exatamente o campo que precisamos acessar para alterar o spread. Então, é basicamente quase exatamente o mesmo que o renderizador de sprite. Então a imagem em si não é realmente tão complicada. E há uma coisa interessante, que seria a imagem bruta. Então, se eu adicionar a imagem bruta aqui, se olharmos para isto agora e fizermos esta para que a desbloqueemos. Então, como você pode ver, a imagem bruta aqui é um pouco diferente porque em vez de pegar um sprite, isso requer textura. Então, se você, por exemplo, e isso é algo que não vamos olhar em detalhes, mas eu queria mencionar isso. Então, se você, por exemplo, tem uma câmera que você deseja alimentar, então, uma webcam, então você não poderia, quero dizer, mesmo basicamente um filme, isso pode ser exibido em uma imagem bruta porque isso pode ser traduzido para uma textura. Não vamos entrar em detalhes com isso, mas isso é uma das coisas em que a imagem bruta faria mais sentido. E como você pode ver, então ainda podemos colocar o clicker aqui. Então isso não é um problema. Mas agora isso seria uma textura, certo? Mas no geral, isso já seria para as imagens. Eu sei que isso não é nada louco ou também. Sim, interessante. Mas é assim que você adiciona uma imagem à sua interface do usuário. Assim como com tudo o resto na interface do usuário, você pode centralizá-lo. Faça o que quiser com o reitor, transforme, mexa e todo esse jazz. Mas, no geral, é muito, muito semelhante ao renderizador sprite. Certo? E isso seria tudo para esta palestra. Como eu disse, um pouco mais curto. Mas isso não é tão ruim porque as imagens são, pelo menos em termos de interface do usuário depois de termos visto o renderizador sprite. Não é tão complicado, certo? Espero, eu ainda espero que você tenha achado isso útil. Se houver alguma dúvida restante , sinta-se à vontade para perguntar e eu responderei. E sim. 75. (Unity UI) botões, podem ser de mais de dois podem ser de mais: Tudo bem, vamos continuar com a introdução do Unity UI aqui para o curso de unidade. E nesta palestra, vamos dar uma olhada nos botões. Então, já vimos um componente botão na última vez no clicker de queijo, onde fizemos alguns botões que pudemos clicar. E agora nós vamos realmente adicionar um botão normal a partir daqui. Então clique com o botão direito do mouse no painel, por exemplo, u, i, e escolha o botão. Vamos usar o botão normal ou o texto Mesh Pro para este exemplo aqui. E sim, então uma vez que isso é realmente adicionado aqui, podemos basicamente redimensioná-lo como qualquer outro objeto normal basicamente. E o componente interessante neste botão é basicamente o componente de pão bem aqui. Agora já vimos um pouco disso, mas não muito. O texto que é exibido no botão é outro componente de texto abaixo dele, basicamente como um filho. E podemos fazer isso maior. E, por exemplo, diga Click Me, Algo assim, certo? Vamos fazer isso melhor. Lá vai você. Então agora diz “Clique em mim “Se olharmos para o jogo lá está, aí está o botão. E nós podemos realmente ter algumas coisas que podemos basicamente colocar em. Então número um, podemos definir se isso é intratável ou não. Então, se não for interactable, basicamente obtém isso, obtém a cor desabilitada que é notificada aqui. Vamos ver a cor desativada aqui. Então nós também podemos dizer, oh, bem nós queremos torná-lo vermelho, mas eu acho que faz sentido ter este tipo de acinzentado. Isso é o que a maioria das pessoas esperaria de um botão desativado. Há também quando ligamos novamente, temos a cor normal. Então temos uma cor que é destacada. Então, se passarmos o mouse sobre ele, então isso é alterado para esta cor é enquanto eu estou pressionando a tecla do mouse, por exemplo. A cor selecionada é se, por exemplo, estamos nos movendo com as teclas de seta no teclado, porque podemos basicamente selecionar diferentes tipos de elementos de interface do usuário com as, uh, teclas lá também. Também temos um multiplicador de cores e uma duração de desvanecimento. Nós também podemos realmente mudar a transição, para que possamos realmente ter uma animação particular associada a ela. Podemos até mudar o sprite em si. Então, se você tiver diferentes sprites preparados para o botão, então você também pode fazer isso. E a navegação aqui, que é exatamente o que é basicamente, portanto, as teclas de seta em seu teclado para que você possa alternar entre certos botões, por exemplo. Então, se eu fosse duplicar este botão Control D, e eu vou colocá-lo aqui, então nós podemos realmente olhar para a navegação visualizada. E como você pode ver, se eu pressionar a seta para a direita, eu mudaria para este aqui. Se eu saísse chegaria mudaria para este agora, esses são os únicos botões interativáveis que existem. Então é isso que a visualização mostraria isso. Mas também temos, é claro, o onclick, que é a única coisa que realmente vamos dar uma olhada rápida. Então vamos ver que isso é um grande, Nós realmente não mudamos o que duplicamos a cena e mudar algo. Inacreditável, Isso não é algo que possamos fazer. Então vamos realmente fazer a imagem real aqui, botões L5. Vamos recarregar isto e depois a cena duplicada que vamos fazer como está. E isso vai ficar bem também. Então, os botões L5, o que podemos fazer aqui? Vamos criar um novo script, botões L5. E nós estamos realmente indo para criar um dois scripts neste caso aqui. Um deles é só um botão. Então eu vou mostrar algumas coisas que podemos fazer nos scripts com botões. E então há outro script, este é apenas o exemplo de saída. Digamos, vamos chamá-lo de algo assim. E vamos criar um novo objeto vazio aqui, que vai ser o exemplo de saída. E coloque isso em 000 e coloque o script de saída de exemplo lá. E então, se descermos até o botão do painel, adicione o script de botões a esse. O ego, aí está. E ainda assim vamos abrir os dois e ver o que podemos fazer aqui. Então, o primeiro vai ser, Vamos fazer olhar para o exemplo de saída. Vamos fechar os outros. Dentro daqui. Na verdade, só teremos um vazio público. E então digamos que uma saída, saída algo que é o nome do método. E este método é simplesmente indo para basicamente log, eu tenho saída algo, eu tenho saída algo, algo. Lá vai você. E isso é basicamente a coisa que poderíamos adicionar a este botão. Então, se olhar para o botão novamente, então podemos adicionar manualmente um evento on-click. Isso acontece se colocarmos uma vantagem. E aqui nós podemos realmente colocar em tudo para que possamos ou colocá-lo em, como você pode ver, podemos colocar em scripts, podemos colocar em diferentes, quase todos os objetos que podemos basicamente puxar lá dentro. Mas o que queremos colocar é este exemplo, saída GameObject. E se colocarmos isso lá, então podemos acessar todas as suas funções. Assim, por exemplo, as funções do objeto do jogo, podemos alterar o nome. Podemos configurá-lo activado ou desactivado. Então isso também é meio útil para algumas coisas onde você não precisa necessariamente criar novos métodos para isso. Podemos definir a transformação para que possamos realmente fazer algumas coisas aqui também. E também podemos acessar o script de saída de exemplo de componente, que então também tem a saída Algo método aqui que podemos basicamente colocar lá, certo? Então, se agora clicarmos nisso como você pode ver, eu tenho algo de saída. Então, o método neste exemplo, saída está realmente sendo chamado sem problemas. Agora, há outra maneira de adicionar novas funcionalidades a um botão através do script. E nós vamos dar uma olhada nisso agora no script de botão, em uma espécie de script Bund. Primeiro de tudo, é claro, precisamos estar usando o framework UI do motor Unity, framework UI, ou melhor, namespace que você vai. E então nós podemos realmente apenas ainda Vamos apenas fazer um botão privado. Então este é o botão, digamos. E que um vai ser definido para este ponto obter botão Componente. Então essa é uma digitalização do componente ou do método do componente brilhando através e o botão. Podemos então basicamente ter este onclick e este é um evento clique como você pode ver. E podemos adicionar ouvintes a ele. Dentro daqui. Como você pode ver, os parâmetros devem ser uma unidade Eventos, Unidade ação. E podemos basicamente fazer isso fazendo uma expressão lambda aqui. Então, por exemplo, poderíamos dizer log de pontos de depuração e, em seguida, algo como quatro ruídos. Por que não? Vamos ter um ano mais engraçado. Por que eu não estaria certo. Então, isso seria, então, por sua vez, ter simplesmente chamado isso. Nós também podemos, se temos outro método aqui, você também pode dizer privado. Digamos que evite testar botão ou algo assim. Depurar log de pontos. Mais uma vez, pareça algo como eu apertei o botão. E também podemos adicionar isso fazendo ouvinte on-click. E então podemos simplesmente colocar no botão de teste como uma espécie de apenas o nome do método sem ter sido em uma chamada de método. Portanto, não coloque os parênteses aqui, mas apenas o nome real do método. E isso também funciona. Então, isso é então vai chamar este método quando o botão real é clicado. Então vamos ver se isso funciona. Então o que devemos esperar ver é que queremos ver eu tenho saída algo para ruídos e, em seguida, o IF clicou no botão. Então vamos ver se esse é realmente o caso. Nós, a propósito, não podemos ver as mudanças no onclick aqui. Mas o que não podemos ver são os quatro ruídos e eu apertar o botão. Então, esses estão sendo chamados sem problemas pelo clique no botão. E este é basicamente o ouvinte de anúncios aqui. Pode ser incrivelmente útil se você quiser definir as diferentes funcionalidades para o botão, talvez dependendo se algo está aberto ou fechado ou mesmo se você tem diferentes, você sabe, painéis de controle ou algo assim. Então, há alguma funcionalidade e alguma utilidade para isso, definitivamente. Mas, no geral, isso já é para o botão. Não é tão excitante. Mais uma vez, há, é claro, algumas coisas onde podemos mudar as cores e algo assim e a intratabilidade. Mas também vimos as mudanças da intratabilidade e um pouco para a adição de novos ouvintes. Eles estão no clicker de queijo. E, no geral, isso seria bom para o botão. Não há nada de louco demais nisso. É basicamente apenas um elemento de interface do usuário que você pode clicar. E isso seria tudo para esta palestra como sempre, espero que você tenha achado útil e você aprenda algo novo. Se houver alguma pergunta, é claro, como sempre, sinta-se à vontade para perguntar e eu vou ter certeza de responder. E sim. 76. (Unity UI) alternam e controles deslizadores: Tudo bem, vamos continuar a introdução da UI do Unity aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em alternâncias e controles deslizantes. Então, primeiro de tudo, vamos duplicar nosso L5 visto até torná-lo L seis controles deslizantes totais. E vamos também, sim, na verdade nós não precisamos criar nenhum script para isso porque aqueles, bem, quero dizer, a maioria disso realmente vai ser bastante auto-explicativo. E você vai acessar as partes específicas do componente, os campos e propriedades do componente. Tudo o que vimos até agora, então, sim, dentro da tela, vamos primeiro adicionar um novo painel aqui. Então, aqui em baixo, um painel. E vamos colocar isso no lado direito da tela. Então painel, Vamos colocá-lo também transformá-lo de volta nos aparelhos que, que seria meio útil um ego. E sim, tudo bem. Nós também podemos mover o texto para longe um pouco. E, em seguida, início deste painel, temos dois elementos de interface do usuário para adicionar. Um deles vai ser o botão de alternância primeiro. Então vamos fazer isso um pouco maior e eu vou dar uma olhada nisso. E, em seguida, vamos também adicionar-lhe imediatamente os controles deslizantes. E nós podemos realmente fazer isso maior e imediatamente ver algo. Então isso é muito legal. Então vamos dar uma olhada na alternância primeiro. Assim, a alternância, o objeto de jogo real tem o componente total para ele. Vamos dar uma olhada nisso daqui a pouco. Mas primeiro vamos dar uma olhada no fundo da marca de seleção e do rótulo. Portanto, o rótulo é um objeto de texto normal, que geralmente é o que mostra o que essa alternância em particular faz. Agora, nós podemos apenas dimensionar isso para que possamos realmente ver o que está acontecendo aqui. mesmo com o fundo e a marca de verificação. Ambos são apenas uma imagem. Basicamente. Tanto o fundo como a marca de seleção, apenas uma imagem que você poderia substituir mesmo. Você pode, claro, também escalar este. Então, primeiro de tudo, digamos dimensionando o, dimensionando o plano de fundo e, em seguida, a marca de seleção também pode ser dimensionada X2. Vamos acertar este. E então, se pressionarmos a tecla Alt enquanto a redimensionamos, então podemos redimensioná-la de todos os ângulos diferentes. Depende se você quer ou não uma marca de alternância tão grande. Mas é claro que isso é algo que você poderia, por exemplo, fazer. E então isso é basicamente apenas a marca de seleção no fundo lá apenas para muito facilmente entender imagens. E o rótulo, como eu disse, é apenas o texto. E então a alternância é a que é interessante. Então, mais uma vez, interactable para que possamos realmente ativá-lo e desabilitá-lo. A transição é a mesma. Podemos participar de uma cor ou podemos alterar o sprite ou ter uma animação associada a ele. Então isso é basicamente tudo o que já vimos no botão. A diferença aqui é apenas que temos um valor desconhecido alterado. Basicamente método que é chamado quando o valor muda. Mas isso é realmente também um evento que você poderia, por exemplo, assinar que nós vimos com nossos próprios eventos. Este é um desses eventos, em teoria, com os quais poderíamos fazer isso. E aqui podemos simplesmente adicionar também. Então, por exemplo, saída de exemplo. Mais uma vez, quando ele muda, podemos, por exemplo, dizer na saída de exemplo de alternância e função e, em seguida, dizer saída algo. Isso, é claro, também funciona se tivermos o método que somos queridos chamar. Se isso realmente tem um parâmetro booleano, então ele também vai passar o parâmetro booleano que estamos alterando, a alternância para. Então isso é muito legal. Está ligado é basicamente exatamente o booleano que queremos verificar. Então está ligado, faz um tick aparecer, e então se não estiver, então, neste caso, o está no booleano é falso e não há nenhum tick lá. Então vamos usar o botão de alternância uma ou duas vezes. Então, como você pode ver, eu posso clicar nisso e como você pode ver, eu tenho algo de saída. E então, se mudarmos novamente, isso acontecerá mais uma vez, porque agora só estamos procurando uma mudança de valor. Então nós apenas olhando se esse valor realmente muda de verdadeiro para falso ou de falso para verdadeiro. Então, por exemplo, se mudarmos o rótulo, isso pode, por exemplo, ser algo como uma opção de morte perma. Como exemplo, quando se trata do controle deslizante, esta carta é, eu diria, meio que em torno da mesma complexidade. É um pouco mais complexo. Então, temos mais uma vez uma imagem. Esta é simplesmente a imagem de fundo do controle deslizante. Eu aconselharia a manter isso como uma espécie de o mesmo comprimento. A área de preenchimento na área de preenchimento será mostrada uma vez que realmente movamos esta alça, alça, pequena área e a alça, basicamente a alça que podemos movê-la, que você não deve mover a alça independentemente do controle deslizante. Porque o controle deslizante aqui, quando damos uma olhada no valor aqui, se alterarmos isso e como você pode ver, o controle deslizante realmente muda. E a coisa realmente legal sobre este controle deslizante aqui é que podemos realmente dizer, Ok, primeiro de tudo, que direção ele vai da direita para a esquerda, da esquerda para a direita, de cima para baixo, ou de baixo para cima e, em seguida, de cima para baixo. Vamos mantê-lo da esquerda para a direita. Agora, mais uma vez, todas as coisas habituais que são capazes de ser feitas, transição interativa as cores, você sabe, isso é, isso é tipo de coisa. E o valor mínimo e máximo outras coisas que são realmente interessantes. Porque a idéia aqui é que se basicamente movemos isso, podemos, por exemplo, dizer, bem, queremos que o valor mínimo seja 0 e o valor máximo seja 100, por exemplo, certo? Então você pode mudar isso. E como você pode ver agora esse número muda aqui de 0 para algo assim. E também podemos dizer, bem, queríamos que isto fosse apenas números inteiros ou não queremos que isto seja números inteiros. Então você poderia, por exemplo, eu acredito que se eu colocar no 10.5, então isso funcionaria. Se eu tiver números inteiros, então somente inteiros são basicamente a coisa que funcionaria no valor aqui. Então isso é muito legal. Podemos dizer que também podemos dar negativo, certo? Isso funciona bem. Então isso é realmente muito legal para enviar valores diferentes para isso. Então isso pode, por exemplo, ser A1 e FMV ou algo assim. Se quisermos um texto para isso, teremos de o acrescentar nós próprios. Mas isso não deve ser um problema. Então nós podemos, por exemplo, apenas dizer texto da interface do usuário e, em seguida, adicioná-lo aqui, para trás lá e, em seguida, torná-lo um pouco maior. Diga algo como f de v, por exemplo. E então temos uma mensagem aqui. Então, isso também funcionaria como um exemplo. E sim, nós também podemos mudar isso. Então dentro do nosso jogo, quando temos isso, se selecionarmos o controle deslizante e você pode ver agora o valor é 35. E se eu clicar sobre isso e realmente mudá-lo, e como você pode ver esse controle deslizante, o valor muda também. Eu também posso acreditar, ok, Scroll dispostos não funciona assim, mas você pode usar as teclas de seta para basicamente mover da esquerda para a direita para o valor. E mais uma vez, há outro evento aqui que você poderia assinar. Então, o valor mudou. E isso dá a você o valor com ele como um parâmetro. Então, em teoria, você poderia ter um método y'll que tem, que avalia a mudança aqui. E se for algo particular, então algo pode acontecer lá. Certo? E isso seria basicamente para as alternâncias e os controles deslizantes. Eu acho que eles são principalmente úteis em menus de opções. Fora isso, eu não tenho 100% de certeza de onde você iria usá-los, mas eu acredito que muitas pessoas podem criar outras maneiras criativas em que você poderia ou deveria ser capaz de usá-los, certo? Mas será isso para esta palestra como sempre, espero que você tenha achado útil e você aprenda algo novo. Se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu responderei. E sim. 77. (Unity UI) Layout no Unity no Unity: Tudo bem, vamos continuar com a introdução do Unity UI aqui para o curso de unidade. E nesta palestra vamos dar uma olhada nos layouts. Então, isso é basicamente onde nós damos uma olhada em bem, layouts e como tipo de automatizar o layout de sua interface do usuário. E para isso, eu já criei o layout L7 como uma cena, então você pode fazer isso também. E para isso, vamos adicionar uma nova tela aqui. Claro, esta tela vai estar sob a câmera espacial mundial, câmera principal. E então nós também vamos ter certeza de que ele tem o mesmo escalar aqui. Então, escala com o tamanho da tela, 1920 a 10 , 80 e 85, e os pixels de referência, vamos defini-la para 200, apenas para o inferno. Certo? E agora vamos adicionar um painel. Vamos ver, lá vai você. E então vamos duplicar este painel três vezes para que tenhamos três painéis. E todos esses três painéis vão ser crianças do primeiro painel. E o, este, vamos apenas redimensionar o painel. Número um, vamos redimensionar e colocá-lo aqui. E então vamos redimensionar este também. Não precisa necessariamente ser do mesmo tamanho. Simplesmente semelhante. E nós vamos colocar isso no meio bem aqui. E então vamos pegar o último painel e fazer algo muito parecido. Para que agora tenhamos três painéis ao lado um do outro. E de repente assim, isso funciona muito bem. Vamos realmente escalar isso um pouco para que eles são tipo do mesmo tamanho, não é como eu disse, e eu tenho que ser do mesmo tamanho porque nós vamos mudar os tamanhos de qualquer maneira. O primeiro que vamos olhar é o layout vertical. Então eu vou chamar isso de layout vertical. E o que é muito legal lá é que podemos basicamente ter um certo tipo de grupo de layout nesses painéis. Primeiro de tudo, nós vamos criar uma espécie de, um novo, bem, eu estou tipo de dizer como uma exibição. Então vamos adicionar um novo painel aqui. E nós vamos fazer isso como alguns assim para que ele seja meio centrado. E então neste, vamos adicionar mais alguns detalhes. Então, por exemplo, uma nova imagem. Então você pode pensar sobre isso, talvez assim seja talvez uma tela de seleção para um determinado item ou algo assim. Então temos uma imagem aqui. Não vamos preenchê-lo, vamos apenas mantê-lo como está. Quero dizer, poderíamos preenchê-lo com um clicker, eu acho. Não assim, mas assim. Então podemos, por exemplo, colocar o clicker lá dentro. Por que não? E, em seguida, no painel, nós também vamos adicionar um novo texto. Então nós vamos ter talvez um texto no topo, que vai ser algo como muito legal, muito legal item, certo? E então vamos fazer isso um pouco maior para que possamos realmente lê-lo corretamente. Vamos fazer o melhor ajuste. Sim, isso é bom. E então vamos duplicar este texto e talvez ter uma descrição aqui. Então vamos usar algo como Lorem Ipsum para este. Então lá vai você. Certo, então agora temos basicamente um pequeno painel legal aqui. Pode ser um painel de itens ou algo assim, o que gostaríamos, bem ter isso exibido de forma vertical. Então queremos que isso seja exibido assim. E depois o próximo aqui e o próximo aqui. Claro, podemos duplicar esse Controle D e, em seguida, mover o segundo um pouco para baixo. E assim por diante e assim por diante. Mas não funciona tão bem como gostaríamos. E, portanto, o que podemos fazer é simplesmente colocar um layout neste painel aqui. E é isso que vamos fazer. Então nós vamos para Adicionar Componente, hum, e então para colocar para fora aqui. E então vamos usar o layout vertical neste. Agora, em primeiro lugar, como você pode ver, tudo quebra aqui. Não se preocupe com isso. Vamos usar, vamos fazer isso e consertar isso em pouco tempo. Então podemos voltar aqui e, como você pode ver, alguns valores são impulsionados pelo grupo de layout vertical. Então isso significa que isso basicamente muda. Agora podemos mudar isso de volta. Então vamos para o painel de itens aqui, certo? Troquei um pouco de volta. Podemos, no entanto, como podem ver, mudar a sua posição. Nós podemos mudar o tamanho aqui, mas podemos mudar a posição agora o tamanho realmente não importa agora como ele parece. Porque nós também vamos dizer usar escala infantil, que basicamente a criança, se nós realmente, essa não é a escala, seu tamanho. Lá vai você. Então, se fizermos isso, então se dissermos controlar o tamanho do filho, então ele irá dimensionar até exatamente o tamanho de seu pai. Então o painel aqui vai dimensionar até seu pai. E agora a coisa legal com o grupo de layout e o grupo de camada vertical para isso também, podemos dizer um preenchimento. O preenchimento é basicamente o espaço entre a criança e suas fronteiras pais, por assim dizer. Então, se eu sair daqui, como você pode ver, ele fica menor na esquerda. Então podemos, por exemplo, dizer 15, 15, 15 e 15. Então agora ele vai ser movido para o meio. E meio que 15. O espaçamento também pode ser predefinido. Então vamos colocar um 15. E se você duplicar este painel de itens, veja o que acontece. Eles automaticamente layout que, colocam-se aqui fora com um 15 espaçamento entre eles e em todos os lugares da fronteira de nós também temos um 15 Yup. Unidade. Basicamente espaçamento ou preenchimento. Nesse caso. O alinhamento da criança simplesmente diz: “Ok, onde começamos com esse alinhamento? Neste caso, realmente não importa. Onde poderia importar é se você colocar em mais baixo então nós contaríamos de baixo para cima basicamente. Mas no canto superior esquerdo seria bom. Arranjo reverso simplesmente inverte a ordem disto, a escala e o tamanho, como eu disse. Então, se você colocar o tamanho, por exemplo, para a altura, agora, nada muda aqui, mas podemos expandir isso. Para forçarmos a criança a expandir-se. E isso é muitas vezes o que queríamos fazer. Porque se agora adicionarmos mais, como vocês podem ver, agora em algum momento, ele fica um pouco lotado demais. Mas, por exemplo, na verdade funciona muito bem e parece muito bom. Então este seria o layout vertical. Agora, em seguida, o próximo é o layout da grade também utilizável? Muitas vezes, vamos realmente copiar um desses painéis de itens e colá-lo aqui. Para o layout da grade e certifique-se de que ele realmente é uma espécie de centrado aqui. E vamos fazer isso um pouco. Então nós estamos realmente colocar a descrição tipo de aqui. E então o, você tem algo assim. Então vamos colocar isso aqui e então o nó girá-lo embora. E então o texto do título vai subir no topo e talvez fazer isso um pouco menor também, algo assim. E sim, vamos ver se isso funciona também. Então talvez um pouco menos de texto e, ou um pouco menor de uma imagem. E está tudo bem. Agora para o layout da grade. Então, mais uma vez, sob layout, podemos simplesmente dizer layout de grade. Ele irá redimensionar imediatamente o painel de itens aqui. E vamos nos preocupar com isso daqui a pouco, porque neste momento, este tamanho de célula é exatamente o que ele faz. Por isso faz deste um tamanho específico. Vamos primeiro de tudo, olhar para o preenchimento novamente, que é o movimento mais uma vez é exatamente o mesmo. Então, se eu disser 15, 15, 15, e 15 então vai ter preenchimento para a borda do pai. Basicamente, o tamanho da célula é exatamente especifica o tamanho de cada uma das células. Então, por exemplo, poderíamos dizer algo como, bem, talvez um 150 é suficiente, mas por que ele precisa ser como 200. E isso poderia funcionar, certo? Assim, podemos, por exemplo, tornar isso um pouco menor também. Então podemos fazer isso um pouco menor, certo? Então isso caberia e tornaria isso um pouco menor. Vai ser difícil de ler agora, mas isso é claro, mas isso é claro, apenas um exemplo de qualquer maneira. Então lá vai você. Então isso não funcionaria em teoria. E então, se fôssemos adicionar um novo painel de itens, podemos ver imediatamente que ele é adicionado aqui à direita. E se adicionarmos outro deste lado, não há espaço suficiente. Então ele é adicionado à próxima linha, por assim dizer. E se eu expandir isso um pouco, então, como você pode ver, agora ele realmente é adicionado à mesma linha lá. Então isso é muito legal. Também podemos ter algum espaçamento. Então este é o espaçamento entre os elementos reais, os elementos de layout. Podemos ter um canto de partida diferente. Assim, por exemplo, podemos começar no canto inferior esquerdo ou podemos começar no canto inferior direito. Agora isso não funciona. Não tenho 100% de certeza do porquê. Eu vou porque o alinhamento lá vai você. Então, o alinhamento realmente também garante onde isso começa, uma horizontal ou vertical, certo? Então, podemos primeiro preencher as colunas e, em seguida, as linhas ou uma coluna por coluna, ou podemos ir linha por linha. E as restrições flexíveis também podem ser flexíveis. Tão flexível significa que tudo o que se encaixa, ele se encaixa. Se a restrição é contagem de coluna fixa, então podemos dizer, ok, nós só temos este muitas colunas, ou podemos ter uma contagem de linhas fixa. E então nós podemos basicamente mudar quantas linhas existem ou quantas colunas eles têm que ser. Então, há realmente muito para brincar com o layout da grade. Eu só posso realmente, eu diria conselhos para brincar com ele um pouco. O layout da grade é um dos meus favoritos e funciona muito, muito bem. Então, se eu apenas copiar alguns deles e eu vou dizer que eu realmente, eu realmente não gosto do espaçamento desses. Posso adicionar o espaçamento aqui e tudo faz o que faz. Então, acho isso muito legal. E também é realmente ótimo porque quando você gera elementos de interface do usuário, então a idéia é que eles automaticamente é colocado para fora de uma maneira que funciona. E o último seria o layout horizontal. Layout. Vamos também copiar um desses e colocá-lo aqui. E o layout horizontal não deve surpreender ninguém, também está em Layout sob layout horizontal. E este significa simplesmente, então se eu adicionar outro, então eles são adicionados de forma horizontal. Então, não há grade neste caso. Então você também poderia, por exemplo, expandir estes para ser algo como um não, lá vai você, este para ser como um muito longo. Por exemplo. Vamos apagar essa e fazer esta outra vez. E então poderíamos dizer para o layout horizontal, mais uma vez, preenchimento o mesmo espaçamento é o mesmo entre eles. E podemos reverter o, podemos controlar o tamanho, certo? Isso também funciona. Então, controlando o tamanho mais uma vez, misturar isso se expande para ser o tamanho inteiro. Espaçamento deve ser auto-explicativo fora preenchimento em vez disso neste ponto, espaçamento ou tudo aqui deve realmente ser auto-explicativo. Se vimos tanto o layout vertical quanto o da grade, eles são todos muito parecidos, mas fazem coisas ligeiramente diferentes, certo? E isso seria tudo para o layout. Palestra aqui. Layout é incrivelmente útil, especialmente se você tiver um tipo de UI Prefabs que você instanciar em sua interface do usuário. Por exemplo, se você tiver, não sei, como 10 itens, então você quer um exemplo de 10 itens aqui, 10 opções que você pode clicar. E talvez se você quiser, se você tem 20 itens, bem, então você quer 20 desses, e eles devem ser definidos de uma maneira particular, então você pode basicamente facilitar isso com, por exemplo, o, seja o layout vertical, o layout de grade ou o layout horizontal. Então ferramenta incrivelmente útil para estabelecer automaticamente elementos de interface do usuário, certo, e que seria isso para esta palestra. Espero que tenha achado útil. Se tivesse, claro, eu agradeceria uma crítica sua. Caso contrário, se houver algumas perguntas, então, é claro, sempre sinta-se livre para perguntar e eu vou ter certeza de responder. Sim. 78. (Unity UI) rolagem e máscaras: Ou eu, vamos continuar a introdução da UI do Unity aqui para o curso da unidade. E nesta palestra vamos dar uma olhada nas barras de rolagem e no componente de rolagem destruído. Esse tipo de trabalho de mãos dadas. No nosso caso, o que eu quero mostrar a vocês é basicamente como ele poderia fazer uma espécie de vista. E, em seguida, role para cima e para baixo, tem basicamente vários elementos presentes ao mesmo tempo. E para isso, vamos simplesmente duplicar o layout L7. E vamos nomear esta barra de rolagem LH. E vamos abrir isso imediatamente. E para ninguém surpresa, isso parece exatamente o mesmo porque nós apenas duplicamos a cena. E nós vamos fazer isso como um exemplo no layout vertical aqui. E a primeira coisa que vamos fazer é tornar isto muito maior. Então o livro, nós não queremos movê-lo, nós realmente só queremos torná-lo maior. Então o painel de layout vertical real em si vai ficar muito maior. E então vamos apenas duplicar o último painel de itens aqui e ter mais alguns. Não vamos fazê-los correr para fora da tela lá ou para fora do painel de layout real, mas apenas assim, então deve ficar bem. E então o que queremos é basicamente definir isso. Bem, nós vamos ter uma espécie de, um novo painel que é tipo deste tamanho onde vai tipo de agir como uma janela e o resto não vai ser visível. Essa é a ideia aqui. E é assim que vamos olhar para a barra de rolagem. A maneira como podemos fazer isso é antes de tudo, vamos fazer algo assim. Então vamos fazer um novo painel, não basicamente como um irmão para o painel de layout vertical. E isso vai estar sob um painel de interface do usuário. Agora isso vai ser realmente grande, mas isso é, nós podemos redimensionar isso para aproximadamente o mesmo tamanho que o original. Então alguém assim. E então vamos dar um pouco mais no lado direito para que tenhamos um pouco de espaço de leitura para nossa barra de rolagem. Neste painel será o que no topo aqui e vamos chamar isso de painel de rolagem. - Claro. E este vai precisar. Vamos realmente também ter certeza de que isso está centrado corretamente. Lá vai você. Isso deve funcionar muito bem. E então vamos adicionar dois componentes a ele. Um deles vai ser o pergaminho ereto. Este pergaminho destruído. E então o outro vai ser uma máscara. E assim que adicionarmos a máscara, você verá que isso imediatamente mudou basicamente algum visual. O nosso não os mudou visual. Ainda não, de qualquer maneira. Claro que não porque ainda temos que tomar o layout vertical e realmente tê-lo como um filho disso. E assim que fizermos isso, agora muda algo visual, visual. Como você pode ver, de repente, o layout vertical real é uma espécie de corte neste ponto porque o layout de rolagem agora é uma máscara. Então, tudo, o tamanho dele realmente depende de onde o alcance visual disso depende do tamanho do layout do scroller aqui. Então, quanto maior o layout pequeno, o layout de rolagem maior a coisa que podemos realmente ver. E este, então, agora nos habilita. Então, se formos mover este layout vertical para a direita. Vamos mover isso, como você pode ver agora ele meio que se move para cima e para baixo. Agora, se pudermos fazer isso em uma espécie de conjunto com uma barra de rolagem, bem, quero dizer, então tudo funcionaria muito bem. E isso é exatamente o que vamos fazer no painel de rolagem abaixo disso. Então, selecionando esta interface do usuário e, em seguida, adicionando uma barra de rolagem, vamos adicionar uma barra de rolagem aqui. Agora, o que é importante? O componente da barra de rolagem em si realmente se parece com o componente de controle deslizante. Como se fosse, é praticamente a mesma coisa. Para nós, para este robô, o que queremos é que ele seja de cima para baixo, eu acredito. Sim, é isso que queremos. E então nós também podemos redimensioná-lo. Então vamos fazer algo assim. Coloque-o à direita da tela aqui. Vamos fazer algo assim e depois movê-lo para baixo. Lá vai você. É uma espécie de barra de rolagem. Eu acho que isso é realmente muito bem feito. E eu sou a barra de rolagem em si. Na verdade, não precisamos mudar nada. O que precisamos mudar é que as coisas no pergaminho se corrigem. E as coisas que queríamos mudar no reto de rolagem, em primeiro lugar, onde só queríamos um movimento vertical aqui porque isso só se move para cima e para baixo. E então queremos definir uma barra de rolagem vertical, que é exatamente a barra de rolagem que acabamos de adicionar. E então também queremos adicionar conteúdo. E esta é basicamente a Transformação Rect. Então este seria um componente de interface do usuário que tem o componente de transformação de naufrágio anexado a ele, que queremos mover. E este é exatamente o layout vertical aqui. Depois de adicionarmos ambos, isso é realmente tudo o que precisamos fazer para ter uma espécie de layout vertical funcional, tipo barra de rolagem negócio. E eu acredito, no entanto, que realmente o que queremos é de baixo para cima, eu acredito, sim, a direção é na verdade de baixo para cima. Vamos ver se isso funciona. E sim, faz. Então, se eu rolar para baixo agora ele está rolando para baixo, mas como você pode ver, ele está indo muito devagar. Posso fazer mais duas coisas. Eu posso, claro, pegar a barra de rolagem e movê-la assim. E eu também posso clicar no painel de layout vertical e movê-lo por conta própria. E eu também posso deixar isso ir como você faria em um smartphone. Agora, se eu subir, você pode ver que é um pouco saltitante no topo. Isto pode ser mudado aqui. Então este é o tipo de movimento. É elástico. Eu pessoalmente preferiria aclamado como uma espécie de como quase todas as outras barras de rolagem funcionam. E também eu definitivamente aconselharia a colocar a sensibilidade de rolagem lá. Algo como 25 deve ser, deve ser suficiente. Sim, agora funciona melhor, então é um pouco mais rápido. Com uma sensibilidade de rolagem de um, você é, quero dizer, você está rolando o tempo todo. Isso não é uma boa ideia. - Sim. E isso é realmente como é fácil adicionar uma barra de rolagem com um pouco de funcionalidade. Claro, mais uma vez, todas essas coisas que já vimos em basicamente todos os outros elementos interativos da interface do usuário, basicamente certo? Cor e tudo isso. E este, este tipo de acordo com basicamente também visto quando olhamos para os controles deslizantes. Isso é basicamente a mesma coisa. Podemos alterar o valor agora o valor, é claro, não podemos mudar porque ele está ligado ao rolagem ereta aqui. Mas geralmente nós podemos mudar o valor e então nós também podemos apenas ler o valor pelo seu script. Claro, colocando um qualquer um desses lá. Nós também temos este evento de valor ONE alterado onde podemos onde nós basicamente obter a mudança do valor. - Sim. E isso será basicamente para a barra de rolagem. Na verdade, não é tão ruim. E com a máscara e o componente vermelho de rolagem, você pode fazer algumas coisas muito legais como um layout de rolagem lá. E então agora poderia ser, você poderia adicionar a este layout vertical. Quero dizer, tudo o que você quiser e você pode rolar e rolar. E talvez você possa ter, sei lá, mil itens legais aqui. Nesse ponto, provavelmente seria melhor ter o layout da grade, mas sim, seria isso para a palestra da barra de rolagem aqui. Espero que tenha achado útil como sempre. Se houver alguma pergunta, então, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 79. (Unity UI) Dropdown e campos de entrada: Tudo bem, vamos continuar com a introdução do Unity UI aqui para o curso de unidade. E nesta palestra vamos dar uma olhada no menu suspenso, bem como o campo de entrada para os elementos da interface do usuário. Esses seriam os últimos elementos que se acredita que temos de olhar. Então vamos fazer uma nova cena, realmente nova cena L nove, chamando-a caiu para baixo entrada. Claro. Por que não? Vamos abrir isso imediatamente. E vamos também adicionar imediatamente um pequeno painel agradável aqui. A tela, é claro, precisa ser alterada para a câmera do espaço da tela neste caso, e adicionou a câmera principal lá. E vamos mudar imediatamente a referência. Na verdade, é 1920 por 1080. E faça o fósforo 0.5. Ótima. Isso deve ser tudo o que precisávamos fazer aqui. E, em seguida, para o painel, apenas vai redimensioná-lo um pouco. Coloque-o no meio da tela. E, em seguida, vamos adicionar os dois tipos de últimos elementos de interface do usuário que ainda não olhou vai ser o menu suspenso. Vamos fazer isso um pouco maior. Vamos, coloque-o aqui. E eu também vou adicionar a interface do usuário para o campo de entrada. Vamos também fazer isso um pouco maior. Lá vai você. De novo com isso, provavelmente seriam todos eles, certo? Vimos basicamente todos os outros. O sistema de eventos é adicionado automaticamente. E o ScrollView é basicamente o que fizemos da última vez, mais ou menos. Então vamos dar uma olhada primeiro na lista suspensa. Então a primeira coisa que vamos olhar é este rótulo aqui. Então os rótulos, é claro, podem ser redimensionados um pouco, 38, Isso é realmente muito bom na seta também pode ser redimensionado um pouco. Acho que isso faria sentido. Vamos fazer isso como um pouco maior. Lá vai você. Sim. Isso realmente parece muito bom para um menu suspenso. E há também este modelo que está atualmente desativado. Então, se nós ativá-lo e você pode ver que é assim se pressionarmos este outro. Então, se clicarmos nisso e, em seguida, vamos ter este tipo de modelo aqui. Você pode alterar o conteúdo específico lá, para que o item aqui seja alterável. No entanto, no geral, Eu provavelmente não iria mexer com isso muito porque o, Eu acredito que isso é realmente duplicado. Na verdade, podemos. Então vamos fazer isso um pouco maior do que assim como sim, isso, isso é definitivamente um pouco pequeno demais para tornar o item um pouco maior. Lá vai você. Os continentes a serem pagos mais no SDA atrás, e então o item deve ser redimensionado também. Lá vai você. Se você pressionar Alt, então ele vai redimensioná-lo em ambos os lados a partir do meio. E, em seguida, também podemos ajustar o tamanho da fonte particular aqui. Isto aqui à esquerda é, como podem ver, esta é a marca de verificação do item. E há também uma marca de seleção, o fundo e o rótulo do item. E há uma barra de rolagem associada com ele. Então isso é exatamente o mesmo que os registros de pergaminho. Você pode ver que há uma espécie de exatamente o que construímos da última vez. Apenas que isso já está embutido no próprio menu suspenso. Agora, isso é basicamente o que já vimos, mas o que não vimos são as opções aqui. E isso é basicamente uma coisa muito interessante. Temos opção um, opção, opção a, opção B, opção C, e podemos simplesmente adicionar opções a isso. Eu acho que nós vamos ficar com isso e nós também não vamos fazer nenhum sprite. Na verdade, vamos fazer o sprite no primeiro um clicker e os outros não terão um tudo dividido. E vamos ver como essa parece. Vamos dar uma olhada nisso. Então vamos começar isto e largar isto. E como você pode ver, que primeiro de tudo, nós podemos escolhê-los. E então teremos esta pequena marca de verificação. Eles devem observar qual dessas opções realmente foi escolhida. Agora, o modelo pode ser alterado da maneira que você quiser. Reggie pode torná-lo menor ou maior. Sim, basicamente, como você quiser, o sprite real em si não será exibido. Isto é uma espécie de algo no fundo. Você mais uma vez tem o evento aqui em um valor alterado. E, claro, as opções que você pode, com o menos aqui, você pode basicamente subtraí-las ou, você sabe, livrar-se delas. Você também pode reordená-los aqui. E isso, as opções aqui também seriam possíveis para alterar aquelas dentro do próprio script. Isso também funciona. Então vamos dar uma olhada nisso por enquanto. Então vamos fazer uma nova pasta. Este seria L9. Este é um menu suspenso, desça. Entrada, entradas. O, oh, tudo bem. E que vamos criar um novo, vamos chamar esse exemplo suspenso. E vamos deixá-lo recarregar. E depois vamos começar isto. Mas antes que queiramos mudar alguma coisa, eles são, vamos adicionar isso ao menu suspenso real também, só para que não esqueçamos isso porque isso seria fatal. Certo? Mais uma vez, não precisamos do método de atualização e usando o ponto do mecanismo Unity, vamos ter um privado. Isso seria uma lista suspensa. E isso é, em seguida, basta chamar este menu suspenso. Claro. A lista suspensa é igual a este ponto obter componentes. Drop, auto-explicativo este, e então ele caiu. E lá vamos nós. Opções. Então, isso, como você pode ver, é uma lista de dados de opções suspensas. Ok, isso é realmente muito legal. Também podemos definir o valor real. Isto é, isto seria um inteiro. Então é basicamente o índice da lista neste caso. Então o índice do elemento da lista que queremos. Mas, por exemplo, as opções que podemos adicionar lá, como você pode ver. Então esta é uma lista normal. Então, aqui podemos adicionar e, neste caso, queremos, pode ver os dados da opção suspensa. Então crença de que podemos fazer isso assim, sim, exatamente. Então podemos fazer novos dados de opção e como você pode ver, podemos dar-lhe uma imagem, podemos dar-lhe um texto, ou podemos inverter ambos. Então, em teoria, o que poderíamos fazer é algo como a opção S. Nós vamos chamar essa opção S porque ela foi gerada por um script, algo assim. E vamos ver se isso realmente funciona. Temos a opção D, a opção a e a opção C. E depois de começarmos, devemos esperar que a opção S apareça também. E se descermos lá embaixo, estará. Opção S também está disponível para seleção. E agora ele se foi porque é claro que foi gerado através do script. Então isso é realmente o quão fácil é adicionar as opções suspensas através do script. Você pode simplesmente criar uma nova instância de dados de opção suspensa lá e adicioná-la às opções. Certo? E isso é basicamente toda a loucura para a lista suspensa. Mudar visualmente não deve ser um problema. Já vimos muito disso basicamente com todas as outras coisas na interface do usuário. Então, sim, vamos passar para o campo de entrada. Então, o campo de entrada na verdade também muito fácil. Existe o campo de entrada em si. Há o espaço reservado e, em seguida, há o texto. Então, o espaço reservado, podemos fazer isso um pouco maior do que você pode ver isso, isso é simplesmente como inserir texto. Você também pode mudar isso para espaço reservado ou se você tem o seu jogo talvez em um idioma diferente, então é claro que você pode mudar isso bem em teoria. E o texto em si deve provavelmente ter o mesmo tamanho que este. Então vamos fazer este 59 também. E se começarmos isso e entrarmos aqui, então se eu clicar nisso, vou pegar essa carruagem. E eu posso digitar “Hello World”. E se eu clicar fora dele, você pode ver que o ano texto muda. Então isso basicamente é apenas um componente de texto, certo? Uma referência a um componente de texto, que é este. E ele só lê o texto que está aqui. Então nós podemos basicamente mudar este texto imediatamente. E isso também é salvo na variável de texto, diretamente no próprio campo de entrada. E aqui é exatamente onde você também pode ler. Há também coisas muito legais que você pode fazer. Então a cenoura pisca, eu acho que este é um vermelho piscar normal. Você também pode aumentar a taxa de piscar para que ela pisque mais rápido ou mais lento. Eu não sei se isso é necessariamente algo que você precisa e você também pode ajustar a largura. Eu acredito que cinco é o maior, então é um pouco mais perceptível aqui. Também podemos torná-lo uma cor personalizada, que é muito legal, na verdade, meio vermelho. É uma coisa legal com a qual você pode brincar. E sim, então você também pode obter desta vez até dois eventos diferentes aqui no valor alterado. Então, isso é basicamente quando a string em si muda e, em seguida, na edição final. Então, isso é quando você termina de editar. E então você não precisa basicamente chamar o valor alterando-o cada vez. Então, cada pouco, cada tipo de caractere específico seria incontestável no valor alterado, e, em seguida, na edição, string e um final Editar, desculpe, Lá vai você. On e edit basicamente dá-lhe este anel uma vez que você é feito com a edição lá. Então esses seriam os dois eventos que você poderia adicionar suas chamadas de função ou chamadas de método também. E sim, isso é basicamente tudo o que há para o campo de entrada. Não é nada louco ou sim, você também pode definir um limite de caracteres se você quiser. Isso é algo que você poderia fazer. E há algumas outras coisas, como multiline com Submit. Você também pode torná-lo uma nova linha multi-linha, e há também algumas outras coisas. Então, qual é o tipo de conteúdo aqui? Um pino, um número inteiro. Então ele pode realmente ler esse número decimal, certo? Então isso seria algo para o tipo de conteúdo. Você poderia mudar isso também. Mas, no geral, isso seria para o campo de entrada, digite o menu suspenso. E isso concluiria o tipo de olhar através, através de todos os elementos da interface do usuário do Unity. Eu mostrei a você basicamente todos eles. Agora, para fazer isso a interface do usuário muito bem, essa é uma outra questão totalmente diferente que está definitivamente em suas mãos mais do que a minha. Isso tem mais a ver com o tipo de design da experiência do usuário. E isso é difícil de ser ensinado. Eu quero te dizer, ou eu quero te ensinar as habilidades técnicas e depois o que você faz com elas. Espero que possa impressionar não só a mim, mas talvez a si mesmo e a muitas outras pessoas com o que pode inventar, certo? Então isso seria para a introdução da interface do usuário. Na próxima palestra, vamos adicionar mais algumas coisas de volta ao clicker de queijo. Então nós vamos adicionar um definitivamente pelo menos o layout. E então talvez possamos ver se há talvez uma ou duas outras coisas que possamos acrescentar lá, certo? Mas foi isso para a interface do usuário. E neste caso, a lista suspensa, uma palestra de campo de entrada. Espero que tenha achado isso útil e aprenda algo novo. Mais uma vez, se houver alguma dúvida, sinta-se à vontade para perguntar e eu responderei. E sim. 80. (Unity UI) Adicionar grupos de layout ao nosso Layout de queijo: Tudo bem, como prometido, nós nos encontramos de volta no “Cheese Clicker “aqui. E esta é a última palestra aqui para a introdução. E nós vamos apenas adicionar basicamente aos grupos de layout, um para o painel de construção e outro para o painel de atualização. Porque ambos, basicamente, poderiam bem, quero dizer, beneficiar deles. E vamos pensar sobre isso. Então, o próprio painel de construção, podemos simplesmente ir para o Adicionar componente, componente aplicativo painel de construção e, em seguida, adicionar um grupo de layout vertical. Acho que isso faria mais sentido. E deixe tudo controlar também o tamanho da criança e, em seguida, obter algo como 15, 15, 15, 15, e, em seguida, espaçamento também 15. Eu acho que isso realmente funciona muito bem. E se tivéssemos um terceiro elemento aqui, então isso funcionaria. E no quarto, precisaríamos começar a redimensionar um pouco. Ou também podemos pensar em não ter um grupo de layout vertical e talvez ter um grupo de layout de grade. Podemos ter dois desses ao mesmo tempo. Isso faz sentido. Então vamos remover isso. Vamos ter um grupo de layout de grade. E também certificando-se de que isso é um pouco maior, eu acho, porque caso contrário, isso não vai caber. Então algo como 300, 200 talvez, talvez 300, 300 realmente funcionaria. E, em seguida, também certificando-se de que temos um pouco de preenchimento aqui. Lá vai você. Então isso também funcionará se fôssemos mudar com os prefabs reais são um pouco. Mas eu realmente acho que vamos voltar para o grupo de layout vertical novamente. Acho que foi bom. E isso está bem, certo? E quando olhamos para o painel de atualização, é claro que esses são gerados através da UI de atualização. Vamos abrir isso também. Porque há uma coisa que é claro que precisamos mudar. E essa seria a transformação da posição local aqui porque nós estávamos definindo a posição nós mesmos. Agora não precisamos mais fazer isso. Então, podemos basicamente excluir essa linha completamente. E vamos, na verdade, comentar. Porque caso contrário, quem sabe, talvez seja melhor. E então podemos fazer isso um pouco menor e simplesmente simplesmente adicionar o grupo de layout de grade. Se um pouco de preenchimento, talvez 10 aqui, e então o tamanho da célula, eu realmente acho que o tamanho da célula de um 100 deve ser bom. Nós provavelmente podemos torná-lo um pouco menor, mesmo 8585, algo assim. E vamos ver como isso parece. Agora está tudo bem. Quero dizer, um pouco de espaçamento também seria bom. Então 10 espaçamento e então eu penso, tudo bem, isso é realmente muito bem feito. E se fôssemos adicionar novas atualizações aqui, poderíamos, claro, torná-lo um pouco maior, algo assim. E então as atualizações caberiam lá dentro também. Então isso é muito legal. Na verdade. É assim que é fácil ter um layout funcional. E isso é muito bom. Então vamos realmente adicionar um pouco de queijo para que eles acendam. Só para o inferno. Então vamos para 500 e sim. Sim. Então eles ainda funcionam totalmente bem mesmo que eles estão em grupo em camadas. E outra coisa melhor é que quando clicamos em um deles, eles ficam desativados, certo? Isso é o que estabelecemos. Assim, o conjunto ativo no objeto do jogo é definido como false. E se isso acontecer, então, como você pode ver, eles simplesmente se movem. Porque o grupo de layout basicamente estabelece seu auto fora apenas sobre os elementos do jogo ativo. Então, se formos reativar isso, na verdade só funciona. Então isso é realmente bom que, que funciona tipo de inerentemente para a interface do usuário no grupo de layout. Isso funciona sem problemas, certo? E então podemos adicionar uma espécie de outro painel aqui ou algo assim. Ou você também pode substituir todos os textos individuais com textos de malha Pro para ter uma sensação mais agradável para ele. Mas, no geral, eu acho que isso é realmente bom. Isso é o que eu imaginaria o que faríamos para o tipo de layouts diferentes, certo? O painel de atualização que achei ser o mais interessante. E então o painel de edifícios, se fôssemos adicionar mais alguns desses, provavelmente teríamos que realinhar nosso edifício real como painel de construção, o painel de construção individual um pouco. Mas no geral, isso ainda funcionaria muito bem, certo? E isso seria tudo para a interface do usuário. Por agora. Espero que você tenha achado isso útil e outro queijo slicker com isso seria meio completo. E espero que tenha aprendido algo novo. E se alguma pergunta permaneceu, é claro, como sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 81. (Unity intermediário Intermediário: Muito bem, e bem-vindos à seção intermediária da Unidade para este curso de unidade. E nesta palestra, vamos dar uma olhada nas fontes de áudio e basicamente como reproduzir áudio. E basicamente as opções que temos com isso. Então, primeiro as coisas, porque estamos novamente em um novo projeto, vamos primeiro configurar nossa pasta de ativos aqui. E neste momento vamos precisar de mais algumas coisas. Em primeiro lugar, é claro, os scripts mais uma vez, isso é um dado. E então vamos apenas duplicar isso com o Controle D. Então, é claro, precisamos dos sprites também. Mesmo que neste caso não vamos usar nenhum sprites nesta palestra em particular, mas eles virão. Não se preocupe. Também precisaremos de animações. Nós só vamos adicionar isso já. E então uma das coisas que vamos precisar, é claro, agora nesta palestra é que o áudio dentro da pasta Scenes. Vamos apenas criar uma nova cena, não um novo roteiro, uma nova cena, é claro, eles atrás. E este é L, um, porque uma vez que você começa a primeira palestra na seção intermediária, e isso seria fontes de áudio. E, em seguida, na pasta de scripts, podemos criar uma nova pasta, áudio L1. E aí dentro queremos um novo roteiro. E aquele que vamos chamar de áudio, exemplo de áudio. Lá vai você. E então eu acredito que uma vez que começamos as fontes de áudio aqui, acho que temos tudo o que precisamos para a configuração. Vamos criar um objeto de jogo vazio. Esta vai ser a nossa fonte de áudio. Coloquei em mil, é claro. E então vamos adicionar o componente de fonte de áudio a ele. Então, sob áudio, estranhamente, e este é o mais fundo, a fonte de áudio. E há um monte de coisas que podemos basicamente mudar aqui em termos de campos. Mas vamos primeiro adicionar os exemplos de áudio aqui também. Então o script para o objeto do jogo, e vamos também adicionar nossos arquivos de áudio. Então, este é claro, é fornecido. Você também pode brincar com seu próprio arquivo de áudio. Mas eu pensei que eu teria um que é como um som engraçado de boing. Vamos ouvir isso daqui a pouco. E, na verdade, há uma maneira muito fácil de adicionar isso. Você tem este ano de referência de clipe de áudio e você pode simplesmente arrastar isso para dentro, e então lá está ele. Agora isso, é claro, pode ser alterado assim como, por exemplo, o renderizador de sprite onde mudamos o sprite assim como aquele. Também podemos alterar este clipe de áudio via script. Neste caso, não vamos mudá-lo. O que vamos fazer é tocar estes, o som real através do guião. Então o que vamos fazer é antes de tudo, vamos passar por isso por um momento aqui. Mixer de áudio, podemos basicamente, assim como você pode ver, isso é basicamente se o som deve tocar através de um mixer de áudio primeiro ou diretamente o ouvinte de áudio. Não vamos usar um mixer de áudio neste caso. Portanto, isso não nos interessa, simplesmente silencia os efeitos de bypass sonoro. Então, se tivermos efeitos nisso. Na fonte de áudio real, vamos apenas ignorá-los se isso estiver no efeito ouvinte. No ouvinte também pode ter alguns efeitos. Temos zonas de reverberação e podemos contornar. Então isso seria ignorar todos esses. Jogar em despertar significa simplesmente assim que este objeto de jogo específico acordar com o componente de fonte de áudio nele, em seguida, ele irá reproduzir o som uma vez. E loops simplesmente significa que ele irá loop uma vez que atinge o final do clipe de áudio, ele será reiniciado desde o início. A prioridade aqui, como você pode ver, a idéia aqui é que portanto, se nós apenas foram lidos isso rapidamente define a prioridade da fonte. Então isso faz sentido para o, cada fonte de áudio tem uma prioridade particular. Neste caso, um sol com um valor de prioridade maior terá maior probabilidade de ser roubado. Provavelmente ser roubado por sons com valores de prioridade menores. Como isso, o que isso significa? Bem, se temos duas coisas jogando ao mesmo tempo, talvez algo não possa acompanhar. Por isso, às vezes temos de ter uma prioridade. Eu nunca vi isso realmente entrar em vigor. Mas eu também tenho que admitir que eu não brinquei com a OU, com isso. Um volume deve ser auto-explicativo. É simplesmente o volume do som. Também não deve ser louco. Esta é simplesmente a frequência e isso vai realmente abrandar e diminuir a velocidade do som. Vamos curar-nos o mais rápido possível. Serial pan, se a codificação de vídeo estiver correta, então você também deve ser capaz de ouvir isso. Então isso é simplesmente se ele vem ou não do alto-falante esquerdo ou direito. Uma mistura espacial é basicamente você pode ter áudio 3D. No nosso caso, há três REO nem sequer faz sentido porque estamos em um, em um jogo bidimensional de qualquer maneira, então eles vão e depois a mistura de zona de reverberação, eu realmente não tenho 100% de certeza onde isso vai. Eu basicamente sempre mantenho isso em um. Em Configurações de som 3D padrão. Há muito legal. Então, na verdade, temos um monte de coisas aqui. Mais uma vez, para nós agora não é necessário porque nós só lidar com 2D de qualquer maneira. Então 3D realmente não faz nenhum sentido para nós de qualquer maneira. Certo? Então vamos abrir o nosso exemplo de áudio e também vamos desmarcar o jogo no despertar. Porque não queremos o guisado acordado. Na verdade, só queríamos jogar quando fazemos alguma coisa. Então, a primeira coisa, porque é claro que este script em particular é mais uma vez sobre os objetos de jogo reais que são fontes de áudio em também. Vamos fazer uma fonte de áudio privada aqui. E, em seguida, vamos configurá-lo fazendo o seguinte é igual este ponto Component Audio Source, e foi isso. Então, porque é claro, o script real está no mesmo objeto de jogo que a fonte de áudio. Podemos fazê-lo com este comando. Caso contrário, talvez seja necessário obter o objeto do jogo, mas o método do componente Get com bastante facilidade. E então o que nós vamos fazer é dizer que se introduzir schottky para baixo e obter a chave para baixo, na verdade o ego tem keydown. E então nós vamos dizer espaço de ponto de código chave. Vamos ocupar espaço aqui. E então tão fácil quanto você pode pensar, Ponto de fonte de áudio, lá vai você. Foi isso. Isso, isso, isso é realmente tudo que precisamos para chamar isso o único método que precisamos chamar para tocar esse som. E vamos ouvir a glória do som engraçado do boing. Então, se eu começar isso, nada deve acontecer. E nada acontece. E se eu pressionar a barra de espaço, lá vamos nós, Funciona. Bem, isso é muito legal. Então eu posso realmente tocar um som quando eu pressionar a barra de espaço. E vamos brincar com essas coisas um pouco. Então, por exemplo, se eu puxar o tom para cima um pouco aqui, e como você pode ver agora é pedaços para cima e o campo está subindo. Se eu puxar o tom para baixo um pouco, não muito, então soa como alguém. Isso é muito bom. Certo? Então isso é muito engraçado. A caneta estéreo, então a caneta estéreo, se eu tocar isso, e agora deve ter basicamente movido todo o caminho para o alto-falante esquerdo. E se eu tocar isso de novo, agora deve ser apenas no seu alto-falante direito. Então, se você quer controlar isso basicamente, então você pode fazer isso também. Claro, todas essas coisas também podem ser controladas através do script. Então, se dermos uma olhada neste ponto fonte de áudio, por exemplo, o ano de pitch é movido um get e um conjunto. E nós temos o estéreo pan, pegue um conjunto. Podemos ter um booleano, mudo e todos os tipos de outras coisas também. Então, há um monte de outras coisas que podemos fazer também. Incluindo, por exemplo, o volume também pode ser definido de 0 para um e algumas das outras coisas, mas o método de jogo é um dos mais importantes. Há também um jogo agendado, então você pode basicamente ter isso em um determinado horário. Podemos ter uma jogada uma chance. Então isso reproduz o áudio e, em seguida, aumenta a escala. Isso realmente também é, você também pode dar-lhe um clipe de áudio na verdade. E, em seguida, jogar atrasado simplesmente faz com que seja atrasado. São coisas muito específicas. Normalmente, a reprodução de ponto da fonte de áudio é a que você realmente precisa, certo? E isso já seria para a idéia da fonte de áudio. E você pode simplesmente adicioná-lo. E o que é muito importante é que componente da câmera geralmente tem o ouvinte de áudio. Esse é um dos componentes que você precisa em sua cena. Se você não tem isso, então você não será capaz de basicamente aqui desta fonte de áudio e, em seguida, nenhum som vai realmente chegar. Então isso é muito importante notar que, como na verdade em sua câmera principal, bem, ele deve vir com a câmera principal. Então, cada vez que você tem uma câmera principal em sua cena, isso deve estar imediatamente lá. Mas se por alguma razão estranha não é, então, agora você sabe que isso é realmente também algo que você precisa robô que seria para esta palestra. Espero que tenha achado útil e aprenda algo novo. Como sempre. Se houver alguma dúvida, sinta-se à vontade para perguntar e eu responderei. E sim. 82. (Unity Intermediário: Tudo bem, vamos continuar com a seção de unidade intermediária aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada rápida no sistema de partículas. Agora, o sistema de partículas é provavelmente um dos sistemas mais extensos da Unidade. Pode, quer dizer, você pode quase fazer qualquer coisa. Bem, nada literalmente, mas digamos em termos de partículas, pelo menos. Então vamos adicionar uma nova cena aqui, sistema de partículas L2. Vamos abrir isso imediatamente também. E então vamos realmente não precisar de uma outra pasta de script porque nesta, nós realmente não vamos usar os scripts, scripts em que um em tudo, certo? E este está sob efeitos. Então, se clicarmos com o botão direito e depois irmos para Efeitos, temos um sistema de partículas. Então vamos adicionar este sistema de partículas e como você pode ver, ele imediatamente se dispara e dispara partículas como loucas. E a primeira coisa que vamos fazer é basicamente pegar isso e arrastar isso para que possamos ver um pouco mais do inspetor aqui. E eu não fiz, eu não kit quando eu disse isso, que era um monte de coisas e há ainda mais para que nós podemos realmente basicamente cada uma dessas ou até mais coisas. E uma das coisas que eu quero mencionar é que nós definitivamente não vamos passar por tudo aqui porque três horas depois, nós basicamente terminamos com tudo. Logo no começo, quero dizer que a melhor coisa que você pode fazer é apenas brincar com isso tanto quanto você basicamente precisa e quanto quiser. Porque essa é a melhor maneira de aprender o sistema de partículas. Algumas dessas coisas devem realmente fazer sentido inerente. Então, algo assim. Começar com o quê? Iniciar cor. As partículas começam? Que tipo de gravidade modificada ou eles têm. Então agora eles estão caindo, como você pode ver, há uma espécie de subindo e então eles estão caindo novamente. Podemos mudar a velocidade, certo? Então agora ele se move mais rápido. Ou podemos dizer, na verdade, vamos torná-lo mais lento, então é negativo dois. Vamos, na verdade, também fazer essa. E não um 0, isso seria, sim, e eles são muito, muito lentos. Então essa é uma daquelas coisas em que deve realmente fazer sentido. Bastante fácil. Então, rotação invertida, eu não acredito que realmente faça alguma coisa. E neste momento, não. Porque o que também é importante ser dito é que o, este faz algo para que isso realmente gira as partículas reais. O sistema do produto geralmente é usado em espaço tridimensional. Então, se eu mudar para o espaço tridimensional, como vocês podem ver agora, eles vão para lá. Mas não há razão pela qual você não poderia usá-lo em um projeto bidimensional assim, há realmente nenhuma razão para não fazer isso. Certo? Então vamos pensar sobre isso. Há algumas coisas aqui. Então a duração, quero dizer, você também pode passar o mouse sobre eles e obter uma boa estimativa do que todas essas coisas são. Quero mostrar algumas dessas coisas que você está aqui. Então esses são o tipo de funções que você pode aplicá-lo. Então, por exemplo, o que eu realmente gosto de algo como cor ao longo da vida. Então, se eu colocar esse, então eu posso realmente, como você pode ver, tipo de um modo de cor para que eles possam começar, por exemplo, como branco. E então quando eles estão em um local de 100, então eu posso dizer, bem, então eu quero que eles tipo de ganância. E o que acontece? Então, quanto mais longe essas partículas se afastam da minha fonte, elas ficam mais verdes. Na verdade, isso é muito legal. E isso é basicamente, você pode fazer isso com quase todas essas coisas. Você pode fazer isso com o tamanho, com a velocidade. Mesmo, você pode até mesmo mudar a cor pela velocidade da partícula real. Como se houvesse um milhão de coisas que você pudesse fazer aqui. Você pode adicionar barulho como você pode ver, isso é, quero dizer, isso é loucura. Você pode até adicionar dados personalizados. Nós não vamos definitivamente não olhar para os dados dos clientes porque isso é loucura. Mas digamos, por exemplo, velocidade ao longo de uma vida. Assim, podemos, por exemplo, dar um pouco mais de velocidade, por exemplo, na direção z ou na direção x. Então podemos realmente mudar a trajetória disso. O que é mais importante ou interessante é na verdade a forma e não a emissão, mas a forma. A forma é basicamente que tipo de controles onde as partículas estão sendo geradas. Então esta é a forma do cone e então podemos, por exemplo, estender o ângulo. E então, como você pode ver agora, é um ângulo de onda mais plano, então as partículas estão se movendo em um ângulo bem mais plano aqui. Também podemos ajustar o raio aqui em baixo e também a espessura. A espessura na verdade não deve importar muito. Porque mais uma vez, isso está em 3D. Então, se eu for para 3D, como vocês podem ver agora, isso parece um pouco diferente, como vocês podem ver do que em duas dimensões. É por isso que eu disse que o produto é incrível, geralmente usado em três dimensões, mas não há problema. Você também pode fazer isso assim. E quando se trata de formas, aqui, você pode ver que há muitas formas que podemos usar. Então, a esfera é, bem, simplesmente uma esfera, então ela começará do início e depois se moverá. Também podemos estender o raio até onde eles estão desovando. Também tem um arco diferente. Creio que o arco aqui é, mais uma vez, um pouco de um problema devido à natureza bidimensional disto. Vamos olhar para outro, o cone, por exemplo, eu, na verdade, o cone foi o que nós olhamos para o hemisfério. Mas isso é meio círculo. Navio aberto, raio maior. Lá vai você. Algo assim. Então, como você pode ver, quase não há fim para isso. Agora podemos ter uma espécie de feixe e poderíamos, por exemplo, ter um, outra taxa escalável IFA, escalá-lo. E, por exemplo, isso poderia ser, você poderia ter isso e então dizer, por exemplo, ter a idéia de que poderíamos ter um onde é o tamanho maior, digamos a vida inteira. Na verdade, vamos fazer o máximo de partículas. Além disso, muito importante a propósito. Mas eu quero a vida toda, certo? Então é aqui que eles morrem. Então você pode basicamente dizer, bem, na verdade, vamos fazê-lo. Deixe-os morrer a 1,5 ou algo assim. E então, de repente, bam, você tem um tipo de efeito de teletransporte legal para como um 2D teleportado. Quero dizer, isso é tão fácil quanto é para o sistema de partículas como exemplo aqui. Isso foi apenas uma espécie de idéia que veio à mente para a caixa, por exemplo. E então você também pode ter seus próprios sprites personalizados lá como o tipo de área de geração, você pode ter um círculo. Agora o círculo é basicamente um problema porque é mais uma vez a maneira que é girado neste caso. Mas sim, isso é uma espécie de aparência geral para o sistema de partículas. Tenho que ser honesto, há tanta coisa que você pode fazer com isso. Mas sugiro vivamente que experimente um monte de coisas aqui porque eu, não te leva a lugar nenhum se você assistir a uma palestra de três horas sobre, ok, o que cada uma dessas coisas faz? Quero dizer, a maioria deles são muito bem descritos cor por velocidade, ok, então a partícula muda sua cor pela velocidade que tem. Isso é tudo o que há. E sim, mais uma vez, o que é loucura também? Todas essas coisas também podem ser alteradas via script. Então você pode basicamente também mudar todos os tipos de coisas via script. Então talvez você tenha um teleprompter que se pareça com isso quando está vermelho, então você pode se teletransportar e então você deixa verde quando você não pode teleportar algo assim, apenas como uma idéia. Então há tantas coisas que você pode fazer com ele. Sim, quero deixar-te com isto. Brincar com ele tanto quanto você precisa. O sistema de partículas é incrivelmente extenso e pode fazer muitas coisas. Mas como eu disse, a melhor coisa brincando com ele um pouco. Eu só queria te mostrar algumas coisas aqui. E então a essência geral disso, certo? Então seria isso para esta palestra. Espero que aprenda algo novo. Se alguma pergunta permanecer, é claro, sinta-se livre para perguntar e eu serei mais curto. Desovou. Mão. Sim. 83. (Unity intermediário: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E, em seguida, esta palestra vamos dar uma olhada rápida nas configurações do projeto. Então há algo em que nem precisamos de uma nova cena quatro. Nós vamos apenas para editar aqui e, em seguida, para Configurações do projeto. E então nós vamos ser atingidos com um monte de coisas que nós estamos apenas indo tipo de glândulas sobre um pouco. Algumas dessas coisas e as configurações do projeto as vimos uma vez antes na introdução nítida C para a geração C, C-sharp Project para o namespace. Então aqui nós fomos capazes de basicamente colocar em um namespace. E agora estamos basicamente inundados com todos os tipos de configurações que podemos colocar. Temos configurações de áudio, gerenciadores de pacotes, física personalizada. Na verdade, é um pouco. E geralmente o que eu sugeriria é que só olhasse certas coisas se você realmente precisar delas. Então vamos olhar para algumas coisas que eu acho que são úteis e sensatas de ter visto antes, mas geralmente nenhuma delas é realmente necessária. Então eu sou, uma dessas coisas é, por exemplo, os gráficos. Você pode ter diferentes níveis de gráficos. E os padrões, eu diria que o nosso melhor é mantido assim. Você sabe, há algumas configurações de sombreamento basicamente lá dentro. Eu não mexeria com eles, especialmente estamos em um ambiente 2D. Eu definitivamente diria que os gráficos devem ficar como eles são. Você pode realmente ter um gerenciador de entrada. Nós realmente não conversamos sobre isso antes. Gerente de Pacotes, vamos pular a física, não nos interessa. Estamos interessados em física para D, e esse é o primeiro que é muito interessante aqui. Então, em primeiro lugar, poderíamos, por exemplo, ter uma gravidade personalizada. Claro, a gravidade em nosso mundo é de 9,81 metros por segundo ao quadrado. E isso é o mesmo que está aqui. Mas se você, por exemplo, quer ter uma gravidade que é aplicada de forma diferente, então você pode alterá-la aqui, um projeto amplo basicamente. E há também tantas outras coisas que você também pode mudar no ano também. A idéia é que existe, a física é basicamente completamente personalizável. Então isso é muito legal. Na verdade. As configurações do jogador é outra daquelas coisas que são muito interessantes. Então, aqui você pode fornecer um nome de empresa e também um nome de produto, bem como uma versão. Você também pode substituir o ícone do seu EXE basicamente. E você também pode substituir o cursor. Em seguida, há também algumas configurações, por exemplo, para o PC aqui. Isso também seria aqui o ícone na versão do PC para o seu EXE. Então você tem algumas opções básicas de resolução e apresentação. Então você pode dizer qual é o modo básico de tela cheia? Pessoalmente, acho que uma janela de tela cheia é basicamente a melhor. Você pode ter uma resolução nativa padrão executado em segundo plano também é possível. Então isso seria, como você pode ver, a idéia de se você clicar fora da janela, se o jogo continua ou não em segundo plano. E, em seguida, mais algumas coisas que também funcionam janela redimensionável seria algo que pode ser interessante. E sim, então isso funcionaria. Em seguida, há também opções de imagem de abertura. Então este é basicamente o início do jogo. Podemos fazer uma prévia para isso. Então, no início do jogo, você vai ter, você vai ver isso feito com Unity. Você também pode adicionar suas telas de abertura personalizadas lá também. Então, se eu fizer isso, eles vão, você pode basicamente adicionar logotipos e então você pode dizer, Ei, onde está isso, você sabe, você quer isso antes do logotipo da unidade depois, e assim por diante e assim por diante. Você pode fazer sua própria imagem de fundo, tudo isso. Então, basicamente, isso é algo que você teria se você realmente tem um tipo de, um, um verdadeiro talvez até mesmo Studio. E então você tem seu logotipo e você mostra e então você faz, tem um logotipo da unidade e, em seguida, qualquer outro logotipo que você pode precisar, talvez para um editor ou algo assim, seria então basicamente aqui. Mas, mais uma vez, muitas dessas configurações de projetos são realmente para pessoas que são muito, muito mais avançadas até mesmo em seu jogo. Sim, e há algumas outras configurações também. Normalmente, a maioria deles pode ser deixada como estão. E isso é definitivamente o que eu recomendaria. Como você pode ver mais uma vez, que há tantas coisas que você pode basicamente ter aqui que na verdade é loucura. A próxima coisa muito interessante. Então tanto o gerenciador de predefinição, bem como a qualidade, basicamente nós não vamos nos importar com, bem como os modelos de cena. Esses podem ser interessantes para criar tipos de modelos para cenas. Mas, atualmente, isso não é realmente necessário para o nosso caso de uso aqui. O que é interessante, no entanto, é o serviço de execução de script. E essa é uma das coisas que eu meio que aludi em uma palestra anterior onde tínhamos duas coisas um GameObject estava sendo definido por um script e o script estava lendo esse objeto do jogo. E a questão era que, bem, talvez um dos outros, um deles vai ser executado primeiro e o outro é o segundo. Então aqui podemos basicamente adicionar scripts. Por exemplo, basta adicionar o script de exemplo de áudio. E então podemos dizer, bem, quando isso vai ser basicamente executado? Então, este é um adicionar scripts para a ordem do cliente e arrastá-los para reordenar scripts e o cliente pode executá-lo antes ou depois do tempo padrão. Então este é o tempo padrão e executado de cima para baixo. Então, basicamente, primeiro desses e, em seguida, em algum momento, vamos chegar à amostra de áudio. Então isso é algo onde você não necessariamente tem que ter o despertar e a função start ou um método. Em vez disso, use aqueles para tipo de saber qual deles é executado primeiro porque talvez tenhamos duas coisas que são executadas no método awake em dois scripts diferentes. E nós somos como, Ok, este script tem que ser executado antes deste script. E esta é uma maneira de garantirmos isso. Então é por isso que a ordem de execução do script pode ser muito, muito importante. Os serviços, vamos realmente aplicar isso. Os serviços são, mais uma vez, algo que eu pessoalmente diria. Nós vamos pular mais uma vez porque isso é algo que é muito mais avançado para você realmente tem um projeto real acontecendo que você pode querer ter. O que você quer colaborar? E ter compras no aplicativo, compilações na nuvem e tudo isso. Não é muito interessante. Tags e camadas é algo que vamos olhar em um mais tarde abaixo da linha. Isso é em uma palestra futura, especialmente as tags ou o que vamos olhar. Um Pro baseado em texto muito interessante que é simplesmente a tela que tivemos quando importamos um texto smash bro última vez, o temporizador também ser algo que é importante ou interessante. Basicamente temos alguns passos de tempos fixos, bem como a escala de tempo. Isto é basicamente o que obtemos se chamarmos uma escala Time.DeltaMe. E nós podemos, a propósito, também mudar isso no script VA e, em seguida, o tempo basicamente pára. Portanto, isso é algo que também podemos fazer. E todas as outras coisas não são interessantes para nós. A única coisa que pode ser interessante é o papel divergente com os arquivos de metal visíveis, que podemos querer basicamente habilitar para o nosso eu não sei por que começou. De repente, isso é meio estranho sobre nós poderíamos querer ter os mesófilos visíveis aqui. Porque talvez o que queremos é ter isso no GitHub e então os mesófilos visíveis fazem sentido, certo? E isso seria basicamente para a rápida olhada nas configurações do projeto. Como eu disse, eu só queria dar-lhe um olhar superficial de alguns deles, especialmente a ordem de execução pode ser muito, muito interessante e importante. E física 2D que você pode basicamente personalizar aqueles também é muito legal. Eu definitivamente aconselhá-lo se há certas coisas, então você também pode olhar para cima sempre olhar para cima certas coisas que você quer. Normalmente, não sei. Então, por exemplo, pode ter sido que, Hey, eu realmente quero ter o tempo para dormir ser maior ou eu queria definir a escala de tempo para algo mais de um, e isso é exatamente o que você deve fazer. Então, caso a caso, eu aconselharia você a procurar as configurações do projeto na unidade na documentação do Unity. Essa é a melhor ideia que posso dar para isso porque caso contrário, mais uma vez, assim como com o sistema de partículas, estará aqui depois de três horas. E então passaríamos por todas as configurações do projeto. E então as duas primeiras horas teriam sido esquecidas depois da última hora. Então é por isso que eu só queria mencionar que eles existem podem ser úteis em algum momento abaixo da linha. Mas agora, eu aconselho você a aceitar isso. Ok. E então vamos seguir em frente para a próxima vez, certo? Então este seria o fim para esta palestra. Mais uma vez, se alguma pergunta permanecer, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 84. (Unity intermediário: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada nas etiquetas. E para fazer isso, em primeiro lugar, vamos adicionar alguns sprites agradáveis a este projeto aqui. Temos nossos bons cartões antigos que já usamos anteriormente. Este é mais uma vez os múltiplos cartões. Então nós vamos basicamente colocar em algumas configurações aqui. Ponto de modo de filtro, vamos colocar os pixels por unidade para 16, bem como colocar o modo sprite para múltiplo. Então nós vamos aplicar isso indo para o Sprite Editor. Coloque o corte para automático, tudo bem. E depois fatia. E então nós temos cartões individuais aqui com uma largura de 42 e uma altura de 60. Carregue em Aplicar aqui. E então estamos realmente bem. E então dentro daqui temos essas cartas, núcleo 0, 1, até 55. E nós vamos apenas pegar a Corte 0 e colocá-lo em nosso pequeno mundo ouve em nossa cena. E eu acho que 02 é uma ótima posição para isso. Na verdade, nada disso é um sistema de partículas. Vamos, em primeiro lugar, criar uma nova cena, é claro, para manter tudo agradável e arrumado. E isso seria L4, que está adicionando tags. E isso também é abrir isso. E então dentro daqui podemos colocar o cartão e eles vão para 0,5, certo? Isso é ótimo. É uma boa posição que eles são. E então queremos um GameObject vazio agradável aqui. Claro que, em 000, 000 ou Mônaco, esta marca. E, em seguida, dentro da nossa pasta de scripts, uma nova pasta. Não, isso não funcionou. Lá vai você. Scripts. Scripts, criar pasta, etiquetas L4. E então vamos criar um novo script C Sharp. Vamos chamar isso de etiquetas também. E isso será adicionado ao nosso objeto de jogo vazio aqui. E então vamos dar uma olhada no que isso realmente pode fazer por nós. Tudo bem? Então, em primeiro lugar, uma etiqueta, quais são as nossas etiquetas? Bem, a idéia é que você pode adicionar certos elementos para objetos de jogo, e isso é exatamente aqui em cima. Então, como você pode ver, marcado e atualmente isso não está marcado, isso é desembaraçar. A câmera principal realmente tem detectar câmera principal. E o que podemos fazer é se entrarmos nisso, podemos realmente ver que existem algumas tags predefinidas para nós. Responder terminar editor apenas jogador da câmera principal e o controlador do jogo. E então há também a tag edge, basicamente funcionalidade que podemos clicar. E, em seguida, no Inspetor nós obtemos este tags e camadas vai sentir que podemos ver. E em vez de aqui, como você pode ver, lista de impostos está vazia. Então a lista de nossas tags predefinidas que definimos está vazia e podemos acertar este pouco mais e então temos que especificar um nome. Então, por exemplo, podemos dizer, bem, o tribunal, o novo nome da etiqueta é cartão e, em seguida, salvar isso. Então isso agora está marcado como 0. E então podemos, por exemplo, adicionar inimigos também. E então talvez algo assim. Nem sequer sabem saúde ou, ou, ou, ou, ou, ou, ou, ou, ou danos, algo assim. Então, o que é que isso faz? Então, o que isso faz agora? Então vamos para o vetor, o cartão. Primeiro de tudo, muito importante se você adicionar ataque através desta soma, temos este menu drop-down. Ele não adiciona automaticamente a tag ao objeto do jogo. Você terá que abrir a lista suspensa e, em seguida, basicamente, selecionar isso. Então vamos dizer cordão porque este cartão tem separado, porque este é um cartão. E então podemos pensar que esta é basicamente uma das outras maneiras que podemos tipo de ver, ok, este GameObject um certo tipo de objeto basicamente, antes, quando pensamos de volta para onde tínhamos o colisor de caixa, onde usamos os colisores. Ali. Conseguimos comparar o nome do objeto. Mas sabe, às vezes o nome muda e talvez inimigos diferentes tenham nomes diferentes. E você quer ter algum tipo de outra marca de identificação. E isso pode, por exemplo, ser uma etiqueta inimiga. E como usamos essa etiqueta? Bem, esta etiqueta é, na verdade, apenas uma corda. É muito fácil de usar. Então vamos apenas fazer um log de pontos de depuração aqui. E então vamos dizer GameObject dot find. E nós vamos encontrar acordes 0 porque esse é, naturalmente, o nome deste objeto de jogo neste caso. E então vamos dizer, por exemplo, tag, como você pode ver aqui, é apenas uma string. E então vamos copiar isso com Controle C. E então há outra função ou método realmente legal aqui chamado tag compare. E então dentro daqui podemos, por exemplo, dizer cartão. E depois há outro, digamos inimigo. Certo? Então, a ideia de estar aqui. O primeiro, vamos apenas produzir a tag, como você pode ver, tag deste objeto de jogo. E então a tag de comparação é este jogo objetos encarregado com qualquer tag que damos como um perímetro? Isso é claro que vai ser verdade porque cord é exatamente a tag que nós definimos. Um inimigo deve ser uma comparação falsa. Neste caso, é melhor usar este método do método CompareTo em vez de fazer a nossa própria comparação de strings, eu acredito que há algum pouco de debate sobre isso. Mas geralmente o método CompareTo parece mais agradável de qualquer maneira, em vez de fazer tag dot é igual a e, em seguida, colocar, está tudo bem. Comparar tag é realmente um bom método. Tudo bem, então, em teoria, isso deve funcionar como imediatamente, vamos ver, cartão, ok, primeiro de tudo, que, essa é a tag que temos predefinido aqui. E então, é claro, é verdade que a etiqueta e o carrinho e a TC são exatamente a mesma etiqueta. E então inimigo não é realmente a tag que este tribunal tem, este objeto de jogo, certo? E isso na verdade é tudo o que há para as etiquetas. Eles não são loucos, complicados, mas eles podem ser realmente úteis se você tem certas coisas predefinidas que devem funcionar de uma maneira particular. E eles são realmente úteis, especialmente quando você usa os planadores. Basicamente, podemos comparar etiquetas. Eles são em vez de comparar o nome como nós fizemos. E eles são uma coisa normal que faz parte de um GameObject como você pode ver. Então esta é uma propriedade normal do objeto do jogo e você pode acessá-lo e até mesmo configurá-lo dentro do script se você gostaria de escrever, e que seria isso para esta palestra mais uma vez, espero que você tenha achado útil e você aprendeu Algo novo. Se alguma pergunta permanecer, então, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 85. (Unity intermediário Intermediário 2D Raycasting no Unity no Unity: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada rápida em um casting de raios. Então, reformulando, talvez já tenha ouvido falar disso antes. É basicamente uma maneira de olhar para se você fosse ou não atirar um projétil em uma determinada direção, se ou não atingiu algo que tem uma das coisas onde ele é usado. Na maioria das vezes eu diria que um de seus casos de uso pode ser basicamente fazer a detecção de acertos. Então, ao invés de gerar uma bala e ter realmente o sistema de física tipo de calcular sua trajetória e ter um novo objeto de jogo e uma espécie de algo assim. Na verdade, apenas desenhamos um custo de raio, que é uma espécie de linha invisível. Somos um vetor invisível que detecta quando atinge um determinado colisor básico. E vamos dar uma olhada nisso. Então parece nova cena. Isto vai ser a L5 reformulação. Agora. Oh, isso é realmente assim. Lá vai você. E o, vamos olhar para a reformulação em duas dimensões. Agora, em três dimensões, a única coisa que realmente muda é o número do que o vetor que você tem que colocar. Então, em vez de um vetor ter que colocar em um vetor de três. Mas, além disso, tudo permanece igual. E, em seguida, uma nova pasta dentro de nossa pasta de scripts L5 reformulando, bem como um novo script lá dentro. E isso, para surpresa de ninguém, também é chamado de casting de raios. Ótima. Então agora vamos realmente adicionar duas cartas aqui. Então vamos adicionar uma espécie de ás de copas. E então eu vou apenas escolher aleatoriamente fora disso. Então agora temos duas cartas aqui. E o que nós vamos fazer é nós estamos indo para semi-centralizado, então negativo seis e então colocar o y em 0. E eu vou colocar este em um negativo. E o X86, isso é ótimo. E um desses vai ser bem detectado daqui a pouco. E um dos “um”. Então, o ás de copas vai realmente atirar para fora um re-elenco de si mesmo. E então ele vai detectar basicamente este acorde aqui. E a maneira como podemos fazer isso é antes de tudo, vamos adicionar um colisor de caixa para descartar. Então, para o cinco de paus, eu acho que isso seria mais uma vez em Física 2D e, em seguida, apenas caixa de colisão para que uma caixa agradável desordem é desenhada em torno dele. E, em seguida, para o 0 ou o ás de copas neste caso, podemos simplesmente adicionar o nosso script para que eles re script de casting correto vai ser adicionado aqui que você vai. E o outro tem um boxplot. Vamos abrir o roteiro de casting de raios e ver o que podemos realmente fazer aqui. E isso vai ser uma coisa bem fácil de fazer. Então, primeiro de tudo, vamos excluir o método start porque só precisamos do método de atualização. E dentro daqui, input.txt recebe uma chave. Vamos levar o porteiro, neste caso, não a chave para baixo. E vamos ocupar espaço neste caso. Porque o que eu quero fazer é basicamente eu quero sempre fazer um novo. Na verdade, vamos fazer a chave para baixo por agora primeiro e depois podemos mudá-la mais tarde. Se quisermos. Um novo método, vazio privado, gerar, re-elenco. Isto é apenas para que possamos lê-lo um pouco melhor. Então isso é por causa da legibilidade, bem como apenas porque é um pouco mais agradável em vez de colocar isso dentro do tipo de declaração if lá. E o que queremos é um reelenco hit 2D. Isto é o que queremos. Isso é igual a um raio. Então isso é chamado raid a variável, e isso é igual a física 2D. Então esta física para D é uma reformulação de ponto de classe. E isso leva, como você pode ver, uma origem e uma direção. E também podemos fornecer mais algumas coisas. Então esta vai ser esta transformação de ponto, essa posição. E então ele tem uma direção. No nosso caso, o que queremos que este vetor ponto-ponto, certo? Então também podemos especificar uma distância, como você pode ver, vamos fazer 15 F por enquanto. E depois vamos ficar bem. Se você não especificar uma direção, então o raio será infinitamente longo. E basicamente no mesmo traço ou vamos fazer é que vamos desenhar, então depurar ponto draw ray. Então nós podemos realmente desenhar um raio custos aqui, como você pode vê-lo também. Neste caso, ele realmente leva um vetor tridimensional. Então, vetor três, bem como uma direção. No entanto, isso não é um problema porque nós simplesmente ainda podemos passá-lo. Esta transformação de ponto, vetor de posição de ponto, o vetor de dois pontos, certo? Vezes 15, porque esse é basicamente o comprimento que especificamos aqui, certo? Esta direção e este é o comprimento. E se nós apenas multiplicarmos esses, e isso funciona muito bem também. E então temos que fornecer uma cor. Vamos fazer azul aqui. Vamos fazer azul. E depois há uma duração. Então isto é por quanto tempo este raio realmente será desenhado. Vou demorar cinco segundos. Então isso é muito parecido com uma linha de desenho, apenas que é especificamente para um raio neste caso. E, em seguida, o que podemos fazer, bem como depurar ponto log re ponto colider. Então este é o GameObject, vamos ver, colisor. Este é realmente o colider 2D que está anexado ao objeto de jogo que este array atingiu. E eu só vou dizer o nome por enquanto, vamos apenas mostrar o nome para o que o reelenco real atingiu. Então, se você pensar sobre isso, o que deve acontecer é que a partir da posição negativa 600, um re-elenco 15 passos de riqueza do mundo junto com 15 unidades mundiais ao longo da geração. E assim que chegar aos tribunais, 32, basicamente deve produzir isso também. Então vamos ver se isso realmente funciona. Então agora estamos no jogo e eu bati na barra de espaço e você pode ver núcleos 32 realmente recebe saída. E nós também podemos ver essa linha azul muito fina. É muito, muito, não é realmente muito bom de se ver. Vamos voltar e fazer isso vermelho. Talvez, talvez o vermelho seja um pouco melhor de se ver. Esse pode ser o caso. Então vamos ver se isso funciona. Sim, vermelho é um pouco melhor. Então C, eu só vou pausar. Em vez de nossa cena aqui, podemos ver isso um pouco melhor. Como você pode ver a partir do centro do cartão de fora, vamos para a direita, exatamente 15 unidades basicamente. E nós atingimos este acorde e este raio, em seguida, basicamente, detecta , oh, eu acertei um cartão e, em seguida, emite o nome real dele. Agora, podemos fazer isso várias vezes, certo? Então podemos gerar matriz. Agora, o raio na verdade teria desaparecido neste ponto porque nós já atingimos algo que fizemos, estamos feitos. Então o visual é um pouco, bem, eu não diria que não diria que é enganador, mas o visual permanece um pouco mais, só para que tenhamos um show que podemos realmente ver o que está acontecendo. Se pegarmos este cartão e o movermos para baixo. O que vocês verão é que, de repente, teremos uma referência nula porque não atingimos nada dentro deste raio. Então isso é também algo que você deve definitivamente considerar que talvez re ponto collider é realmente vai ser nulo. Portanto, apenas esteja ciente disso. E se colocarmos de volta e batermos novamente, então, como você pode ver, as cartas 32 são emitidas várias vezes. Então, com isso podemos basicamente dizer, ok, onde é isso? Nós também podemos dar uma olhada em onde isso foi atingido e todos os tipos de outras coisas divertidas. Então o raio realmente tem algumas coisas lá. Vamos ver o que o raio também tem a oferecer. Para conseguirmos o colisor. Nós também podemos obter a distância que é pode ser realmente útil. E esta é a fração C da distância ao longo do raio que ocorreu a batida. Basicamente significa que se o raio tem 10 unidades de comprimento e foi atingido exatamente na metade do comprimento da matriz, então isso obteria 0,5 porque isso é 50% do comprimento da matriz. Há um vetor normal que você pode obter que pode ser útil se você quiser fazer coisas extravagantes com vetores que eles são. Você também pode obter imediatamente o corpo rígido que está anexado ao objeto do jogo. No nosso caso, nós realmente não temos um corpo rígido preso, ligado a ele. Você também pode obter o ponto, o ponto exato no espaço do mundo onde o raio atinge o alvo. Então isso seria, bem, no nosso caso, estaria em algum lugar aqui. Esta é uma das maneiras em que você poderia, por exemplo, dizer, Bem, talvez se ele bater no topo aqui, então você quer que talvez a metade superior deste núcleo desapareça. E se acertar no fundo de você, então você quer que a metade inferior desapareça em algum lugar assim. Então você pode tipo de fazer você sem danos em partes específicas deste cartão. Mas sim, esse é o aquecedor básico de reformulação. É realmente útil porque com, claro, o colisor mais uma vez, você pode muito facilmente obter o ponto GameObject GameObject como você pode ver. E então você tem o GameObject e que, claro, abre basicamente tudo o que o, que o objeto do jogo tem direitos que você pode obter, fazer obter componente novamente, obter qualquer componente que ele tem, e fazer todo tipo de coisas loucas com ele. Então você pode bater nele e então mudar sua posição ou você pode mudar seu tamanho, algo assim. Então, basicamente, as possibilidades são realmente infinitas neste. E o reelenco é simplesmente uma maneira de você, que você poderia fazer isso basicamente. E é uma maneira justa, eu diria barata. Todas as coisas consideradas para fazer isso. Então, se você tem um se você tem cena 2D básica onde você iria filmar algo, então talvez colocar em re-elenco é um pouco melhor. Bem, sim, existem inúmeras opções do que você pode usar custos re com. São apenas alguns que mencionei. Um dos que eu usei, por exemplo, estava dentro do meu, Eu tinha um jogo 2D. Vamos parecidos com Zelda, digamos. E eu estava filmando um re-cast fora do meu personagem toda vez que eu pressionava a barra de espaço para basicamente falar com NPCs. Npcs todos tinham um colisor de caixa e eles também tinham uma interface chamada rastreável. E se o reelenco detectou que eles tinham uma interface tolerável aos olhos basicamente ligada a eles. Depois consegui falar com eles. Essa foi basicamente a maneira que eu uso re-cast em um exemplo. Mas é claro, há tantas maneiras que você pode usar o re-elenco que sim, eu só queria mostrar como você pode usá-lo e quanto mais você usá-lo para, bem, isso realmente depende de você. E será isso para esta palestra sobre fundição de raios. Espero que tenha achado isso útil. Como sempre. Se houver alguma dúvida , por favor, sinta-se à vontade para perguntar e eu responderei. E sim. 86. (Unity intermediário: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em como salvar dados com prefs de jogadores. E sim, basicamente como você pode salvar dados específicos no disco rígido. E então, quando você basicamente recarrega um cofre, por exemplo, como isso funciona? E podemos fazer isso com algo que se chama prefs do jogador. Essa é uma classe que a unidade fornece para nós, na qual podemos basicamente proteger inteiros, strings, e tipo de tipos de dados normais e primitivos. Agora, para fazer isso, vamos realmente construir um grande visto nesta palestra aqui. Então este é L6 jogador prefs. E a razão pela qual eu quero construir uma cena um pouco maior aqui é porque o número 1, é uma boa prática. Então isso é muito bom. E, em seguida, número dois, isso também será usado próxima palestra quando estamos salvando e carregando com arquivos JSON. Mas chegaremos a isso quando chegar a hora, certo? Se você não está interessado em basicamente o fluff em torno dele e fazer a interface aqui, então você pode, é claro, também pular esta palestra porque a próxima palestra é basicamente apenas a parede, como você faz os prefs do jogador por conta própria. E você pode simplesmente baixar o pacote real que é fornecido. Ali. Tudo já está configurado a cena e os prefs do jogador e todos os scripts basicamente estão configurados. A única coisa que não está configurada é o salvamento e carregamento dos dados, que você pode, basicamente, acompanhar. Eu só queria mencionar isso porque o jogador real prefs é apenas cerca de cinco minutos da palestra real. O resto é uma espécie de coisa em torno dele. Eu só queria mencionar isso. Você não precisa necessariamente configurá-lo. Você também pode simplesmente baixá-lo. Então, sim, então L6, prefs de jogadores. E para criar nossos scripts, nós realmente temos quatro scripts, neste caso, o de, o primeiro é chamado de população. E então provavelmente, sim, lá vai você. E, em seguida, o segundo é um jogador de dados. Então este é apenas um exemplo para alguns dados de jogadores que vamos usar. Então temos esses prefs de jogador seguro que vai ser o arquivo real ou o script que vai salvar os dados. E, em seguida, também temos um Gerenciador de UI que vai gerenciar a interface do usuário que será exibido. Então vamos abrir um após o outro. Dados principais do jogador da população, seguro, prefs do jogador e, por último, mas não menos importante, o Gerenciador de IU. A primeira coisa que vamos dar uma olhada é a população do tribunal, que vai ser muito, muito fácil. Isso vai ser o mais fácil de todos eles. Porque este terá uma lista privada de Sprite. Não, não desenho de primavera, mas Sprite. Eles vão como vai ser frio, todos chamados de sprites. E então vamos fazer este campo serializado. É isso, Isso é tudo que a população de carros tem. É simplesmente um comportamento mono que irá conter todas as nossas cartas. E podemos imediatamente adicionar isso como um objeto de jogo vazio aqui. Então este seria o nosso cartão. População. E então vamos adicionar isso ao objeto real e, em seguida, nossos núcleos que você já importou. Mais uma vez, vamos, em primeiro lugar, trancar isto aqui. Então, selecionando a população de cartão GameObject, bloqueando o inspetor. E vamos selecionar Acordes 0 e, em seguida, manter a tecla Shift pressionada para que, se cada cartão selecionado, e então vamos simplesmente arrastá-los para todos os sprites de cabo. E agora temos todas as noivas da corte aqui, dentro do roteiro da população de cartas. E isso será usado mais tarde para referenciar basicamente um sprites de cartão diferente. E sim, então vamos continuar e vamos primeiro construir uma interface muito agradável. Então, para isso, vamos adicionar um painel de hoje à noite aqui e depois a tela, primeiro lugar, é claro, desbloqueando isso novamente. E, em seguida, a tela será colocada para câmera espaço de tela. Adicionando a câmera principal aqui. Isto não deve ser nada muito louco. E então o painel será uma espécie de na metade inferior do, a metade inferior ou o terço inferior. Vamos fazer metade inferior, isso é bom para o campo visual. E também teremos um cartão. Então vamos apenas colocar em um tribunal ouve ocorreu 0. Isso vai ser em 0,52. Acho que está tudo bem. E isto vai ser chamado de cabo do jogador. Então este é o carro. Basicamente, o jogador pode escolher qual cartão está sendo exibido aqui e nós vamos salvar isso. E quando carregarmos os dados de volta, então o cartão vai realmente mudar. Então essa é uma das coisas que vamos fazer. Também temos que construir mais algumas coisas na tela aqui. Então isso vai ser um pouco mais extenso neste caso. Uma das coisas que vamos ter é um menu suspenso e vamos usar o texto Mesh pro neste caso. Então vamos fazer o essencial de importação TMP aqui. Agora que temos o teste Mesh de texto basicamente sobre isso também. Então vamos fazer isso um pouco maior. Algo assim provavelmente será suficiente por enquanto. Podemos ver isso um pouco mais tarde. Então este seria o, basicamente, o menu suspenso, certo? Então, vamos renomear este cartão suspenso. Este é o menu suspenso a partir do qual podemos basicamente escolher as cartas. Vamos preencher isso com os tribunais mais tarde. E então teremos três entradas. Então isso vai ser uma interface do usuário e um campo de entrada, também texto Mesh Pro. Porque não? Vamos fazer disso algo assim. Vamos tentar centralizá-lo mais ou menos. E então vamos para este campo de entrada e apenas redimensionar esta semana este tamanho automático. Assim, o espaço reservado é o tamanho automático e outros textos também serão auto tamanho. E, em seguida, este campo de entrada vai ser a entrada HP. Então, eu vou basicamente, sim, Bem, primeiro de tudo, nós vamos construir isso e então nós vamos construir os dados para ele enquanto selecionamos este Controle D para duplicá-lo. E então isso vai ser arrastado um pouco para baixo. E esta seria a entrada vazia, por exemplo. E então vamos duplicar isso também. E então esta vai ser a entrada XP. E o, Eu também vou conseguir alguns rótulos lá. Isso só vai ser texto Mesh Pro. Então este é o rótulo HP, por exemplo. Vamos fazer este. E nós vamos mover isso, na verdade torná-lo um pouco maior. Mova isto para cá. E esta é a HP, certo? Nós também podemos auto dimensionar isso. Isso é ótimo, isso é muito bom. Duplicá-lo mais uma vez com aqui Control D e, em seguida, outro, regra d. Este seria o rótulo MPI, sempre certificando-se de que este é um bem feito aqui, bem como os objetos do jogo sendo renomeado portal corretamente, bem como, em seguida, é claro, também mudando os textos que eles são. Porque isso vai poupar muita dor de cabeça, especialmente mais tarde. Se você pode querer mudar algumas coisas, eles são você vai ficar feliz que você renomear isso corretamente. E, em seguida, duas últimas coisas, e essas serão dois botões. Um botão bem aqui. Isso vai ser mais uma vez um botão Mesh pro de texto. E este vai ser o botão Salvar. E então vamos duplicar isso também. Na verdade mudar o então você pode apenas voltar controle Z. Claro, este pode ser o botão de dados seguro, e então vamos copiar isso. Na verdade. Vamos também fazer o tamanho automático, modo que é realmente ainda melhor. Agora duplicado. Mas parece que este vai ser o botão Carregar, botão de carregamento. E, em seguida, também altere o texto aqui para carregar dados. Neste momento, o primeiro painel aqui está configurado. E agora queremos um segundo painel. E isso é basicamente para exibir o que temos colocado lá vai ser você painel. E, em seguida, torná-lo um pouco menor para o lado direito aqui. Vamos ter um painel aqui em cima, que vai mostrar o resto dos dados. Então este vai ser o painel de dados do jogador. E neste, vamos ter um texto da interface do usuário no topo. O que só vai dizer, este vai ser apenas o rótulo de dados do jogador. Por exemplo. Isto é apenas vai dizer jogador, um jogador de dados auto tamanho e, em seguida, também torná-lo id centro, o ego. E então vamos ter uma mensagem. Este vai ser o rótulo de cada peal HP mais uma vez. Então, por exemplo, nós também poderíamos selecioná-los e depois duplicá-los novamente. Leve-os para o painel de dados do player, e depois arraste-os para que não tenhamos que ler. Fazemos isso porque são basicamente os mesmos. Esses são apenas rótulos que vão ficar exatamente como estão. Então eles não vão mudar. No entanto, nós vamos, então nós podemos basicamente duplicá-los novamente. E então esses, esses objetos de jogo, vão realmente mudar. Então, esses seriam. O valor HP, o texto do valor, por exemplo. E então temos o texto do valor MPI e o texto do valor XP. As entradas aqui são, eu só vou escolher qualquer número aqui. Então, algo assim. Cento, dez, quinhentos, e então este vai ser 500. Agora também vai expandir isso um pouco. Então nós vamos fazer isso um pouco maior e também torná-lo alinhado com eles para que ele meio que parece bom. Mais ou menos. Pelo menos eles fazem algo assim. Uma linha ali e uma linha. Ali. Você vai. Agora está tudo bem. E então este também. E lá, e então nós vamos fazer este mesmo tamanho aqui, assim como este tem o mesmo tamanho que o mais baixo e o do meio. Lá vai você. Então esses três também vão estar ancorados à direita. Então vamos ter o alinhamento B à direita, e aqueles vão mudar. Mas vamos descobrir o porquê, como isso funciona daqui a pouco. Em primeiro lugar, essa é a configuração aqui. Então isso funciona muito bem e isso é muito bom. Vamos fazer isto mais pequeno. E nós basicamente já podemos adicionar algumas coisas a isso. Então a primeira coisa que vamos ter é que vamos ter um criar um objeto vazio. Será que o Gerenciador de UI, vamos fazer muito com isso em pouco tempo, bem como teremos um, outro objeto vazio, o objeto de dados seguro. Isso basicamente vai salvar nossos dados e basicamente também carregar nossos dados para que tenhamos isso disponível, certo? Eu acredito que essa é uma espécie de configuração que precisamos para agora, e agora ele passa para os diferentes scripts. Vamos também adicionar o, vamos adicionar o player, o player seguro prefs aqui para o objeto de dados seguro e o Gerenciador de UI para o objeto gerenciador, bem como a população de coração que já adicionamos. E depois os dados do jogador, certo? Os dados do jogador não precisa ser adicionado a nada porque os dados do jogador não vai ser um comportamento mono. Então é aí que podemos basicamente começar. Então, vamos realmente excluir isso primeiro e acima de tudo. E os dados do jogador que queríamos salvar são algumas coisas. Então, por exemplo, o que queremos salvar é um inteiro público, HP, um MP inteiro público e um XP inteiro público, bem como um índice de cartão int público. Então este é o índice que representa o cartão. Claro, o que poderíamos fazer é salvar o próprio cartão. Mas por que guardaríamos o cartão em si ou o sprite se podemos simplesmente dizer: “ Oh, quero dizer, temos um índice, temos uma lista de cartas. É por isso que a população central foi uma boa ideia. E podemos facilmente fazer isso. E basicamente vamos tornar isto bastante sensato. Então, primeiro de tudo, nós vamos realmente ter um delegado aqui. Então este vai ser um vazio delegado público na mudança de dados do jogador para que possamos basicamente ver quando os dados mudam. Então vamos colocar em cada bit de dados aqui no índice do cartão, no índice cardíaco. Então esse é o vazio e, em seguida, todos os parâmetros é como o evento real ou o método que ele está sendo chamado pelo evento tem que se parecer. Então temos que dar a ele os perímetros e isso precisa ser evitado. E então vamos ter um evento estático público do tipo na mudança de dados do jogador, que está na mudança de dados. E vamos usar isso para basicamente atualizar a interface do usuário uma vez que os dados foram alterados. Então, mais uma vez, em vez de passar por isso com dentro de um, um método de atualização, vamos fazer isso assim, certo? Vamos fazer um único padrão aqui. Então nós vamos ter um dados LEA estáticos privados, que vai ser a instância que no início vai ser nula. E então vamos ter um pequeno gueto agradável fazendo uma instância de dados de jogador estático. Isto está escrito agora em letras maiúsculas. Então este seria neste caso, neste caso é realmente uma propriedade. E então nós vamos ter um entrar aqui onde basicamente dizemos, Ei, se instância é igual a nulo, então vamos criar uma nova instância. E se não for, então nós simplesmente retornaremos esta instância. E dentro daqui, nós realmente queremos instância é igual a um novo jogador de dados. No entanto, neste momento, isto não estaria preenchido. Então, primeiro de tudo vamos ter que fazer um novo construtor. Agora este construtor pode realmente ser privado porque nós realmente nunca queremos dados claros para estar fora de qualquer lugar. Nós sempre queremos criá-lo dentro daqui. Neste caso, porque sempre haverá apenas dados de um jogador. E isso vai ser salvo nesta variável de instância acessível pela instância pública de dados do player estático. Agora, geralmente, esta não é bem a maneira que ele provavelmente funcionaria dentro de um jogo que realmente funciona. Mas isso vai ser, eu acho que é suficiente para este momento, porque na verdade tudo o que nós queremos fazer é que nós queremos alguns dados que nós queremos salvar. Então, nosso construtor terá um JMP XP e índice de cartão. Poderíamos também ter sido gerados automaticamente, mas creio que isso também vai correr bem. Então este é, este AHP, este ponto AMP é igual a MP. . Tab XP é igual a x b, e então este índice de cartão ponto é igual a coordenada x. é igual ao índice de cartão que eles vão. E o que nós também teremos é, então estes são os dados do jogador dentro daqui. Agora temos que especificar as coisas que queremos. Então vamos fazer quinhentos, cem, dez a 507 mil. Então este seria o HP, Iniciando HP, o MP inicial, XP inicial, e o índice de cartão que começamos com. E também teremos um vazio público, que será o método de dados do jogador set, que basicamente define os dados do jogador. Então, podemos basicamente mudá-lo. Isso vai ser ter exatamente os mesmos parâmetros que o construtor. E vai fazer exatamente o mesmo neste caso. E então nós também chamaremos a mudança de dados com um ponto de interrogação invocar para que verifiquemos se é ou não basicamente nulo ou não. E então podemos simplesmente colocar em todos os parâmetros que tínhamos lá em cima. Dentro daqui. E isso vai então chamar o evento de atualização ou mudança cada vez que definir os dados do jogador e basicamente alterá-lo para que, em seguida, podemos atualizar a interface do usuário uma vez que basicamente colocar isso em nosso Gerenciador de UI. Tudo bem, então vamos entrar no Gerenciador de UI. Então seu gerente vai ter um, isso vai ser realmente muito interessante. Isso vai funcionar como o seguinte. Então, temos um monte de elementos de interface do usuário dentro de nossa cena agora. E, na verdade, teremos todos esses tipos de explicitamente colocados em nosso Gerenciador de UI. Então vamos ter um, então primeiro de tudo, é claro, usando o mecanismo Unity wi, então precisamos usar esse namespace. Teremos dois botões aqui. Então botão privado, botão Salvar. E então poderíamos simplesmente copiar isso sobre o controle C e, em seguida, salvar isso com o botão Carregar. Agora, ambos serão campos serializados. Neste caso, eu realmente vou colocar o campo serializado na mesma linha que esta, porque caso contrário nosso script vai ficar muito longo. É agora já é muito longo, mas isso só vai torná-lo um pouco mais fácil de ler. Você também pode fazer isso, a propósito, eu costumo colocá-lo no topo em outra linha. Mas também funciona. Também usaremos TMP Pro ou TM pro para o nosso profissional neste caso. E nós vamos ter um campo serializado do tipo de campo de entrada TMP privado, entrada HP, nenhuma entrada, HP na verdade. E então isso pode ser copiado também. Então Controle C, Controle V, Controle V. E então temos entrada MP e XP. Ele também terá um campos serializados, TMP privado, descartado. Este vai ser o nosso cartão suspenso chamado drop down. E, em seguida, temos serializado campo de TMP privado, txt. Este é o texto da HP. Então esta é a exibição real dos valores. Hp leva texto vazio e texto XP. E então, por enquanto, o que teremos é um pouco. Então, dados de um jogador jogar fora referência de dados aqui também terá um privado chamado população, população central, para que possamos acessar isso sempre que quisermos. E então, por último, mas não menos importante , que não implementamos, mas vamos muito em breve nas prefs do jogador seguro, que vai ser o jogador prefs seguro. Lá vai você. E agora isso é um monte de coisas, certo? Isso é loucura. Isso é um monte de coisas. - Sim. E o que vamos fazer é antes de tudo, vamos basicamente configurar isso nos métodos acordados que vamos armazenar isso no método de despertar e vamos configurar algumas coisas no início. E isso vai ser os dados do jogador. Assim, os dados do jogador é igual a instância de ponto de dados. Então isso simplesmente garante que a variável de dados do jogador aqui, a variável estática está sendo definida. E isso salva isso na variável de dados do jogador. Então vamos fazer, então vamos dizer, sim, bem, então vamos realmente encontrar todas essas coisas. Então prefs de jogador seguro vai ser igual a GameObject dot find. E, na verdade, o que vamos usar outro nós vamos usar encontrar objeto do tipo. Então esta é uma espécie de ponto GameObject encontrar e, em seguida, obter componente tudo em um. Isso vai encontrar um, um objeto de jogo que tem este script particular anexado a ele. E então a população de carros vai ser o mesmo objeto de jogo ponto encontrar, objeto do tipo. E esta vai ser a população de cartas, certo? E é isso. Por enquanto, o que vamos fazer no método acordado aqui. Há mais algumas coisas que precisamos fazer antes de continuarmos com isso. E então eu acredito no método de atualização que realmente nem precisamos porque, como eu disse, nós não queremos usar o método de atualização. Nós realmente queremos atualizar a interface real com um, com o carvão de evento. E sim, já podemos implementar isso. Então, isso funcionaria com a UI de atualização privada. Nota não atualizado, mas atualizar UI, que, claro, tem exatamente os seguintes parâmetros. Em MPI, no índice XP e int. Este é o índice do cartão, claro. E então o que vamos fazer é atualizar exatamente essas coisas aqui. Então nós temos os textos XP HP, nós temos o texto vazio e com o texto XP eu então uma outra coisa que é claro que precisamos é o GameObject da carta de jogador. Então, o que podemos realmente fazer é renderizador de sprite privado. Isso deve ser compreensível em apenas um tempo. renderizador de sprite de cartão de jogador. Então este é o, isso vai ser uma referência ao carrinho aqui. Então, a carta de jogador que temos aqui e para o sprite renderer nos para que possamos definir isso como uma atualização também. E este vai ser o renderizador sprite cartão de jogador é igual GameObject ponto encontrar, jogador, cartão de jogador que você vai. Dot get componente, não obter componente em crianças, mas obter componente normal que ego, sprite renderer ler. Então esta é a armadilha. Isso é algo que você normalmente terá que fazer de qualquer maneira quando você configurar alguns scripts grandes e uma espécie de uma maneira interligada de fazê-lo. E agora nós podemos realmente definir os dados já. Portanto, a UI de atualização deve agora funcionar não, sem qualquer problema. Assim, o sprite do renderizador do sprite do jogador é igual à população do carro. E então Aya, Claro, bem, a população de carros agora, vamos voltar rapidamente para a população principal. Isto é, naturalmente, privado agora, na verdade, teremos de o tornar público neste caso. Para que possamos acessá-lo de qualquer lugar que quisermos. Você também pode pensar em torná-lo estático como um singleton, mas isso vai ficar bem também. E então agora nós podemos realmente acessar isso. E este vai ser o acorde do índice dado onde vamos definir este tubo. E então os textos serão definidos também. Então texto HP, texto é igual a cada ponto p toString porque esses são inteiros, nós realmente temos que convertê-los com o método toString. E então podemos simplesmente copiar isso. Então MPI textos e expert TTX, XP e MPEG-2 string. De outra forma, eles vão MP e XP. Tenha cuidado com isso. Isso pode acontecer apenas para ter certeza de que tudo está na ordem correta lá. Certo. E então o que mais quereríamos? Gostaríamos também de outro método que vai ser chamado de private ou não load, não no nível carregado, mas apenas carga. E aqui é onde nós basicamente pegamos as entradas e as definimos. Então a idéia é que agora eles estão vazios, certo? Então agora a textura está vazia e vamos imediatamente definir isso para o padrão basicamente. Então nós estamos basicamente indo imediatamente dizer, ok, entrada HP, que está escrito lá vai ser jogador de dados ponto, ponto, ponto para string. Então, na carga, eu vou mostrar a vocês o que isso faz exatamente em pouco tempo assim que começarmos isso. Mas é basicamente simplesmente vai se certificar de que as entradas reais também são feitas corretamente. Tosse. Um valor é igual ao índice do cartão de dados do jogador. E então o método onload será frio. Bem, atualmente não precisamos chamá-lo. Vamos chamar isso de carga bem aqui no despertar. Depois que o jogador essa instância tiver sido definida. E então eu acredito que nós realmente não precisamos fazer muitas coisas mais. Precisamos preencher o menu suspenso dos cursos. Então isso é algo que precisamos fazer porque agora podemos fazer isso manualmente ou através do script. Porque quando olhamos para o painel aqui, então este é o nosso painel de entrada, o cartão suspenso agora é claro que não tem opções, ou melhor, ele tem opções a, B, e C. Mas isso é claro que não é bem o que queremos. E o que queremos é basicamente todas as cartas lá dentro. Então nós queremos os sprites da população de cartas lá para que possamos basicamente escolher um dos cabos que eles são. E o que vamos fazer é que vamos realmente fazer um novo método para isso. Então isto vai ser um vazio privado. Void pop você tarde, cordão cai para baixo. E isso vai fazer o seguinte. Isso vai ter uma lista de dados de opção suspensa TMP. Isso é o que já vimos, a maneira como pudemos preencher nosso menu suspenso antes que fosse com essa classe de dados de opção basicamente. E esta vai ser uma nova lista aqui. E então vamos simplesmente fazer para cada sprite, sprite na população do tribunal, nota ponto-ponto, população de cartas. Isso não está certo. População do cartão. Lá vai você. Dot sprites. Nós vamos fazer data.table pacote e, em seguida, fazer uma nova opção de dados aqui com o nome do ponto sprite particular, bem como o sprite propriamente dito. E, em seguida, no cartão final, drop-down. E opções é basicamente onde podemos adicionar uma lista de opções e eles são, vamos adicionar os dados em. Então, isso simplesmente preenche o menu suspenso real. E vamos ver isso em ação muito em breve. Certo? Então vamos ver vamos também ter certeza de que dentro do nosso tribunal drop-down que as opções que já temos ou realmente retirado que são lista opcional aqui está vazio agora. Caso contrário, teremos essas opções também. E isso, é claro, não vai funcionar. Está bem. Eu acredito que por agora estamos longe o suficiente ou estamos longe o suficiente dentro dele que devemos ser capazes de começar isso e realmente mudar as coisas. Atualmente, não seremos capazes de salvar nada. E, no entanto, a última coisa, na verdade antes de começarmos é que precisamos dizer, estamos acordados aqui, no fundo aqui, vamos dizer que esta seria a mudança. Então este é o, na verdade, vamos colocar isso aqui em cima. Então, assim que o conjunto de dados do jogador, isso vai ser dados do jogador, mudança de dados ordinal mais igual a atualização UI. Então, vamos atualizar a interface do usuário quando os dados do jogador mudam. Certo? E esse deveria ser o fim para este. Vamos ver, vamos começar isso, ver se temos algum erro. Na verdade, recebemos um erro. Isso não é a pior coisa. Agora mesmo. Na verdade, estamos fazendo coisas muito complicadas. Então podemos ver o que Y0 é. Este cartão vai cair em opções de dados para que em algum lugar algo aqui é uma leitura nula. Podemos pensar sobre isso. Então a idéia é que temos a linha fria 38 no Gerenciador de UI. E isso de alguma forma é nulo aqui. Então o que é provavelmente saber é que o cartão caiu para baixo neste caso. E vamos pensar sobre isso. E isso é claro, verdade porque perdemos uma parte crucial disso e que é definir todos esses campos serializados. Então, se dermos uma olhada no Gerenciador de UI aqui, tudo aqui não está sendo definido. E isso é claro, algo que precisamos fazer primeiro. Então isso é algo que é totalmente normal pode acontecer a qualquer um. Basicamente, às vezes esquecemos de definir algo. Então isso é realmente muito importante para se pensar. Este é um erro que pode ocorrer a qualquer momento. E agora vamos definir isso para que a inserção de um painel aqui, botão Salvar é o botão Salvar, o botão Carregar. E agora, como podem ver, a nomeação aqui é muito útil porque sabemos o que é tudo. A entrada Hp é entrada HB, entrada vazia é entrada vazia x entrada p é entrada EXP, desculpe, executado com o ego. E o cartão suspenso é o cartão descartado. E então podemos ir para o nosso painel de dados do jogador. E receba os textos de valor. Então textos de valor HB, textos de valor MP e textos de valor XP. É por isso que a nomeação dos objetos do jogo é tão importante. Não diga que não preciso disso. Demora apenas alguns segundos e vai poupar-lhe um monte de problemas porque agora se esses seriam entrada um, entrada dois, entrada três, nós não teríamos idéia. Teremos que clicar nisso. Olhe aqui. De jeito nenhum mais fácil. Nomee-os corretamente e tudo vai funcionar muito melhor. Escreva agora, devemos ser capazes de começar isso sem nenhuma flecha. Vamos ver. Certo, não há erros, então isso já é legal. Pode ver os campos de entrada aqui. Eu realmente preenchido com os dados do jogador que estava em segundo plano. E então nós também podemos escolher algumas das cartas aqui. Agora, esses são, como você pode ver, um pouco apertados. Então, podemos querer olhar para o nosso menu suspenso e apenas torná-lo um pouco maior aqui para que você possa basicamente expandir este modelo em um pouco. E eu acredito que isso já deveria fazer isso um pouco mais agradável. Além de colocar o modelo aqui, ter a sensibilidade de rolagem um pouco maior. Então talvez colocar isso em 10 também funcionaria, mas isso é algo que realmente não é incrivelmente necessário. Só vai tornar a nossa vida um pouco mais agradável. Então agora é um pouco mais agradável. Ainda podemos ver, no entanto, o que podemos escolher o seu fim. Sim, podemos escolher um cartão diferente. E agora, nada acontece no, na escolha aqui. Mas isso é realmente algo que vamos colocar agora porque essas são as três últimas coisas. Antes de estarmos realmente salvando algo, temos curva tem que, tem que mudar os dados que vemos. Então, basicamente, se mudarmos a exibição aqui, então queremos que as cartas reais mudem. E se mudarmos algo aqui, então basicamente no final disso, queremos mudar essas coisas de dados aqui ou os dados relevantes do jogador que estão sendo exibidos. E podemos adicionar isso basicamente, vamos fazer outro vazio privado. E isso seria basicamente em, em mudanças de dados, em mudanças de dados. E nós vamos colocar isso no fundo aqui. Então isso está ligado, em mudanças de dados. E isso vai ter alguns ouvintes adicionados aqui. Então este vai ser o cartão largado. Mas sim, no valor alterado, adicione ouvinte. E então dentro daqui, basicamente temos o índice dado. E então podemos fazer outra expressão lambda aqui. E o que realmente queremos é mudar os dados do jogador que eles são. Então a coisa mais fácil que eu acho que fazer aqui seria, sim, Na verdade vamos fazer um método seguro de vazio privado com polegada, HP e MP em x ser um índice inteiro como este, apenas sem aquele. Lá vai você. E, em seguida, vamos simplesmente chamar dados de conjunto de dados dados do jogador, modo que foi o método que definimos antes. Cada BMP. E índice. E isto vai ser chamado aqui. Então, mesmo que o índice mude, vamos mudar todos os dados do jogador. Isso não é tão ruim. Todas as coisas consideradas porque, porque, por que não? Então isso vai ser, nós vamos realmente fazer um int. Esta seria a entrada HP é igual a em ponto análise texto ponto HP. Desculpe, esta é a entrada. Hp. Chamo isso de entrada. Sim, definitivamente. Está bem. HP de entrada é o, é um inteiro. Oh desculpe, é claro, é o mesmo, então isso não vai funcionar. Então, insira os textos ponto-ponto da HP, eles vão. Então esse era o problema aqui. E nós vamos copiar isso sobre, fazer a entrada MP e entrada X p valor. Isso pode ser MP e XP. Então, basicamente, neste momento estamos lendo qualquer que seja o texto que está dentro de nossas entradas aqui. Então a entrada aqui, a entrada aqui, e a entrada aqui. Este é o texto que estamos lendo. E, em seguida, basicamente, salvá-lo neste método seguro. E isso vai definir os dados reais lá. Então isso vai ser entrada cada valor-p, valor vazio de entrada, e valor XP de entrada aqui em baixo. Lá vai você. E então também precisamos do índice. Agora o índice é realmente o que nos é dado com o ouvinte aqui porque este é o menu suspenso basicamente dá-lhe o índice da mudança para que possamos soltar e, em seguida, nós escolhemos um item específico em que. E nos é dado o índice que estamos mudando também. E isso é exatamente o que gostaríamos de adicionar ao método save aqui para que o índice do acorde mude. Então este é um dos ouvintes que queríamos adicionar. E também queremos adicionar ouvintes para a mudança nas entradas reais que eles são. Então a entrada HP, um, que é o campo de entrada, há uma edição final. Então isso é mais uma vez, nós já vimos isso antes. Este evento que é demitido quando terminamos de editar o particular, bem, o que está escrito lá. E então dentro daqui, nós realmente teremos uma corda. Então isso vai ser, vamos chamar isso de texto HP. Claro, por que não cada vértice muda, por que não aquele? E então também chamaremos o método save aqui. E em vez de usar a coisa real que foi analisada lá em cima, nós realmente queríamos que cada vértice mudasse aqui. No entanto, os outros valores que estamos indo para tomar a partir do topo, eles são entrada x valor p, bem como o índice que realmente também tem que obter, é claro, então este seria int índice é igual int ponto nenhum. Na verdade, não precisas de fazer isso. Podemos fazer o valor de ponto suspenso. Lá vai você. Então este seria o índice. Vamos chamar isso de índice de cartão. Porque caso contrário este índice e este índice podem ser confusíveis. Então, índice de cartão. E lá vai você. Isto agora é, naturalmente, uma corda. Então isso precisaria ser analisado no interior daqui, é um pouco confuso, mas eu acho que isso vai ficar bem. O texto muda o ego. E então vamos realmente puxar isso aqui para que possamos, agora na verdade eu acho que isso está indo bem. E queremos fazer isso não só para a HP. Então, quando o, quando terminamos com a edição HP, mas também com o MP e a edição XP. Agora é muito importante que também mudemos esses nomes de variáveis. Então este é o NP e esta é a mudança de imposto XB. E então não queremos mais analisar a mudança da HP aqui. Nós realmente queremos pegar o valor no topo. Nós queremos é copiar este em ponto parse. E aqui está, a mesma ideia. Opa, não, isso não é o que queremos. Lá vai você. Isto vai ser valor HP de entrada e, em seguida, copiar este controle C. E, em seguida, este vai ser integer.parseint, este e este. Tudo bem, vamos passar por isso. Vamos rapidamente, rapidamente, rapidamente explicar listas. Então, o que estamos fazendo aqui? Assim, em mudanças de dados é simplesmente um método que chamamos no final do nosso método de peso aqui. E a ideia é que, no início, estamos lendo tudo o que temos as entradas para. Então, lemos o texto da HP e colocamos a entrada MPI na entrada XP, bem como o valor atual que é selecionado em alguns de nosso menu suspenso. Em seguida, adicionamos ouvintes a cada um deles. Então, basicamente, quando o valor do nosso menu suspenso muda, então se selecionarmos um valor diferente, então o que queremos é que o método seguro seja chamado de fim, para ser passado exatamente esses valores. Agora, isso simplesmente não vai mudar nada. Simplesmente somos, mas ainda queremos que esses valores sejam passados. Porque no nosso caso temos um método seguro que tem todos os quatro desses valores em teoria, é claro, também podemos ir para os dados do jogador e basicamente definir dados do jogador individualmente que possamos definir partes individuais das coisas. Então, se voltarmos para nossos dados de jogadores aqui, é claro que agora, nossos dados de jogador set é algo onde temos que definir todas as variáveis ao mesmo tempo. Poderíamos, por exemplo, fazer mais, sobrecarregar este método e ter algo como definir dados do jogador e, em seguida, apenas dar-lhe o HP ou apenas dar-lhe o MP, ou apenas o XP e assim por diante e assim por diante. Agora eu acho que faz mais sentido ter tudo isso em um porque podemos acessar o resto da entrada real. Eles não são nenhum problema. E, em seguida, a próxima coisa seria que se fôssemos a um, mudar os campos de entrada. Então, se acabarmos com a edição lá do que o que queremos é definir a única entrada que mudamos. Isto vai ser uma sequência de, portanto, temos que analisá-lo também. E então o resto vai ser os valores padrão, tipo de falar. Então, esses vão ficar assim. E queremos fazer isso para cada uma das três entradas. Certo? E agora ainda não estamos para salvar porque, como eu disse, isso vai ser um pouco mais extenso porque eu realmente quero que você tipo de entender o quadro em torno dele. É peso por causa da poupança em si vai ser realmente fácil. Você vai ser como realmente, essa é a poupança. Você gasta uns 30 minutos, na interface do usuário e tudo isso e, em seguida, como quatro minutos salvando coisas, isso é ridículo. Mas isso é basicamente, eu quero ter isso como uma espécie de, uma maneira muito agradável em que você também pode brincar com ele um pouco. Então, sim, então agora tudo foi definido. Vamos ver o que acontece. Então, primeiro de tudo, vamos começar com isso. E se formos basicamente ter uma carta diferente selecionada aqui, e como vocês podem ver, ela muda para o Rei, que é muito, muito legal. E então podemos trocar outro cartão, 33, e então talvez queiramos descer 41. Lá vai você. Agora, vamos mudar o HP. Então, por exemplo, 8 mil. E se eu clicar fora disso, então o HP vai realmente ser alterado também. Agora o que você vai ter notado aqui é que o acorde muda para trás e nós realmente vamos corrigir isso também. Acabei de notar por que isso seria o caso. E a razão é porque isso nos dados muda, é claro que é chamado uma vez. E nós basicamente salvamos quaisquer que sejam os valores reais. Alguns aqui, o que você poderia dizer, bem, isso não vai ser um problema. No entanto, ele realmente vai ser um problema porque isso é uma espécie de coisa única, certo? Então isso é chamado uma vez e então esses valores são passados para isso. Portanto, há duas maneiras diferentes de lidar com isso. Podemos fazer isto resolver estas coisas, e depois colocá-las aqui. Então, basicamente, pode ter este e depois este, e depois este. Agora você pode perguntar, por que isso mudaria isso? E vamos quebrar isso assim para que possamos vê-lo. Então você pode perguntar, por que isso mudaria isso para funcionar? E a idéia é que, bem, porque o texto de entrada aqui muda depois de termos colocado esse valor em cache. Esse valor não muda mais. Isto é definido em pedra basicamente. Então isso é uma coisa que é importante quando você é. Quero dizer, isso não é realmente um tipo de paralelismo ou, você sabe, trabalhar com coisas paralelas. Mas essa é uma das coisas que é muito importante pensar porque às vezes armazenar esses valores em cache na verdade não funciona muito bem. Então, infelizmente, vamos ter que pegar isso e , em seguida, basicamente, substituir este e este também. E então podemos pegar o texto vazio e substituir este e este. Vamos também nos certificar de que estamos quebrando isso de uma maneira razoável. Então, basicamente, depois do texto vazio para este aqui, e nós temos que pegar o cavalo XP aqui e pegar o valor z, valor z. Isso já está sendo feito. E então, infelizmente, mesmo com o índice do cartão, onde nós realmente temos que colocar no valor aqui. E então todas essas três variáveis, todas essas quatro variáveis ficam completamente obsoletas e não precisamos mais delas. Isso, infelizmente, leva ao fato de que isso é muito menos legível. Mas poderíamos tornar isso um pouco mais legível expandindo a expressão lambda neste caso. Mas não vamos fazer isso agora. Porque neste caso, isso também funciona. Poderíamos também ter um outro método chamado, mas creio que isso vai ficar bem por enquanto. Certo. E então apenas para um pouco mais esclarecimento, porque isso pode não ser meio óbvio por que isso não está funcionando, por que isso não estava funcionando corretamente antes. A idéia é que assim, por exemplo, quando mudamos o valor de nossos cartões drop-down. E se agora colocarmos o texto de análise aqui, então isso acontece toda vez que realmente alteramos esse valor. Então nós basicamente, cada vez que o método seguro é chamado, nós estamos realmente fazendo isso de novo. E antes, quando tínhamos essas variáveis armazenadas em cache antes, então isso aconteceria uma vez antes, e então nunca mais. Assim, nunca leríamos o texto real que está lá dentro. Portanto, tivemos que mudá-lo assim. Na verdade. Um exemplo de onde, eu não diria ser chique, mas você sabe, uma espécie de avaliação prematura do código pode realmente levar a que ele não funcione corretamente. Isso é um bom exemplo de algo assim. Então é por isso que eu queria basicamente manter isso dentro e mostrar a vocês, certo, mas agora se estamos realmente fazendo isso, então ele deve funcionar não importa o que façamos. Então, se mudarmos isso para algo como aqui, e então mudamos isso para 5000, como você pode ver, o MPG ou muda. E também podemos mudar o XP para algo e, em seguida, mudar o HP para 87. (Unity intermediário: E agora para a parte de salvar, que provavelmente todos estão esperando por um bom tempo. E o que teremos é que teremos dois métodos dentro do nosso jogo, prefs de jogadores seguros. Isso vai ser um público evitar um dados seguros, salvar dados e, em seguida, um público anular dados de carga, carga, carga de dados. Lá vai você. E também uma variável de dados do jogador privado aqui jogar nossos dados. Eles vão. A data do jogador da variável vai ser definido para jogar um dados é igual classe de dados camada igual a em ponto instância deve ser sensato. Os dados salvos simplesmente vão fazer prefs do jogador. Então esta é exatamente a aula que eu estava falando em que nós podemos salvar coisas e então nós podemos salvar coisas com o set. Então definir, flutuar, definir e definir cadeia. Esses são basicamente os três valores diferentes que podemos salvar. Então, todos esses seriam ins, então isso é HP. E, em seguida, como segundo parâmetro, vamos dar-lhe o valor real. Portanto, é só isso que precisamos fazer para salvar isso. E então vamos fazer isso por todos eles. Então MPI, não só ele, mas MP, EXP, e então nós também vamos fazer o cartão, cartão para cartão índice. E isso vai ser EXP vazio, e então o índice do tribunal. Então esta é a poupança feita. É isso. Agora só precisamos lembrar dessas cordas, é claro, porque elas são as chaves. Então você pode pensar basicamente no jogador pressiona como um dicionário, um dicionário fence que realmente salva isso em um, no disco, no arquivo. Então, para ler isso, podemos fazer. Então interrompa XP inteiro, jogador, prefs jogador, jogador prefs ponto, entrar neste caso. Então GetInt é feito maneira que você passar a chave em e, em seguida, você chegar ao valor real. Você também pode fazer uma segunda coisa onde você pode colocar em um valor padrão. Então, se isso não for encontrado, então você basicamente obter o valor padrão. Isto é simplesmente para garantir que, se por alguma razão suas coisas não estão definidas, então você pode realmente fazê-lo assim. Então vamos copiar isso algumas vezes também. XP Mp e, em seguida, o índice do cartão. E nós tínhamos um de 1500 para o MP e o XP era 2500. Então vamos mudar isso também. É 0 para os índices de cartão vai abrir assim. Cartão indexar o ego. Então agora que nós também temos os valores padrão básicos, apenas no caso de esses não existirem. Porque talvez o que acontece é que clicamos no botão de carregamento de dados e, na verdade, os dados ainda não foram definidos. Então isso seria muito bom. E, em seguida, jogar um conjunto de dados dados do jogador. E então lá dentro podemos colocar no HP, o MPI XP, e no índice de cartão. E isso foi tudo para economizar e carregar. Agora só precisamos ligar os dois botões lá. E seria isso. Então nós só temos que fazer o botão salvar no clique, Adicionar ouvinte. E então, lá dentro, podemos simplesmente chamar os dados de salvamento de pontos do jogador seguro prefs. E no mesmo token, copiando isso, podemos dizer o botão Carregar. Queremos carregar dados. E os prefs do jogador, prefs do jogador seguro foram definidos com o objeto de busca do tipo. Então isso deve ser definido. Isso vai servir também. Então isso pode ser extraído para outro método. Vamos manter isso aí por enquanto. Mas, de um modo geral, penso que isto deve ser realmente tudo o que precisamos. Fazer. Sabe, há mais algumas coisas. Então este método onload, nós provavelmente poderíamos lembrar isso para preencher o texto. Há muitas coisas que podemos mudar para tornar isso um pouco mais legível. Mas no geral, isso vai ficar bem. E vamos ver se podemos realmente salvar e carregar dados. Então isso seria muito legal e muito interessante. Então nós vamos começar isso por agora, e então nós vamos apenas selecionar um belo rei. Então nós vamos ter algo como 12000 e então nós vamos ter um monte de lá e então algo como isso para o EXP. E, em seguida, vamos apertar o botão Salvar dados. Nada aconteceu, o que é realmente muito bom porque, você sabe, se, se houver um erro, então provavelmente teríamos ouvido falar sobre isso. E então vamos sair disso e então todos sabem, todos os meus dados estão perdidos. Eu não sei. Não sei o que tínhamos aqui, tipo 30000. Vamos clicar no botão de carregamento de dados e ver se isso funciona. E fez. Então isso é muito legal. Uma das coisas que agora não atualizou são os textos HP, os textos e os textos XP aqui. Então isso é algo que você também precisa pensar. Porque se nós mudarmos o cartão real aqui, isso mudaria de volta porque isso está lendo fora deles o tempo todo. Então essa é uma das coisas que é muito importante pensar, que você realmente precisa. Eu também garante que aqueles são salvos bem e que eles mudam com ele. Então o que você poderia basicamente fazer em teoria, que poderia basicamente fazer é que você pode simplesmente chamar o método de carga cada vez que você faz isso. Então basicamente o que você simplesmente faz é em vez de apenas dar-lhe o único método, nós podemos colocar em um colchete encaracolado aqui e um colchete encaracolado aqui. E, em seguida, certifique-se de que você não esqueça o ponto-e-vírgula e, em seguida, dizer sobre a carga. Então agora o método onload está sendo chamado cada vez que você diz clique no botão Salvar. E então podemos basicamente fazer a mesma coisa para o botão Carregar também. Então faça este, e então podemos dizer “carga”. E então, se o onload for chamado, é claro, sempre redefiniremos nossas entradas exatamente para isso. E isso deve ser totalmente bom. Então vamos ver se isso funciona agora. Os dados ainda devem ser salvos porque foram salvos antes. Então vamos olhar para esses dados de carga. E como você pode ver agora, todos esses dados foram definidos também. E então, se mudarmos o cartão, então nada aqui muda novamente. Esse é o último tipo de conserto que você precisaria implementar para que isso funcione. E então eu posso mudar isso para outra coisa. 99, 99, algo assim. E então, você sabe, eu não sei, algo assim. E se eu salvar isso de novo, e agora, vou mudar tudo, certo? Algo como isto. E depois vamos para outro cartão. E se eu fosse carregar agora, tudo muda de volta para exatamente os dados que eu salvei pouco antes. Certo? Então essa foi uma maneira muito indireta de mostrar como você pode salvar dados. Eu queria fazer isso em um pouco mais, digamos estilo em um pouco mais agradável e algo que você realmente tem que para que você possa brincar com ele. Independentemente de se você tomou o se você já importou o pacote e brincou com ele assim, ou se você programou junto, entender que isso é um pouco mais complicado, mesmo que o real salvando-se, como você pode ver claramente, é muito, muito fácil de fazer. Isto não é uma coisa maluca. É apenas dois métodos quando basicamente apenas o método conjunto e, em seguida, o GetMethod que fazemos nos prefs jogador. E sim, essa seria a poupança. Mas eu queria ter tudo em torno dele porque na próxima palestra, o que vamos olhar é salvar dados com basicamente Jason com arquivos JSON. E isso vai ser um pouco mais complicado, no entanto, um número um vai ser muito mais robusto? E número dois, ele realmente vai nos permitir salvar classes inteiras em vez de apenas salvar inteiros, flutuadores e strings. O que é importante, especialmente se estiver trabalhando com um grande projeto. Em seguida, inteiros, flutuadores e cordas podem levá-lo um pouco para. Mas em algum momento você vai ser como, cara, eu só não quero definir isso também os prefs jogadores não são a melhor idéia para salvar tudo lá dentro. Aqueles são, É melhor basicamente salvar. Então, como você pode ver, ele armazena as preferências do jogador entre sessões de jogo. Como o nome sugere, é mais ou menos melhor salvar tipo de, você sabe, suas preferências para o seu jogador lá dentro. Então, talvez opções, que é uma boa idéia para salvar nos prefs jogador. E então, além disso, provavelmente não é, definitivamente não é recomendado para salvar quaisquer dados vitais lá. É muito melhor para salvar isso em seu próprio arquivo JSON e, em seguida, talvez até mesmo o seu próprio formato de arquivo, mas isso é muito avançado arquivo adjacente para nós agora na próxima palestra vai ser suficiente muito, então ele vai ser mais do que o suficiente. Isso seria tudo para esta palestra. Como eu disse, era um pouco mais extenso. A própria salvação. Bastante fácil. Mas sim, esse seria o fim para este. Como sempre. Se você gostou e se você aprender algo novo, eu naturalmente apreciaria muito uma revisão de você. Caso contrário, se as perguntas permanecerem, então, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 88. (Unity intermediário: Tudo bem, vamos continuar a introdução da unidade intermediária aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em como salvar dados em um arquivo JSON. Da última vez, basicamente criamos nosso pequeno exemplo aqui, bem como dados de segurança com os prefs do jogador neste caso. E agora nós vamos tipo de adicionar a isso e basicamente ter os dados salvos em um arquivo JSON em vez dos prefs do player. Então, primeiro de tudo, vamos criar uma nova cena. Esta não vai ser, na verdade, uma cena nova. Na verdade, vamos pegar as prefs do jogador L6, desculpe, e depois Control D para duplicá-las. E este vai ser L8, Jason. E, em seguida, dentro da pasta de scripts, uma nova pasta, e que é L8 salvando com JSON ou apenas Jason, isso é bom também. E então o novo script aqui, e nós vamos chamar isso de “Jason loader”. Porque vai ser um solitário que carrega Jason Wright. E agora vamos também abrir o Jason é visto aqui e, em seguida, mudar sobre os dados seguros. Então nós vamos basicamente remover o player prefs script seguro de lá e adicionar o script carregador JSON lá. E, em seguida, vamos abrir o script Jason inferior, bem como nós também precisamos do Gerenciador de UI e os dados do jogador. Estes são os outros dois de que também precisamos porque precisamos mudar algumas coisas aí sobre, na verdade, não tantas. Então, nos dados do jogador, vamos realmente adicionar System.Out serializable no topo da classe. Isso simplesmente nos permite converter esses dados de classe em um, em um arquivo JSON, por assim dizer. Então essa é a ideia que eles são. E a segunda coisa no Gerenciador de UI que precisamos fazer é realmente não muito ruim. Queremos adicionar uma, outra variável privada aqui, e que seria um carregador Jason privado chamado JSON loader. Vamos chamá-lo assim. Na verdade, e tudo bem, tudo bem. E isto será definido para aqui. Então este seria o carregador JSON é igual a GameObject ponto encontrar objeto do tipo Jason loader. E isso seria bom. E então, em vez de fazer o seguinte, então em vez de salvar e carregar com os prefs do jogador, o que vamos fazer é dizer, ok, se os prefs do jogador não são nulos. Então, se ele encontrou na cena atual um, um objeto com o jogador seguro prefs. Então faremos isso. E se esse não for o caso, vamos olhar se o rastreamento e carregador é desigual a nulo em igual nulo. E se for esse o caso, então vamos fazer outra coisa. Então vamos basicamente manter os dados de salvamento do ponto do carregador JSON. Então vamos abrir o arquivo JSON loader aqui. E vamos continuar sendo um comportamento mono porque já o anexamos. E precisamos mais uma vez nos dados do jogador aqui, camada de dados como uma variável. Isto, é claro, pode ser muito facilmente obtido com instância de ponto de dados do jogador. E então, assim como com os prefs do jogador, nós vamos realmente ter uma viagem pública, dados seguros e um vazio público. Dados de carregamento anulado público. Não, não esse, mas carregar métodos de dados. Então isso, se você viu isso e em seguida, também o jogador prefs classe C-Sharp que nós fizemos. Você pode dizer, bem, nós temos um dados seguros e dados de carga em ambos. Não poderíamos fazer uma interface para isso? Sim, isso é exatamente certo. Essa seria uma das, uma das maneiras que você também poderia fazer isso. Então você provavelmente poderia configurar uma interface para cada um deles. Tipo de ter isso como um dados salvos ou um IA, IA dados salvos ou algo assim, que provavelmente funcionaria bem. Mas no nosso caso agora, não precisamos fazer isso. Nós só queremos saber, ok, como podemos realmente salvar isso em nosso adjacente e podemos fazer isso? Primeiro de tudo, o que precisamos é que precisamos usar o namespace System.Out.Print Joe também. Porque esse é o namespace que nós, que podemos escrever e ler dados. Neste momento, em nosso método de salvar dados, o que vamos fazer é definir uma string chamada adjacente. E então vamos usar a classe utilitário Jason para basicamente converter um objeto em um JSON. Então, como você pode ver, podemos colocar em um objeto como um parâmetro e convertê-lo em uma representação JSON. Então, apenas para um esclarecimento rápido, adjacente é uma notação de objeto JavaScript. Não deixe que isso te engane. É, ele não precisa ser usado apenas em JavaScript, é apenas uma espécie de maneira que você pode armazenar dados de forma bastante eficiente e basicamente lê-lo e escrevê-lo. Então o que vamos fazer é realmente vamos registrar essa string JSON e realmente ver o que ela faz. E então o que podemos fazer é também registrar um caminho específico. Então, é claro, em breve vamos usar basicamente o escritor de fluxo, que já usamos na introdução C-sharp. E este vai salvar algo em particular, em um diretório particular. E a maneira que podemos fazer isso é usando dados de aplicativos, datapath. Então este é basicamente o datapath. Em seguida, podemos usar metade separador de diretório antigo. Agora isso pode parecer loucura. O que você está fazendo aí? Em seguida, o último vai ser salvo ponto de dados JSON. E a idéia é que, bem, o datapath, como você pode ver, está sempre diretamente na pasta do jogo. Portanto, este é um caminho direto para a pasta Ativos. E este velho separador é basicamente. Bem, o que você precisa. Então, ou uma barra invertida cinza porque às vezes dependendo de que tipo de sistema você está, se você está ou não em um Linux, Mac ou PC. Então, Windows, que isso pode ser diferente. É por isso que um caractere separador de diretório antigo de ponto de caminho é provavelmente melhor usar aqui. Então vamos primeiro de tudo realmente apenas ter este ser saída aqui em um cofre em vez de realmente tê-lo basicamente salva algo, apenas para que possamos fazer isso. Então vamos copiar sobre basicamente a escuta aqui no ouvinte e, em seguida, mudar as configurações do jogador seguro para Jason loader, e, em seguida, o JSON mais baixo também. E isso deve funcionar, totalmente bem. Agora, vamos ver se isso realmente funcionou ou não. Então, se entrarmos aqui e vamos mudar algumas coisas. Então, por exemplo, na velhice, isso muda os números aqui apenas um pouco. E, em seguida, se acertarmos Salvar dados, devemos ver alguma saída. E nós realmente fazemos isso HB é cinco, o que faz isso 5 milhões, sim, e então 24 mil para MP um 100 e 33 para XP. E então o índice do carrinho é 18. E então você também vê exatamente onde ele salvaria o arquivo adjacente. E isso seria exatamente dentro de nossa pasta de ativos aqui. Então isso é muito bom. E agora podemos adicionar a funcionalidade. Na verdade, vou guardá-lo também. Então, como vamos salvá-lo? Bem, nós vamos estar usando a palavra-chave, usando mais uma vez com o gravador de fluxo neste caso. Então este vai ser o escritor e que é igual a um novo escritor de fluxo para um diretório particular neste caso, e esse é exatamente o diretório que nós especificamos aqui. Eu só queria mostrar isso porque isso é meio legal. E depois vamos fazer isto. E enquanto isso acontece, na verdade, não precisamos fazer nada louco aqui. Escritor, ponto-ponto, certo? E então nós vamos apenas dar-lhe a cadeia adjacente real que temos aqui. Porque o utilitário Dacian adjacente já converteu nosso objeto ou objetos de dados de um player em uma string. Vimos isso na saída. E nós não precisamos necessariamente produzir o datapath mais. E, em seguida, para os dados de carga é realmente exatamente o mesmo, exatamente o contrário. Então nós vamos ter uma string, Jason, que vai ser um, um ponto de string esvazia na string vazia. E então nós vamos estar usando o leitor de fluxo. Nesse caso, o leitor é igual ao novo leitor de fluxo. Agora, é claro, certificando-se de que este é exatamente o mesmo local aqui. Então, pode haver algum sentido ou algum interesse em realmente salvar este datapath como uma variável de string dentro do seu carregador como um, como uma string, como eu disse, onde ele não vai fazer isso neste momento, mas pode ser uma boa ideia. E então vamos simplesmente dizer Reader dot para terminar e salvar isso dentro de nossa string JSON. Agora temos basicamente exatamente a mesma string JSON. Leia de volta como temos aqui. Mas agora, é claro, precisamos fazer um novo jogador de dados para isso. E vamos fazer dados de um jogador. Os dados são iguais a Jason ponto util de JSON. E então dentro daqui, dentro dos nossos suportes angulares estão suportes angulares. Nós realmente especificar o que queremos como retornos. Então este vai ser o dado do jogador. E, em seguida, dentro de lá vai ir para a corda real. E então o que vamos fazer é dizer dados do jogador, conjunto, dados do jogador. Então estes são os dados reais que temos aqui. Este seria um novo exemplo disso. E geralmente o que faríamos é fazer um dado, data.table P e, em seguida, data.dat AMP e, em seguida, data.txt. E então, por último, mas não menos importante, o índice do cartão data.dat. E, em seguida, os dados reais do jogador foram definidos novamente. Agora nós poderíamos, naturalmente, também pensar em talvez fazer outro método de dados set player onde nós realmente dar-lhe uma outra instância de dados de camada aqui e fazê-lo assim. Mas agora isso será, é claro, completamente suficiente e funcionará totalmente bem. Então vamos realmente ver se isso vai funcionar ou não. Então, a primeira coisa, é claro, estar armazenando isso e eu estou apenas rastreando um pouco. Vamos fazer algo assim. E então vamos fazer como 1990 e então vamos fazer como 420. Claro, por que não? E então vamos clicar no botão Dados seguros. Tudo bem. Então isso parecia ter funcionado. Então 17 para 20, 30, 45 e 1990. E então eu realmente olho dentro da pasta do nosso projeto para que não vejamos nada agora. Vamos fazer uma atualização com o botão direito do mouse. E vamos ver, lá está, seguro db.json. Então vamos clicar duas vezes nisso. E ele realmente abriu dentro do Notepad Plus, Plus. Isso é um pouco lamentável. Mas você pode realmente vê-lo aqui também. Cada um antes de 2013, 45 , 1990 e 17 é o carrinho e pescoço, modo que foi salvo. E se pararmos com isso e reiniciarmos, você verá que se eu carregar os dados, e como você pode ver, tudo funciona totalmente bem. E isso é tão fácil quanto trocar isso, certo? Claro, há um ponto de dizer, bem, talvez não queiramos fazer isso assim. Talvez queiramos fazer isso com uma interface ou algo assim. Acho que isso seria muito complicado. Já temos aqui uma construção bastante complicada para todo o aparelho de poupança, por assim dizer. E acho que vai ficar bem. Mas sim, é basicamente o mesmo método de salvar dados e carregar dados que chamamos. E isso simplesmente salva os dados para um arquivo JSON. Agora eu realmente queria mostrar a vocês o arquivo real como um interior do projeto real. Só um segundo. Vou fazer show no Explorer. Então esta é outra pasta na minha outra tela. E então eu vou simplesmente arrastar isso para lá. Deixe-me ver. Lá vai você, e lá vai você. Então é assim que o arquivo JSON realmente parece. Então a formatação não é a melhor, mas agora, eu pessoalmente diria, não se preocupe com a formatação por enquanto. O mais importante é que você ainda pode lê-lo. Se você tem aulas mais complexas, então é claro que vai ficar mais complexo. Sabe, se você tem listas, então isso vai parecer um pouco diferente. E sim, mas no geral, é isso. E sim, é assim que você pode carregar e salvar dados com um, com arquivos JSON basicamente, usando o util adjacente que vem com o próprio Unity, e que seria isso. Então essas são basicamente as duas palestras sobre como salvar o, digamos três palestras sobre como salvar seus dados. Eu definitivamente diria que o carregador adjacente, embora seja um pouco mais complicado, definitivamente, eu diria usar isso. É muito mais robusto, é muito melhor. E usar os prefs do jogador está tudo bem. Mas isso vai levar a apenas dores de cabeça porque os prefs jogador realmente não são o, não a fonte real ou realocação maneira que você deve salvar dados que é importante para o programa. Então salvar arquivos definitivamente ser feito por Jason ou você também pode fazê-los por conta própria, fazer o seu próprio tipo de coisa um pouco sábia, mas isso é muito avançado no momento. Agora mesmo. Jason está definitivamente onde está, certo? E isso seria tudo para esta palestra. Mais uma vez, espero que tenha achado útil e aprenda algo novo. Se algo não estiver claro, então, é claro, não hesite em fazer uma pergunta e eu vou ter certeza de responder. E sim. 89. (Unity intermediário: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada em um conjunto de azulejos. Assim, os conjuntos de azulejos são basicamente uma maneira na qual você pode fazer uma paisagem bidimensional. E isso vai ser muito fácil. Então vamos realmente criar uma nova cena e vamos dar uma olhada no que tudo isso tem reservado. Então L9 conjuntos de azulejos. Não precisamos de uma nova pasta dentro de uma pasta de scripts porque na verdade não precisamos disso. Quem quer que precisemos é de uma nova pasta dentro da nossa pasta de ativos. E isso vai ser os blocos, blocos conjuntos de pasta. E então nós vamos fazer ainda mais um nesse. Então outra sub-pasta, e isso vai ser chamado apenas o conjunto de título sublinhado um, apenas para que tenhamos um nome para isso. E nós vamos importar o mapa de mosaico PNG. Este é mais uma vez um dos recursos do Kenny. Claro, número 1 como um link e, em seguida, número dois como um recurso também. Vamos mudar a compressão para ponto de modo de filtro entorpecido. E, em seguida, pixels por unidade será 16, bem como colocar o modo sprite em múltiplos. E depois vamos dizer “Aplicar”. E então o que é muito importante é que o que queremos é entrar no Sprite Editor aqui. E queremos cortar isso, fatiar isso automaticamente. Eu acredito que isso deve ser bom, mas eu realmente acho que pelo tamanho da célula é melhor. Então isto deve ser 16 por 16 se não estou enganado, vamos ver 16 por 16. E então ele podia ver que eles estão sempre separados por um pixel. Então o que queremos é que queremos 16 por 16 e, em seguida, o deslocamento deve ser 11. Então vamos cortar isso e ver, oh, não, isso é 64 por 64, isso não está certo. Reverta esta reversão aqui. Fatia 16 por 16, deslocamento 11, corte isso. E então o deslocamento é na verdade o caminho errado. Então nós realmente queremos, nós queremos o estofamento aqui? É uma maneira muito estranha de dizer isso. Ok, então eu acho que é um preenchimento para o editor Sprite. Eu realmente pensei que o estofamento seria aquele das, bem, as bordas. Mas, aparentemente, não é. Então eles vão cortar este 16 por 16 e, em seguida, preencher 1 e 1. E então cada um desses também deve funcionar muito bem. Cada um deles agora é um sprite separado e seremos capazes de usar isso como um talentoso. Agora a aplicação aqui pode demorar um pouco porque esses são 485 sprites diferentes. Como você pode ver, é uma espécie de paisagem urbana aqui com alguns sprites verdes e uma espécie de construção também. E se isso for feito, então vamos realmente para a cena do conjunto de azulejos aqui, e vamos ver o que podemos fazer. Então o que podemos fazer é clicar com o botão direito na hierarquia. Em objetos 2D, temos o mapa de mosaico. Vamos fazer um retângulo é assuntos mais elevados também hexagonal com um topo pontiagudo e, em seguida, plano superior. Há também assimétrico e, em seguida, isométrico Z2, Z0 como y. Isso também funcionaria. Mas vamos olhar para mapas de azulejos normais de forma retangular. Se eu conseguir fazer isso funcionar, eles ficam retangulares. Então, uma grade aparecerá dentro de sua exibição de cena, bem como dois objetos básicos de jogo, uma grade GameObject com um tamanho de célula, bem como uma lacuna, lacuna e, em seguida, um mapa de mosaico embaixo dela. E essas são as duas coisas que basicamente vão parecer que são agora. Agora, como podemos mudar isso? Se nós descermos aqui para a paleta de azulejos abertos, então nós estamos realmente indo para obter uma nova janela aparecer, que é esta aqui. E, em vez de lá, não temos atualmente nenhum mapa de mosaico ativo. E diz para criar um novo mapa de mosaico. E na verdade não vamos criar um. Vamos pegar nossa cidade de Sprite e arrastá-la para cá. Bem, nós realmente temos que criar uma nova história e então nós vamos arrastá-la para lá, é claro. Então isso vai ser, vamos apenas chamar este azulejo, azulejo cidade conjunto de azulejos. Conjunto de azulejos da cidade. Isso é bom. Eles são retangulares. O tamanho da grade vai ser automático e, em seguida, o modo de classificação também vai ser bom. Então vamos criar isso. E isso vai ser criado dentro de um conjunto de mosaicos e conjunto mental sublinhar um. Como você pode ver, isso é legal de ver, digitalizá-lo. E agora podemos arrastar em um spread, um pico. E depois vamos fazer isso. Nós vamos salvar isso exatamente, exatamente na mesma pasta aqui. E isso vai levar algum tempo porque ele vai basicamente converter cada um desses sprites em uma espécie de bloco neste caso. Então, como eu disse, vai demorar um pouco. Dependendo da velocidade do seu computador, pode demorar um pouco mais ou um pouco mais curto. E então tudo é importante aqui. Então, se agora olharmos para uma espécie de conjuntos de mosaicos, conjunto de mosaicos, sublinhar uma pasta, então você pode ver que há um mapa de mosaico 64. E aqui em cima você pode realmente ver que sprite é este. E esses são basicamente todos os sprites agora como mapa de mosaico, tipo de partes individuais. E agora você pode pegar esses e desenhar com eles. Então vamos posicionar nossa janela de mapa de mosaico como uma espécie de aqui. E o que podemos fazer? Bem, se nós, por exemplo, selecionamos isso, então você usa, você pode ver isso é uma espécie de seleção destacada aqui. E deve pintar com o pincel. E se eu for aqui, você pode ver o que é isso? Bem, agora posso pintar para isso. Então, se eu agora segurar o botão esquerdo do mouse e eu posso realmente pintar isso. E eu posso pintar, bem os azulejos básicos aqui. Então isso é muito legal, na verdade, isso funciona assim. E os outros botões que são importantes, é claro, há uma seleção da grade, então eu posso basicamente selecionar algo aqui. E assim eu poderia ser capaz de basicamente movê-lo, eu acredito também. Então isso é o que nós, este removemos a seleção exatamente. Então eu posso basicamente selecionar isso, mudar, a ferramenta Mover e então eu posso mover isso ao redor. Então isso é muito legal. Eu também tenho diferentes tipos de modo de pintura. Portanto, há, é claro, o modo de pintura de um único pincel. Há também o, este é o modo de caixa preenchida. Então, com isso eu posso basicamente desenhar uma caixa. E isso desenhará uma caixa em torno dele. Assim, com o bloco que é selecionado, eu também posso selecionar vários blocos por sinal. Então eu poderia, por exemplo, dizer isso para que eu possa arrastar, e então eu tenho quatro blocos que estão sendo selecionados aqui. E então eu posso colocar isso como um exemplo. E então eu posso selecionar este azulejo, pegar o sorteio, e então fazer algo assim. Isso funcionaria. E eu posso tomar a vantagem, por exemplo, algo assim, desculpe, algo assim. Certifique-se de que, se tiver vários selecionados , volte para o pincel real. Caso contrário, com vários selecionados. E a caixa, vai ser um pouco estranha como você pode ver. Ainda funciona. Mas sim, agora nós realmente cometemos um erro. Oh, não, eu não quero isso aqui. O que podemos fazer é pegar a ferramenta de borracha aqui e apagar isso. Agora, porque temos dois ladrilhos selecionados, a ferramenta Borracha também tem dois blocos de espessura ou grande. E se tivermos apenas um selecionado e o tamanho será definido como um. Há também uma ferramenta de preenchimento. Agora, isso também pode ser útil. Talvez se formos como, eu, na verdade, eu não quero que isso seja verde. Eu realmente quero que isso seja uma espécie de concreto ou eu quero que isso seja uma espécie de concreto que você vai e então ele vai preencher isso também. Então, isso funciona muito bem. Então isso já é muito legal. Agora. Talvez, oh cara, querido, o que queremos é uma rua, certo? Então nós estamos tipo, ok, vamos realmente construir uma rua. Vamos ver se conseguimos fazer isto. Então, isto é, a propósito, um botão do meio do mouse e o botão direito do mouse podem se mover. E, em seguida, com o botão esquerdo do mouse, você pode basicamente selecionar coisas. Ouvi dizer que temos algum resto da rua de asfalto aqui. E assim poderíamos, por exemplo, dizer, bem, vamos realmente pegar este asfalto e vamos fazer uma rua como bem no meio aqui. Na verdade, estou me certificando de que também selecionamos isso. Vamos fazer uma rua aqui no meio. Isso é muito legal. E então tudo o que poderíamos também ter esse tipo de sólidos ou podemos realmente adicionar isso também. Lá vai você. E então podemos fazer isso. E então vamos adicionar tudo, sim, e agora todos sabemos que temos participação mínima. Nós também vamos fazer o Controle Z, é claro, para fazer isso, ou podemos, claro, pintar sobre ele ou fazer isso em todos. Vamos também colocar um desses aqui. Então isso é muito legal. Agora podemos cruzar isto. E bem, talvez o que temos aqui também seja um não, talvez isso não funcione bem. Então vamos ver. Sobre o que, ok? Então, como você pode ver, às vezes é um pouco mais difícil fazer isso, mas você pode ver que este é realmente bom para o canto que eles são. E então você pode fazer um canto colocar bem aqui, e então continuar com isso. Junto. Lá vai você. Então há muitas coisas que você pode fazer com isso. E, claro, isso agora é uma espécie de exemplo ativo de um conjunto de mosaicos específico. Mas você pode ver que depois de um pouco, ele também já toma um pouco de forma. E digamos, Bem, na verdade, o que eu realmente quero é que eu realmente quero uma espécie de benzeno, esta área verde, mas isso é meio que não é muito bom, certo? Então agora o banco é, bem, o Mencius tipo de sentado no espaço. Então isso não é muito legal. Exactamente. Vamos, na verdade, controlar Z para voltar aqui. E, e a razão para isso é porque estamos agora usando este mapa de mosaico que está bem aqui. E a ideia é que, bem, isso não é suficiente. Na verdade, precisamos de mais. Então o que queremos é que não queremos editar isso. O que queremos é que realmente queremos outro mapa de mosaico que está abaixo deste. Então o que poderíamos fazer é basicamente dizer, ok, vamos apenas pegar este mapa de mosaico e então vamos apenas controlar uma escritura duplicada e, em seguida, chamar o outro, por exemplo, base. Então agora e mova isso para cima. Pessoalmente, prefiro isso. E, em seguida, dizer negativo, na verdade movê-lo para baixo porque. Oh, mas certifique-se de que está abaixo da grade. Isso é muito importante. Então este é para baixo e então nós temos talvez algo como o meio. E depois duplicamos essa outra vez. E então temos algo no topo, que vai ser o primeiro pedido. Certo? E agora temos três camadas diferentes. E agora, se olharmos para o mapa de mosaico ativo, podemos realmente ver que podemos escolher diferentes aqui. Então, primeiro de tudo, certo, agora os dados em todos eles serão os mesmos. Então, vamos realmente fazer o seguinte. Vamos apagar tudo o que pudermos. Faz com que pareça um grande. A liderança, lá vai você. Então, agora a camada base é excluída. Vamos para a camada superior. A camada superior é excluída. E agora, se eu fosse fazer isso, agora a camada do meio é excluída. Vamos ver. Agora tudo se foi. Então eu posso mudar a seleção com fazer este ano, top, médio e base. Ou se eu voltar a ter o, lá vai você. Então agora a base tem algo nele e também mudá-lo aqui. Então topo, base e meio. E agora porque definimos a ordem na camada, que já vimos dentro da amina inúmeras ocasiões, especialmente dentro do roteiro. Desculpe, o renderizador de sprite. Sim, lá vai você. Sabemos que bem, isso ordena os sprites reais. Se eu agora quiser adicionar este banco, como você pode ver agora ele é sobreposto em cima da camada base porque estamos agora na camada do meio. Se voltarmos para a camada base, como você pode ver, substituiria essa camada base. Mas na camada do meio , não o substitui. E nós podemos simplesmente adicionar este belo ano de banco, talvez dois bancos, e então também talvez adicionar uma pequena árvore agradável também. Então nós podemos, por exemplo, pegar este e, em seguida, apenas adicionar uma árvore aqui e H3 aqui, por exemplo. E então vamos terminar isso só para que pareça um pouco mais agradável. Assim que temos, eu sou uma espécie de área verde bem ordenada com dois bancos e uma árvore aqui. E depois lá. Nós também podemos ter isso e, em seguida, ter uma área pouco agradável eles são também. Lá vai você. Este, este. E então vamos terminar com a parte de cima também. E agora temos duas áreas. Como pode ver, o que fizemos? Bem, nós realmente fizemos uma parte completa porque nós fizemos tudo isso na camada intermediária, o que é claro que não é bem o que nós queríamos. Tudo isso deveria ter entrado na camada base. Então é uma dor real é que não podemos realmente mudar isso. Infelizmente, o que podemos fazer é basicamente por que estamos selecionando isso e, em seguida, também mantendo o controle pressionado. Então o controle e, em seguida, selecioná-lo vai realmente meio que fazê-lo para que possamos pintá-lo como você pode ver. Então podemos mudar para a camada base. Podemos pintá-lo na camada base. E então, na camada do meio, teríamos que excluí-la novamente. É um pouco sim, não é muito bom que isso funcione. Como isso funciona, mas é assim que vamos fazer. Não há nenhuma maneira real de mudar as camadas que são. E também o que eu queria mencionar, enquanto eu estou chamando essas camadas, Unity chama esses mapas de mosaico. Linguagem totalmente confusa como essa é, eu acho que essa não é uma linguagem muito boa porque, por alguma razão, você sabe, este é um conjunto de azulejos. Então este é um conjunto de títulos e, em seguida, este é o mapa de mosaico também. Então isso é chamado Telnet porque eu cito The My, vamos ver, sprites aqui, mapa de mosaico. Mas eu definitivamente me referiria a isso como camadas. Então essas são camadas diferentes que você pode colocar um em cima do outro. Mapa da telha, eu acho que não é o termo certo lá. E sim, vamos fazer o mesmo aqui também. Então vamos copiar este. E isso é realmente copiar a camada base. Queríamos copiar isto. Agora, os grandes problemas que todos sabem, agora o que nós fizemos é que eles também são as árvores lá. Então esta é uma coisa que eu meio que queria mencionar também. Às vezes pode acontecer que você é um, você tem a camada errada selecionada e, em seguida, você tem que refazer isso. Eu definitivamente recomendo ter certeza de que você está na camada certa como esta é uma das coisas mais importantes se você está trabalhando com isso. Porque senão vai levar a muitas dores de cabeça. E pode ser no começo, você sabe, um pouco tedioso, um pouco meio áspero. Não, estou na camada errada de novo. Está prestes a acontecer em algum momento e é assim que vai ser. Então vamos apenas adicionar algumas árvores aqui, talvez outra árvore que eles são, eles vão. E depois terminamos o nosso mapa. Não é o mapa mais bonito no momento, mas é claro que podemos fazer algumas coisas legais com isso. Um dos exemplos disso seria, vamos ver. Então, se você realmente baixar isso e você está indo para obter outro mapa e eu vou rapidamente mostrar-lhe isso também. Então isso é, então é uma espécie de uma pequena espreitadela em outro mapa que eu fiz. Apenas um exatamente para isso. E isso está acontecendo, e isso também é algo que vamos usar na próxima palestra também. E isso parece algo assim. Então esse é o outro mapa que eu fiz que, você sabe, isso é muito legal. Considerando tudo, você sabe, nós temos algumas pessoas mesmo se você carros, alguns bancos. E então nós podemos ter alguns nós realmente não temos nenhum top para os edifícios neste caso, mas apenas plana. Mas quem sabe, talvez isto seja uma espécie de palco sonoro. Mas sim, esse é um dos exemplos que eu fiz também que está disponível para download, que também vamos usar na próxima palestra. Então, sim, isso seria tudo para esta palestra agora, uh, com os conjuntos de azulejos, realmente não há. É que a tua criatividade é basicamente o que te impede de fazer qualquer coisa. Nas ferramentas há realmente útil, realmente grande, e pode ser usado para todos os tipos de outras coisas. E sim, isto é, é basicamente para esta palestra no momento. Espero que você tenha achado isso útil e você aprenda algo novo. Mapas de mosaico, um grande conjunto de ferramentas Sue e mapas de teste, uma ótima ferramenta para basicamente criar seus próprios níveis. Receba quaisquer perguntas, permaneça, então, é claro, sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 90. (Unity intermediário: Tudo bem, vamos continuar a seção intermediária da unidade aqui para o curso da unidade. E nesta palestra vamos dar uma olhada rápida em animações e como fazer animações. Então, as primeiras coisas primeiro, com nosso novo mapa que você, é claro, pode obter para o recurso. Especialmente nesta palestra. Deve haver um recurso para o pacote onde apenas o novo conjunto de mosaicos está localizado. E também, é claro, o bloco se define e, em seguida, os sprites associados a ele. Se você quer isso, você não precisa necessariamente ter isso. Seus próprios azulejos que funcionariam bem. Ou o seu mapa antigo, talvez até o que usamos antes. É apenas uma espécie de show agradável visualmente quando estamos olhando para nossas animações agora. Então vamos duplicar este mapa título e vamos fazer 10 animações. Então vamos renomear isso para L dez animações e também começar isso. E então vamos importar um novo sprite. É claro que isso também está disponível. Este será o brilhante aventureiro. Então isso está lá. E, em primeiro lugar, isso terá de ser mudado um pouco. Nós vamos precisar realmente não muito, Eu acho que só ponto e, em seguida, nenhuma compressão aqui. E depois, claro, múltiplo porque esses são múltiplos novamente. Então vamos ao Sprite Editor. Deixe-me levar isto rapidamente para cá. E o tamanho deles é 80 por 110. E então vamos cortar isso e como você pode ver, se encaixa perfeitamente lá. E então temos o tamanho para cada um deles. E o que vamos fazer é basicamente fazer uma pequena animação de caminhada, bem como uma animação ociosa. Então, esses não vão ser muito loucos. No entanto, eles serão semi-funcionais, pelo menos, digamos, e então vamos ver o que isso implica. Então, vamos aplicar isso. Então, mais uma vez, temos o aventureiro e todos os vários sprites em particular abaixo dele. E então nós realmente precisamos de janelas específicas. Precisamos da animação aqui, Janela de Animação. E isso aberto em outra tela. Podemos simplesmente colocar isso aqui. E então também precisamos de animação e a janela do animador. E eu também coloquei pessoalmente isso aqui para que eu tenha basicamente o animador e a janela de animação aqui embaixo diretamente onde o console está. E a primeira coisa que podemos fazer é basicamente, bem, podemos selecionar uma imagem diferente aqui. Vamos realmente colocar este para que possamos realmente ver que imagem é esta. E a animação vai basicamente mudar entre 02 aqui. Não é a melhor animação ociosa para esta coisa em particular. O que eu acho que, isso, que realmente funciona bem e eu especialmente gosto do olhar louco louco neste rosto. Então isso é realmente muito engraçado. Então o que você pode fazer é o que nós aprendemos é que se você apenas tirar uma foto lá, então um sprite, então ele apenas cria um objeto de jogo. No entanto, se o fizermos também, então selecionamos dois sprites aqui. Então, por exemplo, Tchau. Selecionando um deles e, em seguida, pressionando Control e, em seguida, o outro, podemos selecionar dois diferentes. E se eu puxar esse para a visão da cena, então, como você pode ver, uma nova janela aqui se abre. Diz para criar uma nova animação porque neste caso, ele realmente quer que criemos uma nova animação. E isso é o que vamos fazer em uma espécie de pasta de animações. Vamos chamar isso de jogador ou vamos chamar isso de “aventuras cruas”. Aventura na marcha lenta ventral. Porque esta é a animação ociosa. E vamos salvar isso. E agora um monte de coisas foram feitas por nós. Então, se formos para a nossa pasta de animações, você pode ver que o sublinhado de aventura 0, um controlador de animação foi criado, bem como o clipe de animação ociosa aventureiro. E o clipe de animação é o que é muito interessante para nós e o que poderemos ver no animador, por exemplo, se selecionarmos nossa aventura aqui é um, sim, Bem, uma espécie de resumo de nossas animações que temos. E cada uma dessas caixas basicamente. Então há algumas caixas especiais diferentes, a entrada, este é um tipo de onde ele sempre entra. Há qualquer estado, então qualquer estado que a animação real e animação pode tomar. E depois há uma nota extra também. E a ideia é que o que queremos definir neste animador são basicamente as transições entre diferentes estados. Então você pode, por exemplo, imaginar isso. Se eu estiver parado agora. Por isso, neste momento, está parado. E então nós tocamos a animação, certo? E então ele, eu não sei, balança da esquerda para a direita e esquerda, direita. E então desta nação insular, talvez eu possa pular ou andar. E então o, podemos basicamente dizer, ok, temos uma animação ociosa, temos uma animação de caminhada, e talvez até mesmo uma animação de salto. E então queremos definir transições diferentes como esta, direito, clicando com o botão direito do mouse e, em seguida, fazendo uma transição lá. Agora não vamos fazer isso agora porque nós realmente vamos fazer a segunda animação em pouco tempo. Mas todos esses nós, então cada um desses nós, cada uma dessas animações tem basicamente uma linha do tempo, você está conectado a ela. Então, se eu clicar no ídolo de aventura aqui, então você vê dentro da janela de animação, agora temos esta linha do tempo. E essa linha do tempo muda atualmente. Uma coisa só. Então talvez você tenha trabalhado com, você sabe, talvez com o Premiere Pro ou algum outro programa de edição de vídeo ou talvez tenha visto fotos dele. Isto é basicamente onde podemos definir quadros-chave. E a idéia é que nós podemos tipo de adicionar coisas a esta animação que nos permite basicamente mudar certas coisas. Então, se eu selecionar nosso romance de aventura novamente, então você pode ver que eu tenho este clipe ocioso de aventura agora selecionado. E atualmente o que está mudando é o sprite. Então, como você pode ver no momento 000, o sprite é este. E então, se eu mover isso junto, então o sprite muda para isso no próximo segundo. Agora, se eu fosse jogar isso, então como você pode ver, é assim que a nação insular olharia é claro, muito rápido, certo? Porque tem apenas dois quadros. E isso não seria muito bom. Assim, podemos diminuir o zoom com apenas um mouse rolando para baixo. E podemos olhar por aqui com o botão do meio do mouse e então podemos pegar um desses quadros-chave. Então, por exemplo, este, o segundo. Foto aqui. E podemos arrastá-lo para ser, por exemplo, algo como, bem, digamos cinco quadros. Então, se eu tocasse este clipe agora, como podem ver, agora, ele aceitaria e ficaria por cerca de um quadro. Mas isso também não é bem o que eu quero, certo? Porque agora este em particular só é mostrado para cerca de um quadro e, em seguida, ele retorna para o outro. Então isso pode não ser o que queremos. O que queremos é que fique assim por um tempo, mais tempo. E bem, como podemos conseguir isso? Bem, talvez por exemplo, pegamos isso e então podemos, a propósito, copiar algo, então Controle C. E então se eu for, por exemplo, até aqui, posso colocar o controle V e colá-lo. E agora, em teoria, digamos que eu coloquei aqui. Então agora ele iria ficar lá para um número de quadros. Então isso seria mais seis quadros, eu acho. E vamos dar uma olhada nisso agora. Agora seria assim. E isso é mais como uma animação da Ilha. Agora não é a melhor animação ociosa. Como eu disse, é um pouco confuso, mas será suficiente por enquanto para que tenhamos qualquer coisa. Então isso é uma coisa boa. Agora você poderia, é claro, fazer assim, muito mais rápido ou mais lento assim. Você poderia fazer isso um pouco mais ou menos dependendo do que você gostaria de fazer, certo? Podemos arrastar este ano ou tornar isto um pouco mais lento ou mais rápido. É claro que depende de você mais uma vez, eu só estou fornecendo as ferramentas. O que você faz com eles depende de você. Mas o que podemos fazer agora é também em outras propriedades. Então, se eu colocá-lo nas outras propriedades, você pode ver que basicamente existem, eu acho que todos eles, ou pelo menos certos componentes estão disponíveis aqui para eu mudar. Como você pode ver, basicamente tudo que eu posso mudar dentro do renderizador sprite. E então eu poderia também, em teoria, mudar as coisas na transformação para uma animação. E isto é uma coisa muito fixe. Assim, você pode mudar certas coisas em função do tempo quando uma animação é reproduzida. Agora mudar a transformação às vezes não é muito bom. Eu só queria mencionar isso porque pode ter efeitos obscuros, especialmente se você está mudando de posição com outras coisas. Então, normalmente você deve ter cuidado com isso, exceto se você tivesse espécie de componente visual de um objeto de jogo específico ser diferente da posição real. Então, se você tem uma espécie de, eu sou uma criança e um objeto de jogo pai, então pode haver uma maneira de isso funcionar. Sim, e então vamos dar uma olhada no outro. Então o outro através da animação ambulante que eu gostaria vai ser também dois diferentes. Isso vai ser nove e dez, eu acredito. Então nove e dez, essa é a animação ambulante que eu quero colocar. E há várias maneiras de fazermos isso. Ou nós também podemos arrastar isso para dentro ou o Y não recomendaria que o que eu recomendaria é simplesmente ir aqui e dizer Criar novo clipe. E depois vamos dizer em Ventura. Caminhe e guarde isso também. E agora se eu selecionar esta aventura novamente e a aventura, uma caminhada está aqui, e então eu posso basicamente arrastar sobre nossos sprites individuais. Eu também poderia dizer na propriedade sprite renderer e, em seguida, dizer sprite plus. Então agora o sprite vai mudar. Então eu vou colocar o nove aqui e depois o 10 também. Nós não queremos essa. Na verdade, vamos mantê-la assim. Então, na verdade, eu também não quero que ele fique de pé e depois muda para andar. Eu realmente quero que eles comecem com a caminhada e depois mudem para este. E então mude para a posição de caminhada novamente. Então, algo assim. Então vamos ver como isso ficaria. Bem, isso já é uma animação ambulante. Um pouco rápido demais, então vamos torná-lo um pouco mais lento, talvez algo assim. Então, 15 quadros. Isso provavelmente seria bom. E isso já funcionaria bastante bem. Então vamos guardar isso por enquanto. E então nós vamos realmente obter algo de uma palestra muito antiga, muito antiga aqui. E esse vai ser o roteiro do movimento. Então nós estamos realmente indo para ir para Scripts, Criar Nova Pasta, Elton animações. Isso vai ser os roteiros dos movimentos, certo? Vamos pegar o roteiro do movimento aqui. E vamos ver. Ele só vai recarregar por um momento e então eles iriam, Vamos abrir isso também. E vamos adicionar isso rapidamente ao nosso aventureiro também. Lá vai você. No guião do movimento. Deixe-me trazer isto rapidamente para aqui e então podemos dar uma olhada nisso. Então isso simplesmente nos permite mover nosso personagem, e agora nós vamos realmente adicionar outro componente aqui. Então outro campo que vai ser o animador. Este é o Animador. Agora, felizmente, porque este é no mesmo objeto de jogo, podemos simplesmente dizer que este ponto obter animador componente. Então isso é realmente muito fácil. E então o que vamos fazer é fazer o seguinte. Então, quando estamos dentro do nosso método basicamente mover. E mais tarde na indireção, o que eu quero é que eu quero tipo de definir um componente de velocidade, bem como eu quero inverter os componentes visuais. Então, se eu escrever agora, se eu fosse apenas começar isso, o que vai acontecer é o seguinte. Ele está indo para ir. Se sim, lá vamos nós. Agora começou, ele só vai ter a animação ociosa e agora eu posso andar, mas a animação ociosa ainda lugar, que é claro, isso não é bem o que eu quero. A razão pela qual a animação ociosa é reproduzida. Se eu for ao animador, como podem ver, o ponto de entrada é onde começamos. E então temos uma transição para o ídolo da aventura aqui. E, em seguida, nada para a animação de caminhada. Não sabemos quando devemos andar animação deve ser tocada. Portanto, nós realmente não fazemos nada aqui. E como podemos consertar isso? Como podemos fazer certas coisas jogarem? Bem, podemos fazer certas coisas jogadas fazendo o seguinte. Podemos definir parâmetros e que é à esquerda aqui. Em vez de selecionar jogadores, podemos selecionar parâmetros. E esses parâmetros são basicamente, bem, eles podem ser de diferentes tipos. Então flutuar e inteiro, um touro ou um gatilho. Nós vamos selecionar um flutuador neste caso, e este flutuador vai ser velocidade. Então esta é a velocidade em que este personagem se move. E dependendo da velocidade, vamos fazer a transição para a animação de caminhada ou vamos fazer a transição de volta. Então essa é basicamente a idéia lá. Então vamos clicar com o botão direito do mouse no ídolo da aventura aqui e fazer a transição e, em seguida, movê-lo para a aventura, uma caminhada. E se agora clicarmos nesta pequena seta, você pode ver que há algumas coisas aqui e podemos até ver uma prévia. Então este deve andar e então ele muda para uma animação ambulante. Agora, isso não é bem o que queremos. Nós também podemos tipo de expandir as configurações aqui. E isto é uma espécie de, esta é uma duração de transição aqui. Então estamos basicamente olhando para uma transição de um para o outro. Agora, o que eu pessoalmente acho é que nós realmente não queremos um tempo extra e nós também não queremos uma transição aqui. Na verdade, só queremos que ele mude. E vamos ver o que este diz. Isto não tem tempo extra. Sim. Ainda não temos nenhuma condição lá. É por isso que estamos recebendo esse aviso aqui. Nós vamos colocar em uma condicional em breve o suficiente. Então, sem tempo de saída e sem, bem, sem tempo de saída e sem duração. E agora temos que especificar uma condição. Então, se não temos tempo extra, então temos que ter uma condição. E a condição vai ser velocidade vai ser, quero dizer, eu acho que apenas maior do que 0,01. Na verdade, isso é tudo o que eu quero. 0,1. Vamos fazer 0, 0, 1, o ego. Então isso é tudo, realmente um. Assim que a velocidade for mais de um, então eu quero a animação da OIT também, um cruzamento para a animação de caminhada. E então eu também posso dizer, bem, se estamos na animação de caminhada, talvez em algum momento eu queira voltar para a emissão da ilha. Então, se eu basicamente parei de me mover, e isso basicamente vai acontecer se eu entrar aqui e mais uma vez, eu entrar no, Eu adiar o tempo extra e sem duração fixa, sem transição para a duração. Na verdade, desculpe, a ração fixa está correta, mas não há duração de transição lá. Então, mais uma vez, eu recebo o aviso a, Eu preciso de uma condição e isso é simplesmente vai ser velocidade é inferior a 0,01. E isso seria tudo para eles. Assim que definirmos a velocidade , podemos basicamente controlar em que animação nosso personagem encontra. Agora, essa velocidade não precisa necessariamente se correlacionar perfeitamente com nossa velocidade que o jogador realmente tem. Assim, agora seremos capazes de definir a velocidade de uma maneira particular. Então, se olharmos para o seguinte, então o que podemos fazer é quando estamos dentro do nosso método de movimento. Então isso pode ser colocado em qualquer lugar. Mas se formos, vamos fazer o seguinte. Vamos, na verdade, fazer isto. Então, dentro do nosso animador, no início, animador ponto set float. A velocidade vai ser 0 F. Então isso é tão simples quanto isso vai. Então nós simplesmente temos o nome da variável real, bem como, então, o que, onde quer que nós definimos para. Agora estamos definindo isso no início, e então também estamos definindo isso. Por exemplo, se nos movermos em qualquer direção. Agora a coisa sobre isso é que nós poderíamos, claro, definir isso para a direção específica que estamos nos movendo. Então poderíamos dizer, “Ei, queremos que isto seja qualquer que seja a direção, vezes a velocidade. E então tem uma velocidade negativa. Nós movemos para o, para a esquerda e depois o positivo se você mover para a direita e assim por diante e assim por diante, nós não vamos fazer isso. Vamos apenas configurá-lo para si mesmo agora para que seja positivo quando nos movemos. E então, é claro, também temos que reiniciá-lo de alguma forma para que isso funcione bem. Então, enquanto este funciona no início, ele meio que não funciona mais tarde na linha. Então o que provavelmente queremos é que provavelmente queremos que isso seja chamado dentro do método de atualização. E sim, para que isso aconteça. E quando não estamos nos movendo, no entanto, para onde queremos que isto seja definido no início aqui, que não interfira em nada. Agora há várias maneiras, é claro, mais uma vez, onde poderíamos fazer isso com. Poderíamos, por exemplo, dizer, bem, talvez se eu não estiver me movendo, então definimos o e definimos a velocidade como 0. Também como esta velocidade também poderia ser definido como 0, algo assim. Mas isso vai ficar bem. Isto vai funcionar. E então também vai haver um visual de flip vazio privado, que nós já vamos implementar. Então esta é a direção aqui, sem direção. É assim que eu quero chamá-lo. E não vamos colocar nada aí agora, porque eu vou te mostrar por que precisaremos disso em um momento. Mas neste, com esta configuração, sem o flipping, o visual, isto já deve funcionar totalmente bem. Então vamos ver se esse é realmente o caso. Então, às vezes também pode ser útil porque agora temos o animador e as animações em nosso roteiro de movimento também. Às vezes, poderia ser melhor se nós realmente os separássemos, mas isso não é estritamente necessário. Por isso, neste momento estamos na nação insular. Tudo está funcionando muito bem. E se eu me mover e como você pode ver, nós mudamos imediatamente para a animação de caminhada. Agora, nós somos uma espécie de Moonwalking aqui. Deixe-me maximizar isso para que possamos realmente ver o que está acontecendo. Para que possamos andar. E então se eu andar para a esquerda que não, nós estamos andando na lua. Então estamos trabalhando no tipo de, você sabe, atrás de nós, que é claro que não é bem o que queremos. É por isso que eu disse que podemos inverter o valor x aqui e, em seguida, simplesmente inverter o renderizador sprite sobre. E isto é o que vamos fazer com este método flip aqui. O visual flip simplesmente vai dizer este ponto obter componente sprite renderizador. Flip x é igual à direção ponto x é menor que 0. Então o flip x é simplesmente um bool. E direção y é, bem, ou vai ser um ou 0. E se for, sim, exatamente porque o movimento para a esquerda, então este é negativo. Então sim, está abaixo de 0. Portanto, flip x vai ser verdadeiro, e caso contrário ele vai ser falso. Então agora aqui, vire a direção visual que você vai. Claro, para ser franco, a melhor coisa a fazer aqui é, naturalmente, também dizer fazer este renderizador sprite privado. Renderizador de sprite ativo. Na verdade, configure isso aqui porque vamos, vamos fazer isso corretamente, como é suposto ser feito. Caso contrário, por que se preocupar com isso? Lá vai você. Sprite renderer dot flip x. e agora tudo está bem. Então não faça o componente get chamado aqui. Como já disse várias vezes. E agora ele deve virar o visual se estamos nos movendo para a esquerda. E agora devemos realmente ter uma animação bastante bem viável. Então a eliminação, como eu disse, não é a melhor, mas se estamos indo para a direita, isso funciona. E se nos movermos para a esquerda, isso também funciona. E então ele também vira a imagem ao redor. E a grande coisa sobre isso é que ele também permanece lá. Então essa é uma espécie de maneira que você poderia fazer isso. Agora, se eu mover para cima ou para baixo, então a imagem real girará de volta para a direita. Mas isso é uma coisa muito pequena que realmente deve ser consertável muito facilmente, certo? E sim, isso seria na verdade para a ideia das animações. Então há muito mais, é claro, mais uma vez, para ser feito em animações, certo? Como de costume, estes são olhares muito grosseiros de muitos sistemas porque ele tem tantos sistemas para oferecer. É muito difícil porque, quero dizer, cada um dos sistemas provavelmente poderia ser seu próprio curso em seu próprio direito. Quero dizer, a maioria deles, eu só estou pensando sobre o sistema de partículas mais uma vez. Então esta é uma espécie de uma primeira olhada nas animações. Há coisas incríveis que podem ser feitas com ele e a ferramenta é incrivelmente poderosa, como você viu. Há tantas coisas que você pode mudar com a animação aqui, bem como o animador oferece tantas coisas para ser feito. E a melhor coisa, como eu disse, que posso deixar vocês mais uma vez, é experimentar tudo o que vocês pensam. Então qualquer um, deixe sua criatividade correr completamente selvagem e apenas experimentar algumas coisas e ver se você pode obter algo para funcionar. E sim, só brinca com ele. Essa é sempre uma ótima ideia. E isso seria realmente para a animação neste momento. Como sempre, espero que você tenha achado isso útil e você aprenda algo novo. Eu gostaria muito de uma crítica sua. E se eles permanecerem quaisquer perguntas, é claro, sempre sinta-se livre para perguntar e eu vou ter certeza de responder. E sim. 91. (Unity intermediário: Tudo bem, vamos continuar com a seção intermediária da Unidade aqui para o curso da unidade. E nesta palestra, vamos dar uma olhada em objetos de script. Objetos com script são um tipo específico de contêiner de dados. Portanto, há uma maneira de armazenar dados que é independente de uma determinada classe basicamente. E o que isso significa? Bem, vamos dar uma olhada nisso. E para isso vamos criar uma nova cena. Claro, isso será objetos de script L 11. Lá vai você. Então vamos abrir essa cena. E então nós também vamos criar uma nova pasta de scripts. Isso vai ser L 11 objetos capazes de script. Agora vamos precisar de dois scripts para este, este vai ser o script C-sharp, cartão de jogo, cartão de jogo. E depois outro script “C Sharp”. Vamos, na verdade, fechar de todos esses. E então vamos fazer outro. E este vai ser o script cartão de jogo objeto capaz. Agora você também pode chamar esse clique art. Então eu acho que chamá-lo tocar acordes, objetos programáveis, objetos é realmente errado. Vamos realmente excluir isso novamente e tornar esses objetos de script. Porque esse é um nome melhor. Objetos de script seria um pouco estranho tê-lo nomeado no plural. Então Play Card, cartão de jogo, script, capaz, ejectar. Lá vai você. E isso seria bom. Então vamos abrir cada um deles. Então, a carta de jogo e os objetos programáveis. E então podemos pensar ou para nós mesmos, bem, o que poderia uma carta de jogo metade? Então, em nosso exemplo, o que gostaríamos é que queremos uma espécie de nome de cartão e talvez, você poderia imaginar talvez HB e quantidade de valor. Então algo que seria semelhante a uma espécie de carta de jogo, eu não gosto de Magic The Gathering ou Hearthstone ou algo assim. E a primeira coisa que vamos fazer é que vamos, em vez de herdar do comportamento motor, vamos herdar de objetos programáveis aqui. E isso basicamente nos permitirá criar algo realmente agradável e legal. E a próxima coisa que queremos aqui é acima da classe pública, nós realmente queremos os colchetes aqui e dentro lá queremos criar o menu Ativo, nome do arquivo é igual a cartas de jogo. Então este é o, basicamente o nome do nome do arquivo que vamos criar e, em seguida, o nome do menu vai ser cartão Palais. Vamos ver o que isso faz daqui a pouco. Primeiro de tudo, vamos pensar sobre isso. Então, os dados que queremos exibir objetos de script do tribunal para ter é, por exemplo, um nome, então o nome do cartão. Queremos que haja um, um inteiro, por exemplo, HP e uma maneira de cartão. Então vamos fazer MP, na verdade chamado MPI e, em seguida, também talvez mudar o sprite. Então este seria um sprite de cartão que também poderia ser salvo em uma espécie de objetos com script. Então está tudo bem, mas o que isso nos dá? O que isso faz para nós agora? Bem, agora não tem. Muito para nós, mas o que podemos fazer agora, e isso vai ser uma coisa muito legal. Podemos clicar com o botão direito em nossa pasta. E então podemos ir para o menu Criar. E no topo você vai ver, oh, o que é isso? Jogar cartão é uma coisa nova que podemos adicionar agora. E isso irá adicionar um objetos de script. Como você pode ver, esta é uma peça chamada objetos de script. E agora podemos mudar isso para o que quisermos. Então, por exemplo, podemos dizer, bom, ás, ás de copas é o nome do cartão. Por exemplo, você poderia dizer, bem isso tem 10 HB e 25 maneira. E então nós também podemos adicionar um sprite cartão aqui. Então podemos ir até nossos tribunais, por exemplo, e então simplesmente adicionar o tribunal 0 porque esse é o ás de copas. E, no entanto, agora temos um novo cartão. Então vamos chamar este ás de copas também. Então este seria um dos possíveis objetos de dados que o objeto real pode tomar. Então, vamos também construir um bom lugar de um objeto que com o qual podemos basicamente visualizar isso. Então vamos pegar o acorde 0 aqui e vamos chamar isso de “cartão de jogo”. E então nós vamos adicionar uma tela a ele. Então, na verdade, vamos apenas adicionar o texto Mesh Pro a ele. E esta tela então será realmente no espaço do mundo desta vez. Sei que é uma loucura, claro, ainda com a câmera principal. E então teremos também dois localizados em que e torná-lo um pouco muito menor. Então vamos fazer um 100 por 100 por 100 por agora. Mesmo com o texto que vai ser um pouco menor. Vamos fazer o texto um pouco menor aqui por enquanto. E então vamos reduzir o tamanho. E então podemos descobrir isso. Então, na verdade, vamos também reduzir isso um pouco. Vamos fazer isto 0.5.5. E estamos começando a chegar onde queremos que seja, 0.5.05.05. Agora vamos lá. Certo, então agora o Canvas 000 está no tamanho que queremos. Então podemos colocar o texto aqui em cima. E então nós podemos realmente torná-lo maior novamente, pelo menos um pouco. Lá vai você. Então, isso seria bom. Eu acho que se vamos torná-lo tamanho automático, que realmente não funcionou bem como eu queria que ele texto auto tamanho. Qual é o tamanho mínimo lá? Essa é provavelmente a razão pela qual não funcionou. Lá vai você. É 18, é claro, faça este 10. Então vai estar lá. Então este é o nome do cartão que queremos. Nós queremos isso basicamente tipo de nos lados do cartão como aquele e, em seguida, será o nome do cartão. Isso é bom. Na verdade, isso pode ser um pouco menor. Então isso pode até ser, digamos um oito. Então também centroide. Então isso é meio legal. E então nós podemos basicamente copiar isso, por exemplo, aqui em baixo, só para que nós tenhamos isso. Podemos fazer da HP e da maneira de valor algo aqui e depois aqui. E então, claro, certificando-se de que nós realmente renomeamos isso, então este texto de nome de cartão, vamos chamá-lo assim. Sim, este é o texto do acorde e este é o cartão de texto AMP, por exemplo. E então isso seria, vamos apenas colocar em um, você sabe, algo como dez aqui. E um 10 aqui. Só tem algo aí dentro. Sim, seria isso. Então, é claro, quando estamos no jogo, os aparelhos seriam desligados. Então isto é o que veríamos para este cartão. Então isso é muito legal. E agora, basicamente, o que vamos fazer é primeiro anexado aos scripts de acordes reais para ele. Então nosso script que nós fizemos não os objetos programáveis, mas o comportamento moral que nós realmente não mudamos ainda e será o que ele é. Basicamente podemos, seremos capazes de colocar em dados. Eles são objetos de script diferentes, um dos que já criamos, então vamos apenas, para o inferno, criar outro cartão de colega aqui. E isso vai ser para o rei de copas. E o rei de copas. Isso vai ser como uma espécie de bonito, claro, primeiro de tudo, rei de copas, o nome do cartão e então isso vai ser como 25, cerca de 150 maneiras. E o rei de copas é o 12º ano, então isso é muito bom. Então vamos voltar para o Rei de Copas 12. Vamos arrastar isto. E agora temos dois exemplos. Assim, o ás de copas e o rei de copas. E agora, é claro, ainda precisamos adicionar a funcionalidade para o próprio coração do lago, é claro. E isso vai parecer algo assim. A primeira coisa que vamos ter é um cartão de jogo privado, objetos programáveis, jogar acorde objeto script faz os dados do tribunal, é claro, certo, então estes são os dados do acorde específico que está sendo exibido. Vamos apenas adicionar um campo serializado a ele para que possamos basicamente configurá-lo com, você sabe, no construtor. E então nós também teremos usando t, usando linha tmp. Vamos ter um TMP privado, txt, TMP SMS. Lá vai você. Vai haver o texto do nome do cartão. E então vamos copiar isso. Nós também temos um, um texto HP para texto HP. E então vamos também fazer um texto vazio. Vamos também serializar aqueles apenas que nós podemos ver o que eles estão fazendo basicamente. Agora, esses podem ser, é claro, também definidos através do método de início. Mas nós vamos realmente fazer isso dentro do construtor também. E então o que podemos dizer é que basicamente vai conjunto privado vazio, definir cartões para basicamente cartões dados. É um método que vamos chamar. E, em seguida, dentro de lá, vamos dizer obter renderizador de sprite componente. E estamos porque só vamos fazer isso uma vez no método da loja. Na verdade, não precisaremos ser capazes de pegar isso, então vai ficar tudo bem. E eu vou dizer texto de nome do cabo. O texto é, o texto na verdade é igual aos dados do cartão, ensinou a coordenada do ponto. E então vamos apenas copiar isso sobre os textos da HP aqui. Simplesmente igual a dados do cartão ponto-ponto tribunal HP e MP texto é igual a cartão mp. Agora isso é claro ToString porque esses são valores inteiros aqui e eles têm que ser definidos como string. E então podemos basicamente chamar OnStart o cartão definido para dados do cartão. E poderíamos, por exemplo, também ter em teoria um do, fazer um método de atualização e ter um ponto de entrada. Keydown, keycode.edu para atualização, por exemplo. E, em seguida, também chamar esse método que eles são. E, em seguida, basicamente, atualizar o que para qualquer dado que temos colocado lá. Portanto, isto já deve funcionar muito bem. Então vamos ver. Primeiro de tudo, é claro que temos que definir os textos aqui, então o texto do nome, HP e MP texto. E, em seguida, dar-lhe também um de nossos objetos de script. Vamos colocar o rei de copas em primeiro lugar. Então isso deve mudar. Então vamos começar a cena ou amaciar o jogo. Como você pode ver, rei de copas, o rei de copas, brilhante aparece com 25 HB e uma maneira 150. Agora, se trocarmos o ás de copas e reprimi-lo, então ele será atualizado para o nosso novo cartão. Claro, em teoria, poderíamos fazer algo como um se os dados reais mudam, então podemos ser capazes de atualizar os visuais também. Mas isso também não é muito necessário. E sim, e agora basicamente podemos criar novas cartas de jogo aqui. Então, por exemplo, podemos fazer a rainha de paus se eu encontrar a rainha de paus. Então isso vai ser interessante. Então acredito que eram clubes. Então rainha de paus para P53, eu acredito. Então. Rainha de paus, onde está? É 53. Vamos adicionar isso como o sprite. E esta é a rainha dos paus. E isso teria talvez 65 HB e 140 MP. Então isso é um cartão muito forte. E o melhor é que agora eu posso simplesmente trocar isso aqui. E assim que eu iniciar, os dados são carregados. Neste caso, é um pouco grande demais, mas tudo bem. Isso não é um problema. Isso é algo que podemos resolver muito facilmente. Então eles são, um tamanho auto provavelmente seria melhor. Então nós podemos basicamente sobrescrevê-lo com um tamanho automático e dizer, bem, na verdade, vamos fazer um mínimo de seis e um máximo de 15, algo assim. E assim que fizermos isso, mesmo assim, quando o nome real for muito grande, ele ainda funcionará muito bem. Então isso é muito legal. Então esse é um dos tipos de coisas que você pode fazer com objetos de script. E no futuro, nós realmente vamos ver um bom aplicativo para objetos de script onde nós realmente temos vários tipos de inimigos com isso. Então objetos de script realmente agradável para armazenar como grandes quantidades de dados em, por assim dizer. E ainda assim eles são agora, podemos basicamente ter vários desses objetos aqui, armazenar diferentes tipos de dados. E com isso, eles são basicamente independentes de qualquer classe. E sim, isso seria para a palestra de objetos programáveis. Como eu disse, uma aplicação adequada que vamos ver quando fizermos o nosso próximo jogo. Mas será isso para esta palestra. Espero mais uma vez que tenha achado útil e que aprenda algo novo. Se houver alguma pergunta, como sempre, sinta-se à vontade para perguntar e eu vou ser deve responder. E sim.