Локализация

Содержание

• Как это работает
• Настройка локализации
• Используйте локализацию API
  • Выберите язык
  • Использование SetBinding
  • Прослушивание изменений локала
• Работа со строковыми таблицами
  • Импорт и экспорт строк данных
  • Использование умных строк
  • Настройка умной строки в вашем скрипте
  • Понимание замены
• Предварительная обработка строк
  • GetLocalizedString
  • Использование события StringChanged
  • Динамическое UI управление
• Местонахождение ассетов
  • Настройка локализации активов
  • Таблицы активов и строковые таблицы
  • Общие локализованные ассеты в UI Toolkit
• Локализация в образце Dragon Crashers

Локализация UI может помочь вашей игре связаться с глобальной аудиторией, сделав ваше приложение интуитивным и знакомым на любом языке.

Unity 6 упрощает этот процесс путем прямой интеграции пакета Локализация с UI Toolkit. Эта интеграция позволяет предоставлять контент для ваших игроков в конкретном регионе, независимо от того, где они находятся.

Ключ к локализации Unity Местный класс, представляющий конкретный язык и управляющий региональными особенностями — например, форматированием валюты и чисел.

Давайте рассмотрим простой пример того, как можно настроить локализацию в UI Toolkit. С помощью этой настройки приложение может динамически настраивать свое содержимое на основе выбранного Locale.

Как это работает

Вот несколько ключевых особенностей пакета локализации:

• Локализация строки: LocalizedString класс позволяет управлять строками, которые автоматически обновляются при смене локали во время выполнения. С помощью Умные струны, вы можете добавлять замены, обрабатывать множественные числа и настраивать для других языковых нюансов.

• Локализация ассетов: Обмен текстурами и другими ассетами на основе локализации, что позволяет создавать регионально специфический контент, помимо простого текста.

• Привязка данных: Пакет локализации интегрирован с UI Toolkit’s runtime данные привязки, связывания UI элементы для Таблицы строк и активов. Изменения данных, локали или состояния загрузки запускают автоматические обновления.

• Управление строками и таблицами ассетов: Таблицы String и Asset хранят пары «ключ — значение» для перевода текста и других ассетов в варианты для конкретной локали. Централизованный интерфейс даёт общий обзор всего локализованного текста и ассетов проекта.

• Переключение локалей: Переключение языков в реальном времени без перезапуска приложения. Во время выполнения выберите новый Локал, и UI немедленно обновится, чтобы отразить изменение.

Помните, чтобы воспользоваться преимуществами UI Toolkit FlexBox контейнеров и элементов автоматического размера при адаптации к изменениям в длину текста и форматирования. Это может сделать ваш UIs более чувствительным при поддержке различных языков.

Настройка локализации

Чтобы начать использовать пакет локализации Unity с UI Toolkit, выполните следующие основные действия для настройки локализованного контента и привязки его к элементам UI в UI Builder.

1. Настройка параметров локализации: Установите пакет Localization из Package Manager, затем перейдите в Project Settings > Localization для создания и настройки ассета Localization Settings, который будет управлять всеми локализованными ассетами.

   

2. Создание локалей: Определите языки и регионы, которые будет поддерживать ваш проект с помощью генератора локалей. Это создает ресурсы для каждой локали, идентифицируемой уникальным двубуквенным кодом (e.g., “en” для английского, “fr” для французского, “es” для испанского и т.д.).

   

3. Создание таблиц строк и ассетов: Используйте таблицы строк для хранения текстовых записей для каждого локала. Добавляйте записи для UI текстовых элементов, таких как метки, кнопки и опции выпадающего списка.

   

4. В окне Таблицы локализации (Window > Asset Management > Localization Tables) добавьте пары ключ-значение для каждого текстового элемента в UI. Каждый ключ представляет определенный текстовый элемент (например, метку или кнопку), и каждое значение является переведенным текстом для этого элемента в каждом Локале.

