2DDevelopment Configurando um Controller Avançado 2D na Unity e User Interface

[Under]

Vamos abordar a criação de um sistema de movimento, lançamento de feitiços, gerenciamento de saúde, experiência e ouro.

Introdução​

Bem-vindo ao guia de configuração do controller avançado. Aqui, abordaremos vários aspectos essenciais para criar uma experiência de jogo envolvente.
Abaixo estão as seções que iremos cobrir:

• Configuração de Feitiços: Como criar e configurar feitiços.
• Controle de Saúde: Implementação de um sistema de saúde para o jogador.
• Sistema de Experiência: Como gerenciar pontos de experiência e níveis do jogador.
• Gerenciamento de Ouro: Implementação de um sistema para coletar e exibir ouro.
• Movimentação do Jogador: Configuração de um sistema de movimento e mecânicas de bounce.

1. Configuração de Feitiços​

Começaremos criando um script para configurar os feitiços. O script SpellConfig nos permitirá definir teclas de atalho, prefabs dos feitiços, velocidade e dano.

Spoiler: Configuração de Feitiços

//Assets/scripts/configs[S]/[/S]
using UnityEngine;

[CreateAssetMenu(fileName = "NewSpellConfig", menuName = "Spell Config")]
    public class SpellConfig : ScriptableObject
{
    public KeyCode key;
    public GameObject spellPrefab;
    public float speed;
    public int damage;
}

Após salvar o código a nova config estará disponível no menu da Unity Assets -> Create -> SpellConfig
Exemplo de um Scriptable Object na Unity

2. Controle de Saúde​

Em seguida, vamos configurar um sistema de saúde para o jogador. O script HealthController gerenciará a saúde máxima e atual, além de atualizar a barra de saúde na UI.

Spoiler: Controle de Saúde

//Assets/scripts/controllers
using UnityEngine;

public class HealthController : MonoBehaviour
{
    public int maxHealth = 100;
    public int currentHealth;
    public HealthBar healthBar;

    void Start()
    {
        currentHealth = maxHealth;
        healthBar.SetHealth(currentHealth);
    }

    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        Debug.Log($"Player health: {currentHealth}");
        healthBar.SetHealth(currentHealth);

        if (currentHealth <= 0)
        {
            Die();
        }
    }

    void Die()
    {
        Debug.Log("Player died");
        gameObject.SetActive(false);
    }
}

3. Sistema de Experiência​

Agora, vamos implementar um sistema de experiência e níveis. O script ExpController gerenciará os pontos de experiência e a progressão de nível do jogador.

Spoiler: Sistema de Experiência

// Assets/scripts/controllers
using UnityEngine;
using UnityEngine.UI;

public class ExpController : MonoBehaviour
{
    public int currentExp = 0;
    public int playerLevel = 0;
    public Slider expSlider;

    private int expToNextLevel;

    void Start()
    {
        expToNextLevel = CalculateExpToNextLevel();
        UpdateExpUI();
    }

    public void AddExp(int amount)
    {
        currentExp += amount;
        CheckLevelUp();
        UpdateExpUI();
    }

    void CheckLevelUp()
    {
        while (currentExp >= expToNextLevel)
        {
            currentExp -= expToNextLevel;
            playerLevel++;
            expToNextLevel = CalculateExpToNextLevel();
            Debug.Log($"Level up! New level: {playerLevel}");
        }
    }

    int CalculateExpToNextLevel()
    {
        return 500 * (playerLevel + 1);
    }

    void UpdateExpUI()
    {
        if (expSlider != null)
        {
            expSlider.maxValue = expToNextLevel;
            expSlider.value = currentExp;
        }
    }
}

4. Gerenciamento de Ouro​

Em seguida, vamos implementar um sistema para gerenciar o ouro coletado pelo jogador. O script GoldController atualiza a quantidade de ouro e a exibe na UI.

Spoiler: Gerenciamento de Ouro

// Assets/scripts/controllers
using UnityEngine;
using UnityEngine.UI;

    public class GoldController : MonoBehaviour
    {
    public int currentGold = 0;
    public Text goldUIText;

    void Start()
    {
        UpdateGoldUI();
    }

    public void AddGold(int amount)
    {
        currentGold += amount;
        UpdateGoldUI();
    }

    void UpdateGoldUI()
    {
        if (goldUIText != null)
    {
        goldUIText.text = currentGold.ToString();
    }
    }
}

5. Movimentação do Jogador​

Finalmente, vamos configurar o movimento do jogador, incluindo mecânicas de bounce e lançamento de feitiços. O script PlayerController gerencia esses aspectos.

Spoiler: Movimentação do Jogador

// Assets/scripts/controllers
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
public float moveSpeed = 5f;
 public Rigidbody2D rb;
 public Transform spellSpawnPoint;
 public SpellConfig[] spells;
 public LineRenderer lineRenderer;
 public HealthController healthController;
 public GoldController goldController;
 public ExpController expController;
 public Transform partner;
 public GameObject head;
 public GameObject bodyContainer;
public float bounceFrequency = 2f;
public float bounceAmplitudeVertical = 0.2f;
public float bounceAmplitudeHorizontal = 0.2f;
public float headZPositionLeft = -1f;
public float headZPositionRight = 1f;

 private Vector2 movement;
