Sistema de atualização de base no Unity

Em muitos jogos, os jogadores podem atualizar uma base ou edifício para desbloquear recursos adicionais, melhorar a defesa ou aumentar as taxas de produção. Este tutorial o guiará pela configuração de um sistema de atualização de base em Unity, permitindo que um edifício seja atualizado para vários níveis com mudanças visuais e funcionais em cada nível.

1. Configurando a estrutura base

Primeiro, crie um script Base que defina as propriedades da sua base, como seu nível, saúde e taxa de produção. Cada atualização de nível modificará esses atributos.

using UnityEngine;

public class Base : MonoBehaviour
{
    public int level = 1;
    public int health = 100;
    public int productionRate = 10;

    public void UpgradeBase()
    {
        level++;
        health += 50; // Increase health by 50 with each level
        productionRate += 5; // Increase production rate by 5 with each level
        Debug.Log("Base upgraded to level " + level);
    }
}

Este script Base inclui um método simples UpgradeBase() que incrementa o nível e atualiza os atributos da base. Anexe este script ao GameObject base na cena.

2. Criando um gerenciador de atualização

Em seguida, crie um script UpgradeManager que gerencie as atualizações básicas, incluindo a verificação se o jogador tem moeda suficiente para atualizar.

using UnityEngine;

public class UpgradeManager : MonoBehaviour
{
    public Base playerBase;
    public int upgradeCost = 100;

    public void AttemptUpgrade()
    {
        if (CurrencySystem.Instance.SpendCurrency(upgradeCost))
        {
            playerBase.UpgradeBase();
            upgradeCost += 50; // Increase the cost for each upgrade
        }
        else
        {
            Debug.Log("Not enough currency to upgrade.");
        }
    }
}

Anexe este script UpgradeManager a um GameObject, atribua o GameObject base ao seu campo playerBase e defina o upgradeCost inicial. Cada atualização aumenta o custo, tornando as atualizações futuras mais desafiadoras.

3. Configurando um sistema monetário

Para gerenciar os custos de atualização, adicione um CurrencySystem como uma maneira simples de rastrear e gastar a moeda do jogador. Aqui está um exemplo:

using UnityEngine;

public class CurrencySystem : MonoBehaviour
{
    public static CurrencySystem Instance;
    public int currency = 500;

    private void Awake()
    {
        if (Instance == null)
            Instance = this;
        else
            Destroy(gameObject);
    }

    public bool SpendCurrency(int amount)
    {
        if (currency >= amount)
        {
            currency -= amount;
            Debug.Log("Currency spent: " + amount + ". Remaining: " + currency);
            return true;
        }
        else
        {
            Debug.Log("Not enough currency.");
            return false;
        }
    }

    public void AddCurrency(int amount)
    {
        currency += amount;
        Debug.Log("Currency added: " + amount + ". Total: " + currency);
    }
}

Anexe este CurrencySystem a um GameObject na cena. O padrão singleton permite acesso fácil de outros scripts, como o UpgradeManager.

4. Atualizando visuais e efeitos por nível

Para tornar cada atualização de base visualmente distinta, adicione variações para cada nível, como modelos ou texturas diferentes. Por exemplo:

1. Crie vários modelos 3D para cada nível base ou prepare diferentes texturas/materiais.
2. Adicione código na classe Base para trocar modelos ou materiais sempre que o nível for aumentado.

Aqui está um trecho de código para atualizar visuais no script Base:

public GameObject[] levelModels; // Assign each level's model in Inspector

public void UpgradeBase()
{
    level++;
    health += 50;
    productionRate += 5;
    UpdateBaseModel();
}

void UpdateBaseModel()
{
    for (int i = 0; i < levelModels.Length; i++)
    {
        levelModels[i].SetActive(i == level - 1);
    }
}

Este código ativará o modelo que corresponde ao nível atual da base e desativará os outros.

5. Criando uma IU para atualizações

Em seguida, crie elementos de UI para permitir que o jogador inicie atualizações e rastreie o nível atual da base. Para fazer isso:

1. Crie um Canvas com um botão rotulado "Upgrade Base".
2. Anexe um evento OnClick a este botão, vinculando-o ao método AttemptUpgrade do UpgradeManager.
3. Exiba o nível, a saúde e a taxa de produção da base na interface do usuário para dar aos jogadores feedback sobre o progresso da atualização.

6. Testando o sistema de atualização

Execute o jogo e clique no botão "Upgrade Base". Com cada atualização, os atributos da base devem aumentar, e os visuais devem mudar de acordo. Use o log de Debug para verificar as alterações de moeda e ajustes de nível.

Expandindo o Sistema

Este sistema de atualização básico pode ser expandido adicionando:

• Novos níveis com atributos distintos e melhorias visuais.
• Requisitos de recursos além da moeda, como materiais ou tempo.
• Efeitos especiais para atualizações, como efeitos de partículas ou feedback sonoro.

Conclusão

Criamos um sistema de atualização base em Unity, apresentando aumentos dinâmicos de atributos, uma verificação de moeda simples e UI para atualizações. Este sistema fornece uma base para adicionar mecânicas mais complexas em seu jogo, como atualizações de vários estágios e visuais distintos para cada nível.