5. Храните ресурсы, специфичные для региона, такие как изображения или GameObjects в таблицах ресурсов. Например, вы можете добавить спрайты или текстуры для значков, представляющих каждый локал. Для каждого ключа связывайте ресурсы, специфичные для каждого локала, чтобы отразить региональные или культурные предпочтения.

   

6. Определите интерфейс UXML: Используйте UI Builder для создания файла UXML с элементами, такими как Buttons, DropdownFields и Labels. В демонстрационной сцене этот UXML показывает несколько элементов, готовых для локализации. Для текстовых полей используйте запись из String Table. Для нетекстовых полей, таких как текстуры, используйте Asset Table.

   Демонстрационная сцена

   Образец реализации локализации можно найти в сценах LocalizationDemo, включенных в проект QuizU.

   Чтобы получить к нему доступ, перейдите во время выполнения в главное меню и выберите Локализация, или загрузить LocalizationDemo сцена непосредственно после отключения загрузчика (Тест > Не загружайте Bootstrap Scene в игре).

   

7. Привязать данные к UI элементам в UI Builder: Здесь вступает в действие мощная система привязки данных UI Toolkit. В UI Builder выберите элемент, который вы хотите локализовать. Откройте панель Inspector и выберите Добавить привязку в поле содержания (e.g., text для Меток или backgroundImage для изображений).

   Выберите , LocalizedString, или другой локализованный ассет в качестве типа привязки и создайте ссылку на соответствующую запись в вашей таблице строк или ассетов. Добавьте больше записей в таблицы, если вам нужно локализовать больше элементов.

   

8. Для тестирования используйте раскрывающееся меню Game View Locale для просмотра UI на разных языках, чтобы убедиться, что элементы отображаются правильно в каждом локале.

И это базовая настройка! В этом примере текстовые свойства кнопок и надписей теперь могут переключаться на любой другой настроенный язык. Чтобы локализовать весь UI, убедитесь, что у каждой части текста есть собственная запись в таблице строк.

Пакет локализации гибкий в том, как вы организуете содержание. Используйте несколько таблиц строк, чтобы разбить более большой проект на более управляемые секции или для категоризации различных записей. Затем используйте таблицы ассетов, чтобы помочь локализовать текстуры и другие нетекстовые ассеты.

После добавления привязок локализации в UI Builder, ваш файл UXML включает локализацию непосредственно в элементы UI. Это приводит к блоку кода, похожему на следующий, где каждое локализованное свойство привязано к конкретной записи в вашей таблице строк или ассетов:

<Bindings>

<UnityEngine.Localization.LocalizedString property="text"
table="GUID:6aaa262cde38a4024bc3fc7f5ce6d50d"
entry="Id(104135776002048)" />

</Bindings>

Этот фрагмент UXML устанавливает привязку данных, которая связывает текстовое свойство элемента UI с записью в таблицах String или Asset.

Каждый раз, когда вы обновляете таблицы локализации, связанные элементы UI автоматически отражают последнее локализованное содержимое.

Примечание: В то время UI Builder упрощает создание привязок данных, опытные пользователи могут также редактировать UXML непосредственно для большего контроля над локализованным содержанием.

Используйте локализацию API

Выпадающее меню Game View Locale в Редакторе полезно для тестирования различных языков, но оно не будет доступно в сборке вашего приложения. Чтобы позволить пользователям изменять языки в окончательном приложении, вам необходимо создать свой собственный UI для переключения локалей.

Выберите язык

Если у вас есть двухбуквенный идентификатор вашего Локалитета, вы можете установить активный Локалитет в LocalizationSettings. Затем подключите это действие к вашим кнопкам, используя манипулятор clicked на каждой кнопке или метод RegisterCallback<ClickEvent>.

Скрипт LocalizationDemo в примерном проекте показывает одну реализацию:

void SelectLocale(string localeCode)
{
    Locale locale =
        LocalizationSettings.AvailableLocales.GetLocale(localeCode);

    LocalizationSettings.SelectedLocale = locale;
}

