Unity realiza multilíngue

No desenvolvimento de jogos, é muito importante realizar a função multilíngue. Aqui está uma maneira de implementar multilíngue no Unity.

Criar arquivos de idioma

Primeiro, crie uma pasta chamada "Localização" em seu projeto. Crie uma subpasta dentro desta pasta chamada "Languages". Na pasta "Idiomas", crie um script separado para cada idioma. Por exemplo, para inglês, crie um script chamado "en_US.cs". Nesse script, todas as strings que precisam ser traduzidas são armazenadas em pares chave-valor. Aqui está um exemplo:

public static class en_US {
    public static string PLAY = "Play";
    public static string OPTIONS = "Options";
    // other strings
}

Em scripts em outros idiomas, traduza as strings correspondentes para texto nesse idioma. Por exemplo, para chinês, você pode criar um script chamado "zh_CN.cs" com o seguinte conteúdo:

public static class zh_CN {
    public static string PLAY = "开始游戏";
    public static string OPTIONS = "选项";
    // other strings
}

2. Crie uma classe de gerenciador de localização

Em seguida, crie um script C# chamado "LocalizationManager" no projeto. Este script é responsável por carregar e alternar entre diferentes idiomas e fornece métodos para obter strings em arquivos de idioma.

// LocalizationManager.cs

using System.Collections.Generic;
using UnityEngine;

public class LocalizationManager : MonoBehaviour {
    // 单例模式：确保只有一个实例存在，可以在整个游戏中被访问
    public static LocalizationManager Instance { get; private set; }

    // 字典：存储文本字符串和对应的键值对
    private Dictionary<string, string> localizedText;
    // 当前语言，默认为英文
    private string currentLanguage = "en_US";

    private void Awake() {
        // 单例模式：确保只有一个实例存在
        if (Instance == null) {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            LoadLocalizedText(currentLanguage);
        }
        else {
            Destroy(gameObject);
        }
    }

    /// <summary>
    /// 加载指定语言的文本文件并解析为键值对，存储到字典中
    /// </summary>
    private void LoadLocalizedText(string language) {
        // 创建新的字典
        localizedText = new Dictionary<string, string>();

        // 加载文本文件
        TextAsset textAsset = Resources.Load<TextAsset>("Localization/Languages/" + language);
        // 分行解析文本内容，并添加到字典中
        string[] lines = textAsset.text.Split('\n');

        foreach (string line in lines) {
            string[] keyValue = line.Split('=');
            localizedText.Add(keyValue[0], keyValue[1]);
        }
    }

    /// <summary>
    /// 切换语言并重新加载文本文件
    /// </summary>
    public void SetLanguage(string language) {
        if (language != currentLanguage) {
            currentLanguage = language;
            LoadLocalizedText(currentLanguage);
        }
    }

    /// <summary>
    /// 获取指定键的本地化字符串
    /// </summary>
    public string GetLocalizedValue(string key) {
        // 如果存在该键，则返回对应的值；否则返回原始字符串
        string result = key;
        if (localizedText.ContainsKey(key)) {
            result = localizedText[key];
        }
        return result;
    }
}

Essa classe usa o padrão singleton para garantir que apenas uma instância exista e possa ser acessada durante o jogo. Ele usa o Dictionary para armazenar strings de texto e pares de valores-chave correspondentes.

O método LoadLocalizedText carrega um arquivo de texto no idioma atual e adiciona cada par chave-valor a um dicionário. O método SetLanguage alterna o idioma e chama LoadLocalizedText para carregar um novo arquivo de texto. O método GetLocalizedValue obtém a string localizada para a chave especificada.

3. Use texto multilíngue no jogo

Por fim, use o componente UI Text para exibir strings multilíngues. No campo de texto do componente de texto da interface do usuário, use o código a seguir para chamar o LocalizationManager para obter a string localizada correspondente:

// TextLocalization.cs

using UnityEngine;
using UnityEngine.UI;

public class TextLocalization : MonoBehaviour {
    // 需要翻译的字符串的键值
    public string key;

    private Text textComponent;

    private void Start() {
        // 查找UI文本组件并保存
        textComponent = GetComponent<Text>();
        // 更新文本
        UpdateText();
    }

    /// <summary>
    /// 获取对应的本地化字符串，并更新UI文本内容
    /// </summary>
    public void UpdateText() {
        textComponent.text = LocalizationManager.Instance.GetLocalizedValue(key);
    }
}

Essa classe é anexada ao componente de texto da interface do usuário e define o campo-chave como o valor-chave da string a ser traduzida. No método Start, ele localiza o componente de texto da interface do usuário e o salva e, em seguida, chama UpdateText para atualizar o texto.

A descrição acima é uma maneira simples de obter vários idiomas no Unity. Ao criar arquivos de idioma, criar classes de gerenciador de localização e usar componentes de texto da interface do usuário, você pode facilmente fazer com que seu jogo suporte vários idiomas.

Unity realiza multilíngue

Acho que você gosta