private SpellConfig activeSpell = null;
private bool isTargeting = false;
private float bounceTimer = 0f;

private void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        goldController = GetComponent<GoldController>();
        expController = GetComponent<ExpController>();

if (partner != null)
        {
            PartnerController partnerController = partner.GetComponent<PartnerController>();
if (partnerController != null)
            {
partnerController.player = this.transform;
            }
        }
    }

private void Update()
    {
movement.x = Input.GetAxisRaw("Horizontal");
movement.y = Input.GetAxisRaw("Vertical");

        HandleFlip();
        HandleBounce();

foreach (SpellConfig spell in spells)
        {
 if (Input.GetKeyDown(spell.key))
            {
                StartTargeting(spell);
            }
        }

 if (isTargeting)
        {
            UpdateTargeting();
        }
    }

private void FixedUpdate()
    {
        rb.MovePosition(rb.position + movement * moveSpeed * Time.deltaTime);
    }

void HandleFlip()
    {
if (movement.x < 0)
        {
bodyContainer.transform.rotation = Quaternion.Euler(0, 0, 0);
        }
else if (movement.x > 0)
        {
bodyContainer.transform.rotation = Quaternion.Euler(0, -180, 0);
        }
    }

void HandleBounce()
    {
if (movement.x != 0 || movement.y != 0)
        {
            bounceTimer += Time.deltaTime * bounceFrequency;
float bounceVertical = Mathf.PingPong(bounceTimer, bounceAmplitudeVertical) - (bounceAmplitudeVertical / 2);
float bounceHorizontal = Mathf.PingPong(bounceTimer, bounceAmplitudeHorizontal) - (bounceAmplitudeHorizontal / 2);
bodyContainer.transform.localPosition = new Vector3(bounceHorizontal, bounceVertical, bodyContainer.transform.localPosition.z);
        }
else
        {
bounceTimer = 0f;
bodyContainer.transform.localPosition = new Vector3(0, 0, bodyContainer.transform.localPosition.z);
        }
    }

void StartTargeting(SpellConfig spellConfig)
    {
        activeSpell = spellConfig;
isTargeting = true;
lineRenderer.enabled = true;
Debug.Log($"Started targeting with spell: {spellConfig.spellPrefab.name}");
    }

void UpdateTargeting()
    {
        Vector3 mousePosition = Camera.main.ScreenToWorldPoint(Input.mousePosition);
mousePosition.z = 0;

lineRenderer.SetPosition(0, spellSpawnPoint.position);
lineRenderer.SetPosition(1, mousePosition);

if (Input.GetMouseButtonDown(0))
        {
Debug.Log("Casting spell at position: " + mousePosition);
            CastSpell(mousePosition);
isTargeting = false;
lineRenderer.enabled = false;
        }
    }

void CastSpell(Vector2 target)
    {
if (activeSpell == null) return;

        GameObject spell = Instantiate(activeSpell.spellPrefab, spellSpawnPoint.position, spellSpawnPoint.rotation);
        SpellController spellController = spell.GetComponent<SpellController>();
if (spellController != null)
        {
            spellController.Initialize(activeSpell.speed, activeSpell.damage, target);
Debug.Log($"Casting spell {spell.name} with speed {activeSpell.speed} and damage {activeSpell.damage}");
        }

activeSpell = null;
    }
}

---

​

 

[Under]

Bem-vindo ao guia de configuração da UI para o controller avançado Unity 2D​

Aqui, abordaremos os seguintes aspectos essenciais:​

1. Barra de Saúde: Implementação e configuração da barra de saúde do jogador.
2. Barra de Experiência: Configuração da barra de experiência para mostrar o progresso do jogador.
3. Exibição de Ouro: Configuração do texto da UI para exibir a quantidade de ouro do jogador.

1. Barra de Saúde​

Primeiro, vamos configurar a barra de saúde que irá exibir a vida atual do jogador. Assumimos que você já possui um componente de UI chamado HealthBar.

Spoiler: Barra de Saúde

No editor do Unity, certifique-se de adicionar o componente HealthBar ao seu jogador e referenciá-lo no script HealthController.

2. Barra de Experiência​

Agora, vamos configurar a barra de experiência para mostrar o progresso do jogador. Assumimos que você já possui um componente de UI chamado ExpSlider.

Spoiler: Barra de Experiência

No editor do Unity, adicione o componente Slider à UI e referencie-o no script ExpController.

3. Exibição de Ouro​

Finalmente, vamos configurar o texto da UI para exibir a quantidade de ouro do jogador. Assumimos que você já possui um componente de UI chamado GoldUIText.

Spoiler: Exibição de Ouro

No editor do Unity, adicione o componente Text à UI e referencie-o no script GoldController.

O resultado será algo parecido com isso.

Spoiler: Resultado

Conclusão​

Este guia cobriu a configuração de um controller avançado para jogos 2D na Unity, incluindo movimento do jogador, lançamento de feitiços, gerenciamento de saúde, experiência e ouro.
Siga as seções acima para implementar cada componente em seu jogo. Se tiver dúvidas ou precisar de ajuda, sinta-se à vontade para perguntar na comunidade!

 

[Under]

Download UnityPackage,
​

​