void RegisterCallbacks()
{
    m_ButtonDanish.clicked += () => SelectLocale("da");

    m_ButtonEnglish.clicked += () => SelectLocale("en");

    m_ButtonSpanish.clicked += () => SelectLocale("es");

    m_ButtonFrench.clicked += () => SelectLocale("fr");
}

Теперь, когда вы нажимаете кнопку с названием Английский, Французский, Испанский или Датский, текст в UI изменяется во время выполнения.

Используйте SetBinding

Использование UI Builder для настройки привязок данных интерактивно и легко. Иногда, однако, вам потребуется настроить привязку с помощью скрипта во время выполнения. Например, вы можете создать UI элементы динамически, или у вас могут быть привязки, которые опираются на данные, доступные только во время игры.

Чтобы настроить привязку данных в C#, используйте метод SetBinding на визуальном элементе. Вот как привязать свойство text Label к записи LocalizedString в StringTable:

using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.UIElements;

public class LocalizationDemo : MonoBehaviour
{
    // Set in Inspector
    [SerializeField] LocalizedString m_LocalizedText;

    Label m_LocalizedLabel;
    UIDocument m_UIDocument;

    void Start()
    {
        m_LocalizedLabel =
            m_UIDocument.rootVisualElement.Q<Label>("text__label");

        m_LocalizedLabel.SetBinding("text", m_LocalizedText);
    }
}

В этой конфигурации, m_LocalizedText назначается в Inspector к позиции в DemoStringTable. Этот код связывает text свойство m_LocalizedLabel к указанному LocalizedString, позволяя ему обновляться автоматически при изменении Локалитета.

Прослушивание изменений локали

В некоторых случаях вам может потребоваться выполнить дополнительные действия при изменении Локалитета, помимо обновления локализованных строк. Прослушивайте событие SelectedLocaleChanged в событии LocalizationSettings API, если вы хотите выполнять какую-то логику каждый раз, когда Локалитет обновляется.

Вот пример:

using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

public class LocalizationExample: MonoBehaviour
{
    void OnEnable()
    {
        LocalizationSettings.SelectedLocaleChanged += OnLocaleChanged;
    }

    void OnDisable()
    {
        LocalizationSettings.SelectedLocaleChanged -= OnLocaleChanged;
    }

    void OnLocaleChanged(Locale newLocale)
    {
        // Perform actions when the Locale changes, like updating UI elements
        Debug.Log($"Locale changed to: {newLocale.Identifier.Code}");
    }
}

В этом случае OnLocaleChanged вызывает каждый раз, когда изменяется локаль, что позволяет обновлять другие элементы или запускать собственную логику. Используйте этот обработчик событий для настройки свойств или стилей UI, особенно если переведенный текст не вписывается в текущую макет.

Работа со строковыми таблицами

Большая часть вашей работы по локализации будет включать Струнные таблицы, которые обрабатывают все текстовые переводы для вашего UI и этикетки.

Откройте окно Таблицы локализации (Window > Asset Management > Localization Tables) и создайте или выберите Коллекцию таблиц строк. Здесь вы можете добавлять новые записи, определять уникальные ключи и вводить переводы для каждого Локала.

Импорт и экспорт строковых данных

CSV файлы

Вы можете заполнить таблицу строк, импортируя данные из файла CSV (значения, разделенные запятыми), что позволяет дизайнерам настраивать текст внешне. Чтобы редактировать записи в формате простого текста, экспортируйте существующую таблицу строк как CSV.

После обновления файла, импортируйте его обратно в Unity для автоматического обновления записей на основе их ключей.

Синхронизация Google Таблицы

Для подключения проекта к службе Google Таблицы необходимо использовать ресурс Sheets Service Provider. Этот ресурс управляет аутентификацией и позволяет создавать новые таблицы непосредственно в редакторе.

