Oi Francisco, você vai precisar de um terceiro objeto para guardar o placar e exibir o valor em um texto, vou dar um exemplo do que eu fiz um jogo em exemplo. No print abaixo, tem um protótipo que eu desenvolvi a um tempo atrás: http://prntscr.com/izi8la Observe, que eu tenho o personagem(a bolinha), a moeda, e o texto que exibe a pontuação, basicamente, quando eu detecto uma colisão entre o prefab da moeda e o personagem, eu chamo um método de um terceiro objeto, que guarda os dados da pontuação, e manda para o texto, esse objeto é este do print: http://prntscr.com/izi9gm Ele é um objeto vazio(Create empty), que só tem um script como você vê no print. Então seguindo essa lógica, comece criando um novo objeto vazio, com o nome de Pontuador, por exemplo. depois, nesse objeto vazio, crie um script, no meu caso eu chamei de PointsScript, e dentro desse script você vai basicamente criar uma variável para guardar a pontuação, e vai criar uma função para que a cada vez que a bala pegue no zombie, o valor do placar mude. Lembrando que eu tenho um curso onde ensino a mexer com textos, e outros elementos de interface: https://www.schoolofnet.com/curso-unity-componentes-de-ui/ , enfim, código abaixo: ```csharp using System.Collections; using System.Collections.Generic; using UnityEngine; using UnityEngine.UI; // Adicionando namespace para poder trabalhar com o texto pontuador, falo mais no curso Unity UI public class PointsScript : MonoBehaviour { // Criando minha variável que vai falar quantos pontos eu tenho public int pontuation; // Criando um campo publico do tipo texto, para receber um componente de texto public Text pontuationText; // Use this for initialization void Start () { } // Update is called once per frame void Update () { } // Função que a cada vez que for chamada vai adicionar mais 1 no placar // Essa função tem que ser publica, por que vamos chamar ela la de dentro do script // do prefab moeda public void makeAPoint() { pontuation += 1; pontuationText.text = pontuation.ToString(); } } ``` Após isso, você vai ter que chamar essa função, no meu caso makeAPoint, a cada vez que a bala bater no zombie, no meu caso, a cada vez que o meu personagem coletar a moeda. Então para fazer isso, comece adicionando uma tag para o seu objeto vazio, que você criou anteriormente, o Pontuador, no meu caso eu adicionei essa Tag: http://prntscr.com/izicbu A gente vai precisar adicionar a tag nesse objeto para poder chamar ele lá de dentro do prefab da moeda, ou no seu caso, o prefab da bala. Aqui o código da minha moeda, que detecta quando o jogador colide com a moeda: Veja o script do meu prefab moeda, que pode servir para o seu prefab da bala: ```csharp using System.Collections; using System.Collections.Generic; using UnityEngine; public class CoinScript : MonoBehaviour { // Essa variável vai armazenar o componente/script PointsScript, responsável por fazer o pontuador. // Note, que o tipo dela PointsScript, depende do nome que você deu ao seu script pontuador. // No meu caso eu dei o nome PointsScript, por isso que eu declaro ela com esse tipo. PointsScript pointsScript; // Optei por usar a função Awake aqui, mas você pode usar na start se quiser. private void Awake() { // Dentro da awake eu estou primeiramente usando o método FindGameObjectWithTag, que procura dentro da sua cena um objeto com uma determinada tag // por exemplo, o meu objeto pontuador tem a Tag PointScript // Após isso, eu estou pegando o componente PointsScript dele, que é exatamente o script pontuador pointsScript = GameObject.FindGameObjectWithTag("PointScript").GetComponent<PointsScript>(); } void Start() { } void Update() { } // Depois eu estou detectando a colissao entre o meu jogador e a minha moeda usando essa função aqui, porém você pode usar // Qualquer outro método de detectção de colisão: private void OnTriggerEnter2D(Collider2D collision) { if (collision.gameObject.CompareTag("Player")) { // Note que aqui, antes de destruir o prefab moeda, eu estou chamando a função makeApoint // Que é exatamente a minha função pontuadora pointsScript.makeAPoint(); Destroy(gameObject); } } } ``` E é basicamente só isso, essa semana, mais precisamente na sexta, vai acontecer a regravação do curso Unity + C#(O primeiro), e nesse curso eu vou ensinar a fazer a comunicação entre vários objetos.
Para programadores que não conhecem Unity
O Unity oferece suporte a C#, uma linguagem padrão do setor com algumas semelhanças a Java ou C++ Comparada com C++, C# é mais fácil de aprender. Além disso, é uma “linguagem gerenciada”, o que significa que ela gerencia a memória automaticamente para você: alocação/desalocação de memória, tratamento de vazamentos de memória e assim por diante. No geral, prefere-se C# a C++ se você quiser desenvolver um jogo primeiro e, depois, lidar com aspectos mais avançados de programação. Saiba mais Consulte a documentação de API do Unity
Toda a jogabilidade e interatividade desenvolvidas em Unity são construídas com base em três blocos de construção fundamentais: GameObjects, componentes e variáveis. Qualquer objeto em um jogo é um GameObject: personagens, luzes, efeitos especiais, adereço — tudo. Componentes Componentes definem e controlam o comportamento dos GameObjects aos quais estão anexados. Um exemplo simples seria a criação de uma luz, que envolve a associação de um componente de luz a um GameObject (veja abaixo). Ou, adicionar um componente de corpo rígido a um objeto para que ele caia. Os componentes têm qualquer quantidade de propriedades editáveis, ou variáveis, que podem ser ajustadas por meio da janela Inspector no Unity Editor e/ou via script. No exemplo acima, algumas propriedades da luz são alcance, cor e intensidade.
Os componentes integrados do Unity são muito versáteis, mas logo você perceberá que será necessário ir além do que oferecem para implementar sua própria lógica. Para fazer isso, use scripts a fim de implementar sua própria lógica de jogo e comportamento, e adicione esses scripts como componentes a GameObjects. Cada script realiza sua conexão com os mecanismos internos do Unity implementando uma classe derivada da classe integrada chamada MonoBehaviour. Seus componentes de script permitirão muitas coisas: acionar eventos de jogo, verificar colisões, aplicar física, responder às entradas do usuário e muito, muito mais. Consulte a API de scripts do Unity para obter mais informações.
O conceito tradicional de GameObject-componente continua a funcionar bem pois é fácil de entender para programadores e não programadores, e fácil de criar UIs intuitivas para ele. Adicione um componente RigidBody a um GameObject e ele começará a cair, ou um componente de luz a um GameObject e ele emitirá luz. E assim por diante. No entanto, o sistema de componentes foi desenvolvido em uma estrutura orientada a objetos e cria desafios para desenvolvedores no que diz respeito ao gerenciamento do cache e da memória em hardware em evolução contínua. Componentes e GameObjects são objetos de conteúdo intenso em C++. Todos os GameObjects têm um nome. Seus componentes são wrappers C# sobre componentes C++. Isso facilita o trabalho com eles, no entanto, isso pode afetar o desempenho pois eles acabam armazenados de maneira não estruturada. Esse objeto em C# pode estar em qualquer lugar na memória. O objeto em C++ também pode estar em qualquer lugar na memória. As coisas não são agrupadas em memória contínua. Toda vez que algo é carregado na CPU para processamento, tudo precisa ser buscado em diversos locais. Isso pode ser lento e ineficiente, exigindo, assim, muitas alternativas de otimização. Para abordar esses problemas de desempenho, estamos reconstruindo a base fundamental do Unity com o Data-Oriented Technology Stack, ou DOTS (atualmente em pré-visualização), multithread de alto desempenho. DOTS permite que os jogos utilizem em sua totalidade os processadores multinúcleo mais recentes de maneira eficiente. É composto por: Em DOTS, o ECS é o novo sistema de componentes. O que é feito com um GameObject na abordagem tradicional orientada a objetos, é feito com uma entidade nesse novo sistema. Os componentes ainda são chamadas dessa maneira. A principal diferença está no layout de dados. Você pode ler mais sobre isso na publicação do blog “Sobre DOTS: Sistema de Entidade de Componentes”.
Além de ser uma maneira melhor para abordar a programação de jogos por motivos de design, usar o ECS coloca você em uma posição ideal para aproveitar o sistema de trabalho em C# e o Compilador Burst do Unity, permitindo que você obtenha todas as vantagens do hardware moderno atual. Os sistemas multithread do DOTS permitem criar jogos que podem ser executados em uma variedade de hardware e desenvolver mundos de jogo mais completos com mais elementos e simulações mais complexas. Por sua vez, o código eficaz contribui para controle térmico e vida útil da bateria ótimos nos dispositivos móveis dos jogadores. Ao passar do design orientado a objetos para orientado a dados, pode ser mais fácil reutilizar seu código e a compreensão e o trabalho de outras pessoas nele. Como parte da tecnologia do DOTS está em pré-visualização, é aconselhado que os desenvolvedores usem ele para solucionar um desafio de desempenho específico em seus projetos, em vez de desenvolver projetos inteiros nele. Confira a seção “Mais recursos” na parte inferior desta página a fim de obter links para recursos importantes do DOTS.
.NET: Unity usou uma implementação do tempo de execução padrão Mono para scripts com suporte nativo a C#. Atualmente, o Unity é fornecido com Visual Studio para Mac em vez de MonoDevelop-Unity em macOS. No Windows, o Unity é fornecido com Visual Studio. O tempo de execução de scripts .NET 4.6 em Unity oferece suporte a muitos dos novos recursos empolgantes em C# e depuração disponíveis em C# 6.0 e posterior. Isso também oferece uma ótima experiência IDE em C# para acompanhar os novos recursos em C#. IL2CPP: este é um back-end de scripts desenvolvido em Unity que pode ser usado como alternativa ao Mono ao compilar projetos para algumas plataformas. Quando você opta por compilar um projeto usando IL2CPP, o Unity converte código IL de scripts e organiza em código C++, antes de criar um arquivo binário nativo (por exemplo, .exe, apk, .xap) para sua plataforma escolhida. Observe que IL2CPP é o único back-end de scripts disponível ao compilar para iOS e WebGL.
Como programador, você tem muita flexibilidade em Unity pois é capaz de ampliar o editor com suas próprias janelas personalizadas que se comportam igual ao Inspector, Scene ou qualquer outra janela integrada no editor padrão. Adicionar suas próprias ferramentas ao Unity oferece suporte aos fluxos de trabalho e às necessidades suas e de sua equipe, impulsionando a eficiência.
|
Como comparar colisão na unity2d
Postagens relacionadas
direito autoral © 2024 aprendervalor Inc.