Чтобы создать его, перейдите в Assets > Create > Localization > Google Sheets Service.

В службе Таблицы Google есть два варианта авторизации: OAuth или API Ключ. Используйте OAuth, если нужен доступ к закрытым таблицам для чтения и записи. Используйте ключ API, если нужно только читать открытые таблицы. Для полного доступа на чтение и запись потребуется запросить авторизацию у Google. Подробности см. в Документация по Таблицам Google: авторизация запросов.

Чтобы связать коллекцию строковых таблиц с таблицей Google, добавьте Расширение Google Sheets к коллекции Расширения Выберите ассет Структурная таблица, а затем щелкните Плюс (+) кнопка рядом с Расширения в 2000 году Inspector. Вы можете добавить несколько расширений к одной Коллекции Струнных Таблиц, что позволит назначить различные листы каждому Локалу, если это необходимо.

Чтобы синхронизировать строчную таблицу с таблицей Google, подключите ее к ресурсу поставщика услуг Таблицы. Поставщик услуг Sheets для получения сведений о создании и настройке.

После настройки синхронизация позволяет дизайнерам или неразработчикам вносить изменения в ваши записи локализации непосредственно в GoogleТаблицах.

Использование умных строк

Умные строки являются мощной альтернативой использованию String.Format при генерации динамических строк. Они позволяют создавать шаблоны, управляемые данными, которые поддерживают такие функции, как множественное число, условное форматирование, списки и другие языковые правила. Эти функции могут упростить настройку локализации.

Чтобы использовать Умные Струны, пометьте строку как умную в окне Таблицы локализации.

Откройте окно Таблицы локализации. Умный формат из меню опций (e). Убедитесь, что {S} значок появляется рядом с записью.

В качестве альтернативы, включите Умные Струны в поле Умные в Локализованном Редакторе Струн в Inspector.

Настройка умной строки в вашем скрипте

Чтобы управлять SmartString из скрипта:

• Настройка локализованной строки с замещающими символами: Умная строка состоит из буквального текста с замещающими символами в скобках, подобно String.Format, но с дополнительной гибкостью. В вашей таблице строк создайте запись с замещающими символами, например "Welcome, {0}!". Здесь {0} является заместителем для данных выполнения.

• Используйте LocalizedString и аргументы: В вашем сценарии создайте LocalizedString для этой записи и укажите данные времени выполнения с помощью свойства Arguments. Например, в этом фрагменте из SmartStringDemo показано, как заменить один заполнитель:

// Replaces placeholder with player name (e.g.,
// "Welcome, {0}!" => "Welcome, Player One!")

m_PlaceholderLabel = root.Q<Label>("welcome__label");
m_PlaceholderMessage.Arguments = new object[] { m_PlayerName };
m_PlaceholderLabel.SetBinding("text", m_PlaceholderMessage);

Это привязывает LocalizedString к свойству text метки и подставляет имя игрока во время выполнения. Исходная запись [ «Welcome, {0}!» ] может выглядеть как "Welcome, Player One!" на экране.

Понимание заместителей

Заместители в умных строках не ограничиваются простыми заменами {0}. Они могут быть более сложными и предназначены для обработки сложных сценариев. На самом деле, заместитель может состоять из нескольких частей, включая:

• Селектор: это определяет, какие данные использовать (например, {player.name} выбирает свойство name объекта игрока).
• Formatter Name: Это определяет форматер, который будет применяться (e.g., plural для множественного числа).
• Параметры форматирования: Это настраивает поведение форматера (e.g., указывая формы единственного и множественного числа).
• Формат: Это определяет, как будет представлен выход (e.g., преобразование числа во множественное число, форматирование даты или времени, или выбор фразы на основе ввода).

Селекторы обладают гибкими возможностями и позволяют динамически получать данные во время выполнения. Они могут запрашивать свойства или поля объектов во время выполнения. Например, селектор {gameObject.name} позволяет получить свойство name объекта GameObject, а селектор {slider.value} — свойство value ползунка.

Форматеры преобразуют полученные данные в окончательный формат строки. Форматеры позволяют форматировать даты, время, списки, множественные формы или даже применять условную логику.

После получения данных, форматеры и преобразуют их в окончательный выход. Каждый форматер определяет свои собственные параметры и правила форматирования. В примерном проекте используются несколько форматеров:

• Выберите форматер: {0:choose(1|2|3):morning|afternoon|evening|anytime} выбирает «утром», «днем» или «вечером» на основе ввода.
• Форматирование множественного числа: {0:plural:one item| items} корректирует текст для форм единственного и множественного числа.

Измените значения в Inspector и перейдите в режим воспроизведения, чтобы увидеть полученный текст.

Smart Strings предлагает ряд встроенных форматеров, которые улучшают локализацию, позволяя менять текст в зависимости от состояния игры или контекста:

• Выберите форматер: Позволяет применять условную логику на основе числового ввода
• Форматирование множественного числа: Автоматически применяет правила множественного числа на основе количества
• Формат времени: Отображает дату и время
• Условное форматирование: для логики, аналогичной if/else
• Форматирование списков: Форматирование массивов или списков
• Является форматером соответствий: Для условного отображения текста на основе шаблонов регулярных выражений

Вы также можете использовать API для создания пользовательский форматер. Дополнительные сведения о форматерах см. в разделе Документация по умным строкам.

Предварительная обработка строк

В некоторых случаях прямое привязывание элементов UI к LocalizedString может оказаться неудобным. Например, некоторые элементы могут нуждаться в дополнительном форматировании или модификации перед отображением локализованного текста. В этом случае вы можете предварительно обработать LocalizedString, прежде чем он появится в UI.

GetLocalizedString

Метод GetLocalizedString может помочь здесь; он преобразует LocalizedString в стандартную строку во время выполнения. Это позволяет применять пользовательское форматирование, такие как добавление префиксов или сочетание строк, прежде чем выставить обработанную строку на UI. Вот пример:

[SerializeField] int m_PlayerLevel = 1;

LocalizedString m_LevelMessage = new LocalizedString("My_Table", "My_ Entry");

// A property that retrieves the localized string and replaces the placeholder {0} with the player's level
[CreateProperty] public string LevelMessage =>
    m_LevelMessage.GetLocalizedString(m_PlayerLevel);

В этом примере свойство LevelMessage заменяет замещающий символ {0} в локализованной строке текущим уровнем игрока. Атрибут CreateProperty позволяет использовать это свойство с привязкой данных во время выполнения, что облегчает прямую привязку к элементам UI.

Для простых случаев использования вы можете определить свойства, подобные LevelMessage, для обработки логики форматирования, устраняя необходимость в дополнительных обработчиках событий.

Использовать событие StringChanged

Событие StringChanged объекта LocalizedString полезно для такой предварительной обработки. Оно вызывается при каждом обновлении LocalizedString, то есть при изменении Locale, позволяя изменить текст до его отрисовки.

Чтобы использовать его, прикрепите обработчик к событию StringChanged. Вот фрагмент кода, который создает новый LocalizedString из My_Table StringTable с помощью My_Entry entry:

LocalizedString localizedString = new LocalizedString(
"My_Table", "My_Entry");

localizedString.StringChanged += OnLocalizedStringChanged;

Обратите внимание, что обработчик событий OnLocalizedStringChanged автоматически выполняет преобразование в стандартную строку. Затем вы можете применить собственную логику для изменения текста перед его отображением:

void OnLocalizedStringChanged(string value)
{
    // Example: Add a prefix based on certain conditions
    string processedString = $"[Prefix] {value}";

    // Update the UI element with the processed string
    m_TextLabel.text = processedString;
}

Динамические UI управления

Конечно, предварительная обработка LocalizedStrings не ограничивается простыми текстовыми полями. Она особенно полезна при работе со сложными свойствами или структурами UI, где Smart String не может в одиночку выполнить требуемую логику или форматирование.

Например, DropdownField имеет свойство choices, состоящее из списка строк. Предварительная обработка может помочь динамически локализовать этот список параметров, обеспечивая, что он отражает активный Локал.

Здесь скрипт PreprocessDemo локализует выборы DropdownField, обновляя их каждый раз, когда игрок выбирает новый язык. Опять же, логика восстановления списка запускается в ответ на событие StringChanged.

Вот выдержка из скрипта PreprocessDemo, которая показывает, как это работает:

[SerializeField] LocalizedString m_Choice1LocalizedString;
[SerializeField] LocalizedString m_Choice2LocalizedString;
[SerializeField] LocalizedString m_Choice3LocalizedString;
[SerializeField] LocalizedString m_Choice4LocalizedString;

public void Initialize(VisualElement root)
{
    m_DropdownField = root.Q<DropdownField>("dropdown__field");

    m_Choice1LocalizedString.StringChanged += UpdateDropdownChoices;
    m_Choice2LocalizedString.StringChanged += UpdateDropdownChoices;

    // ... register other choices

    // Initial population
    UpdateDropdownChoices(null);
}

При запуске события StringChanged параметры выпадающего списка перестраиваются, а текущий выбор сохраняется:

void UpdateDropdownChoices(string value)
{
    if (m_DropdownField == null)
        return;

    // Save the current selection
    int selection = m_DropdownField.index;

    // Remove previous choices
    m_DropdownField.choices.Clear();

    // Add current localized values
    m_DropdownField.choices.Add(m_Choice1LocalizedString.GetLocalizedString());
    m_DropdownField.choices.Add(m_Choice2LocalizedString.GetLocalizedString());

    // ... Add other choices

    // Restore selected index and value
    m_DropdownField.index = selection;
    m_DropdownField.SetValueWithoutNotify(m_DropdownField.choices[selection]);
}

Использование SetValueWithoutNotify обновляет отображение выпадающего списка без запуска ChangeEvent. Это предотвращает рекурсивное обновление и сохраняет выбор пользователя при изменении параметров выпадающего списка.

В примерном проекте DropdownField динамически обновляет свой выбор на основе значений LocalizedString. Каждый раз, когда выбирается новый Локал, обновленный язык пропагируется в раскрывающиеся списки.

Затем предварительная обработка может стать дополнительным методом, который поможет вам создать локализованный, контекстно-зависимый UIs. В то время как Smart Strings обрабатывает многие задачи локализации, такие как замены и множественное число, некоторые дополнительные предварительные обработки могут обеспечить дополнительную гибкость и форматирование, которые Smart Strings в одиночку не могут обрабатывать.

Местонахождение ассетов

Хотя строки играют важную роль в локализации, вам может потребоваться локализовать не только текст, но и другие элементы. Например, в примерном проекте используются значки, которые заменяют различно настроенные локали.

Настройка локализации ассетов

Локализация ассетов работает так же, как и локализация строк. Так же, как вы используете таблицы строк для локализованного текста, вы используете таблицы ассетов для локализованных ассетов. Обе таблицы имеют схожий рабочий процесс, включая добавление записей и ссылки на них в ваших скриптах или файлах UXML.

Локализованные ассеты могут быть привязаны к элементам UI с помощью скриптов UI Builder или C#. Например, вы можете привязать свойство style.backgroundImage визуального элемента к локализованному спрайту или текстуре.

В примерном проекте:

• Привязка данных одного элемента определена в UXML через UI Builder.
• Привязка другого элемента устанавливается в скрипте C#.

Теперь, при выборе локали во время выполнения, значки обновляются вместе с текстовыми метками, обеспечивая быстрый визуальный индикатор активной локали.

Таблицы ассетов и строковые таблицы

Процесс работы с таблицами ассетов аналогичен работе со строковыми таблицами. Обе таблицы позволяют определять записи по локальному языку и извлекать их во время выполнения. Обратите внимание на следующие различия:

• Обработка событий: Таблицы ассетов используют AssetChanged уведомлять об изменениях в локализованных ассетах вместо StringChanged событие для строк.

• Методы связывания: Обе привязки строки и ассета работают с SetBinding, но связанные свойства (e.g., текст для строк vs. style.backgroundImage для текстур) зависят от типа ассета.

В этом фрагменте показано, как в демонстрационном примере извлекается LocalizedTexture из таблицы ассетов по имени, а затем привязывается к свойству style.backgroundImage:

m_LocalizedTexture = new LocalizedTexture()
{
    TableReference = "DemoAssetTable",
    TableEntryReference = "HelloWorld_Icon"
};

m_IconElement = root.Q<VisualElement>("icon__hello-world");
m_IconElement.SetBinding("style.backgroundImage", m_LocalizedTexture);

Общие локализованные ассеты в UI Toolkit

Локализованные ассеты бывают разных форм. Вот некоторые из них, с которыми вы можете столкнуться при работе с UI Toolkit:

• Локализованные текстуры: Идеально подходят для икон, фонов и других декоративных визуальных эффектов, они могут быть привязаны непосредственно к свойствам визуальных элементов, таким как style.backgroundImage.
• Локализованные спрайты: Эти менее распространены, но полезны для пользовательских компонентов или визуальных элементов, основанных на спрайтах.
• Локализованные шрифты: Эти шрифты позволяют переключать шрифты для поддержки определенных скриптов или типографических стилей, требуемых различными языками.
• Локализованные объекты: Эти объекты полезны для ссылок на сложные ресурсы, такие как префабы или ассеты, управляемые данными, которые должны меняться в зависимости от Локализации.

Используя эти ресурсы вместе с таблицами ресурсов, вы можете гарантировать, что ваш UI динамически адаптирует не только текст, но и визуальные элементы, чтобы соответствовать активному локалу.

Локализация в образце Dragon Crashers

В демо UI Toolkit Sample – Драконы представлены несколько методов локализации в действии. В меню Настройки вы можете использовать выпадающее меню для выбора одного из поддерживаемых языков. При выборе нового языка система LocalizationSettings обнаруживает изменение и обновляет UI в реальном времени.

Вот несколько вещей, которые вы можете проверить, когда вы исследуете проект самостоятельно:

• SettingsScreen Выбор локала: Экран Настройки позволяет пользователям выбирать локал с помощью выпадающего меню. Этот UI просматривает изменения в LocalizationSettings для обнаружения новых вариантов выбора локала, обновляя в реальном времени по мере изменения выпадающего меню.

• Методы привязки данных: В UI используется комбинация методов локализации. Статические свойства привязываются непосредственно в UI Builder и хранятся в UXML.

  • Метод SetBinding соединяет текстовые свойства с объектами LocalizedString, обеспечивая, что UI отражает выбранный Locale.

• Предварительно отформатированный LocalizedStrings в ScriptableObjects: Некоторые ассеты ScriptableObject содержат предварительно отформатированные свойства LocalizedString. Например, на экране Настройки раскрывающиеся поля Тема и Язык динамически восстанавливают списки из локализованных значений, переводя доступные варианты.

  • Другие элементы, такие как RadioButtonGroup и пользовательский SlideToggle также предварительно обрабатывают LocalizedStrings, обрабатывая событие StringChanged.

Независимо от метода локализации – связывания данных через UXML или C# сценарии – UI реагирует в реальном времени на изменения Локализации.

Используйте методы, описанные в этом примере проекта, в качестве вдохновения для создания локализованных интерфейсов в ваших собственных проектах Unity. Сочетая привязку данных и UI Toolkit, вы можете создать гибкий, многоязычный UI, готовый приветствовать игроков со всего мира.

Ознакомьтесь с UI Toolkit Sample – Драконы для получения дополнительных примеров локализации.