Искать

Не только мобильные устройства

Используйте преимущества Windows 10 и новых возможностей продвижения в Windows Store

Руководства по портированию

Введение

Создание игр на Unity набирает популярность с каждым днем, и особенно — с появлением общих баз исходного кода для разных платформ и типов устройств. Это касается и разработки игр для Windows 10 на базе универсальной платформы Windows (UWP). В этом руководстве вы узнаете, как применить свои навыки в работе с Unity для разработки игр для UWP. Мы остановимся на:

  • компиляции игр для UWP;
  • передовых практиках работы со средой Windows;
  • внедрении функционала, характерного для платформы;
  • ключевых плагинах;
  • публикации игр в Магазине Windows.

Чтобы проиллюстрировать процесс переноса Unity-игры на UWP, мы используем реальную игру. Мы рассмотрим ряд проблем и тонких моментов портирования игры Unity на UWP и опубликуем игру в Магазине Windows.

Примечание. Руководство предназначено для тех, кто уже знаком с основами Unity3D. Чтобы узнать больше о Unity3D, вы можете в любой момент воспользоваться обучающими материалами Unity.

Требования к разработке игр для UWP на базе Unity

Чтобы разработать, скомпилировать и опубликовать Unity-игру в Магазине Windows, вам потребуются:

  • Unity 5.3.5. Для работы подходят как бесплатная версия Unity, так и Unity Pro. Дополнения для публикации в Магазине Windows доступны и для пользователей Unity, и для пользователей Unity Pro;
  • Visual Studio. Подойдет любая комплектация Visual Studio, включая бесплатную Visual Studio Express. Для разработки для универсальной платформы Windows вам потребуется Visual Studio 2015 с обновлением 1;
  • Windows 10. Если у вас нет лицензии на Windows 10, вы можете получить 90-дневную пробную версию. Если вы используете Mac OS X или собираетесь установить систему на компьютер Apple, ознакомьтесь с возможностями Boot Camp, VMWare и Parallels;
  • Учетная запись Microsoft. Чтобы получить лицензию разработчика, вам потребуется бесплатная учетная запись Microsoft;
  • Учетная запись Магазина Windows для разработчика. Нужна для размещения игры в Магазине Windows. В ходе ее создания вы зарегистрируетесь и подтвердите, что вы — частное лицо или компания, которая имеет право на размещение приложений и игр в Магазине Windows. Эта же регистрация действительна и для Windows Phone (единая регистрация позволяет размещать приложения в обоих магазинах). Для частных лиц регистрация может потребовать оплаты, хотя бесплатные учетные записи Центра разработки часто можно получить, участвуя в программах, спонсируемых Microsoft (например, для студентов или стартапов);
  • Устройство для тестирования приложений в среде Windows 10. Несмотря на то, что работу c мультитачем и разные разрешения дисплея можно воссоздать и на эмуляторе, при разработке приложений для сенсорных устройств мы рекомендуем использовать для тестирования настоящие ARM-устройства.

Данный документ актуален для комбинации Unity 5.3.5, Visual Studio 2015 с обновлением 2 и Windows 10 версии 1511. Для вашего удобства мы рекомендуем пользоваться версиями программного обеспечения не ниже Unity 5.3.2 и Visual Studio с обновлением 1, поскольку иначе могут возникнуть проблемы с совместимостью, в т. ч. с API.

Windows Store

Теперь в Магазине Windows существует единая область для отправки и загрузки UWP-приложений. Вы все еще можете разрабатывать приложения для устройств на более ранних операционных системах, но в этом документе мы сосредоточимся на UWP-приложениях для Магазина Windows.

NuGet

NuGet — это менеджер пакетов для платформы разработки Microsoft, поддерживающий в том числе .NET. Он позволяет разработчикам находить сторонние библиотеки и добавлять их в свои проекты. Вы можете использовать NuGet, чтобы обеспечить прямое использование любых Windows-библиотек. При помощи NuGet можно также управлять DLL-модулями, вызываемыми из скриптов в Unity.

NuGet также необходим для портирования игр Unity на UWP. Когда вы экспортируете Unity-проект в приложение Visual Studio UWP, NuGet используется платформой Unity для установки всех библиотек, необходимых для использования .NET Core.

Настройка Unity для публикации в Магазине Windows

В этом разделе мы расскажем, что требуется для того, чтобы взять существующую игру на платформе Unity и подготовить ее для публикации в Магазине Windows как игру для универсальной платформы Windows (UWP). Мы остановимся на следующих вопросах:

  • Включение режима разработчика в Windows 10
  • как ввести информацию об игре в Unity;
  • как произвести экспорт проекта для универсальной платформы Windows под Windows 10;
  • как создать сборку проекта в Visual Studio 2015 с обновлением 2 и пакетом SDK для Windows 10;
  • как связать игру с Магазином Windows;
  • как добавить графику и прочие материалы (логотип, значок, заставку), если это еще не сделано в редакторе Unity;
  • как работать с комплектом сертификации приложения для Windows;
  • как опубликоваться в Магазине Windows.

Включение режима разработчика в Windows 10

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

Активация устройств с Windows 10

Чтобы использовать настольный компьютер, планшет или смартфон на Windows 10 для разработки, вы должны активировать это устройство в разделе «Параметры Windows».

Перейдите в «Параметры Windows» и выберите «Обновление и безопасность». Затем откройте подраздел «Для разработчиков». Теперь просто включите «Режим разработчика».

Подробнее о том, как это делается, вы узнаете здесь.

как ввести информацию об игре в Unity;

Один из первых этапов подготовки игры на Unity — убедиться в том, что вы выбрали правильные настройки сборки.

Для разработки игр на Unity для универсальной платформы Windows (UWP) вам потребуются:

Чтобы изменить настройки Unity, сначала щелкните File и выберите Build Settings.

Затем нажмите Player Settings в нижней части окна.

В окне Player Settings введите информацию об игре.

Если хотите, вы можете также добавить логотип и фоновую картинку Player Settings для окна, которое будет отображаться в Магазине Windows. Поскольку существует множество способов сборки приложений Unity для Магазина Windows, данную операцию тоже можно выполнить множеством способов, а также отложить добавление изображений в интерфейсе Unity и сделать это позже при помощи Visual Studio.

Теперь параметры сборки Unity3D корректно установлены, и вы можете начать экспорт для универсальной платформы Windows.

Экспорт для универсальной платформы Windows

В этом разделе рассказывается о поддержке Unity разработки под универсальную платформу Windows (UWP) и процессе экспорта из Unity для универсальной платформы Windows.

Unity3D поддерживает приложения UWP, начиная с версии Unity 5.2. В настоящий момент экспортировать приложение для UWP можно, выбрав Universal 10 из списка SDK в разделе Магазина Windows окна Build Settings:

Unity 5.3.5 экспортирует файлы проекта Visual Studio 2015, и готовые сборки будут работать на устройствах Windows 10.

Поддерживаются три архитектуры: ARM, x86 и x64. Кроме того, вы можете использовать в своих игровых проектах .NET Core 5.0.

Щелкнув кнопку Build в окне Build Settings, вы откроете диалоговое окно Build Windows Store, в котором нужно выбрать папку для сборки игры.

Когда вы выберете папку, Unity начнет сборку игры для выбранной платформы. Если игра занимает большой объем, это может занять несколько минут:

Теперь в окне Проводника Windows откроется папка со всеми файлами, созданными Unity.

Чтобы узнать об этой процедуре больше, изучите документацию Unity3D по Windows.

Сборка решений в Visual Studio 2015 с обновлением 2 и пакетом SDK для Windows 10

Чтобы продавать или распространять приложение для универсальной платформы Windows (UWP), вам нужно создать пакет APPXUPLOAD. Этот пакет облегчает процесс продаж приложения в Магазине Windows или его распространение среди других пользователей. Когда вы создадите APPXUPLOAD, автоматически сгенерируется еще один пакет APPX для тестирования и загрузки неопубликованных приложений. Второй процесс позволит вам распространять приложения напрямую, разворачивая пакет APPX на самом устройстве.

Для Windows 10 вы должны создать один пакет (.appxupload), который можно загрузить в Магазин Windows. После этого приложение станет доступно для установки и запуска на любом устройстве с Windows 10.

Примечание. Если вам нужно создать пакет приложения для Windows 8.1, следуйте этим указаниям.

Теперь перейдем к компиляции игры в Visual Studio.

В первую очередь, выберите платформу (x86 или x64).

В меню редактора выберите Build -> Build Solution.

Дайте NuGet Package Manager разрешение на восстановление пакетов.

Щелкните Run и убедитесь, что выбрано Local Machine.

Проверьте, что сборка прошла успешно.

Сделав это, вы можете отправить приложение в Магазин Windows. Если это специализированное бизнес-приложение (LOB) для внутреннего использования в компании, его можно развернуть без публикации для установки на любом устройстве с Windows 10.

За дополнительной информацией обратитесь к руководству «Упаковка универсальных приложений Windows для Windows 10».

Связка приложения с Магазином Windows

Из меню Проектвыберите Store -> Associate App with the Store....

Когда вы это сделаете, большая часть полей вкладки Packaging окна Manifest Designer автоматически обновится. В файл манифеста приложения будут загружены следующие значения из текущего проекта с локального компьютера:

  • Package Display Name;
  • Package Name;
  • Publisher ID;
  • Publisher Display Name;
  • Версия

Если вы не будете использовать стандартный файл package.appxmanifest, а создадите собственный XML-файл манифеста, то не сможете связать свое приложение с Магазином Windows. Если же вы попытаетесь связать с магазином собственный файл манифеста, то получите сообщение об ошибке, так как создание собственных файлов манифеста не допускается.

За дополнительной информацией обратитесь к руководству Упаковка универсальных приложений Windows для Windows 10

Подготовка к отправке приложения в Магазин Windows

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

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

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

Чтобы создать новую заявку, щелкните Update (Обновить) около последней заявки на обзорной странице приложения.

Контрольный список для отправки приложения

В комплект Unity входит минимальный набор ресурсов для подачи заявки на размещение, но лучше всего использовать ваши собственные изображения и ресурсы. Ниже приведен скриншот раздела Visual Assets из файла Package.appxmanifest:

Вы можете просматривать все ресурсы, которые используются в процессе сборки.

За дополнительной информацией обратитесь к руководству «Отправка приложений» в MSDN.

как работать с комплектом сертификации приложения для Windows;

Чтобы повысить шанс публикации приложения в Магазине Windows или его сертификации, важно проконтролировать его качество и протестировать его до отправки на сертификацию. В этом разделе описано, как установить и запустить комплект сертификации приложений для Windows. Этот комплект предназначен для проведения серии тестов приложения в таких областях, как производительность и совместимость с API. Чтобы узнать больше о каждом тесте комплекта, ознакомьтесь со следующими темами:

Требования

Если вы разрабатываете приложение для универсальной платформы Windows (UWP), вы должны…

Чтобы установить комплект сертификации приложений для Windows версии 10, включенный в пакет SDK для Windows 10, вам нужно сначала создать пакет приложения для выполнения теста. Из меню Project выберите Store -> Create App Packages:

Когда создание пакета завершится, на экране появится окно, из которого вы сможете запустить комплект сертификации:

Когда вы загрузите его, на экране появится следующее окно:

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

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

Щелкнув по ссылке Click here to view the results, вы откроете окно браузера с результатами тестирования.

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

За дополнительной информацией обратитесь к руководству Работа с комплектом сертификации приложений Windows в MSDN.

как опубликоваться в Магазине Windows.

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

  1. Откройте браузер и пройдите по ссылке https://dev.windows.com/.
  2. Войдите в учетную запись и откройте информационную панель.
  3. Выберите имя пакета приложения, как в Visual Studio.
  4. Щелкните «Отправить приложение».
  5. Чтобы завершить подачу заявки, на следующем шаге вы должны будете ввести информацию об игре. Щелкнув по любой из этих ссылок, вы откроете новую страницу, которая проведет вас через процесс отправки.

На странице «Пакеты» вам нужно будет загрузить все файлы пакета (в формате.xap, .appx, .appxupload и/или .appxbundle) приложения, которое вы отправляете. На этом этапе вы можете загружать пакеты для любой операционной системы, для которой предназначено приложение.

Когда пользователь загружает приложение на устройство, Магазин Windows просматривает все пакеты, доступные для приложения, и автоматически передает на устройство тот пакет, который лучше всего соответствует именно ему.

Чтобы узнать подробнее, что включено в пакет и как он должен быть структурирован, обратитесь к руководству «Требования к пакетам приложения». Вас также могут заинтересовать эти статьи:

Загрузка пакетов для отправки

Чтобы загрузить пакеты, перетащите их в поле отправки или щелкните для просмотра файлов. Страница «Пакеты» позволяет загружать файлы в форматах .xap, .appx, .appxupload и/или .appxbundle.

Примечание. Для Windows 10 всегда загружайте файл .appxupload, но не .appx и не .appxbundle. Чтобы больше узнать об упаковке универсальных приложений Windows для Магазина Windows, ознакомьтесь с руководством: Упаковка универсальных приложений Windows для Windows 10

Если при проверке пакетов возникают ошибки, нужно удалить пакет, исправить ошибки и попробовать загрузить его снова. Чтобы узнать больше, ознакомьтесь с руководством «Устранение ошибок, связанных с отправкой пакетов».

Образец реализации

В этом разделе мы рассмотрим простую 3D-игру Basketball, которую Джей-Би Эвейн (Jb Evain) написал примерно за 20 минут. Если вы хотите создать игру с нуля, вы можете последовать советам, которые дает Джей-Би. Единственный внешний ресурс, который вам потребуется для создания игры — это файл Hoop.3ds.

Также вы можете просто загрузить готовый проектный пакет Basketball-At-Build.zip: он в полном рабочем состоянии. Распакуйте архив и следуйте дальнейшим указаниям в этом разделе.

Вот сцена из готовой игры:

Basketball

Воспользуемся этой игрой, чтобы продемонстрировать весь процесс подготовки игры к отправке в Магазин Windows.

Если вы разрабатываете игру с нуля, выполните следующие шаги. Если вы скачали готовый проект, пропустите шаги с 1 по 8.

  1. Откройте Unity и создайте новый Проект Можете назвать его Basketball или Awesome Game, если хотите.
  2. Создайте сцену игры.
  3. Перетащите файл Hoop.3ds из папки, в которую вы его загрузили, на панель Assets.
  4. Выберите Assets -> Import Packages -> Characters.
  5. Когда ассет загрузится, нажмите кнопку Import, и ассеты будут включены в проект.
  6. Создайте сферу и примените к ней материалы, чтобы она приобрела цвет и свойства.
  7. Разместите компоненты на сцене.
  8. Напишите скрипт Shooter, чтобы можно было бросать мячи в баскетбольную корзину.
  9. На вкладке Проект раскройте дерево Assets и щелкните по папке Scenes.
  10. Дважды щелкните по Игра сцене, чтобы она загрузилась. Прежде чем продолжить, давайте запустим игру и посмотрим, как она работает.
  11. А теперь, когда мы убедились в том, что игра работает, давайте проверим ваше мастерство!

Создание проекта Visual Studio с помощью Unity

После того как вы импортировали и проверили игру в Unity, пора создать проект Visual Studio.

В меню щелкните File -> Build Settings, чтобы открыть окно Build Settings и удостоверьтесь в том, что в списке Scenes In Build выбрана сцена. Обязательно проверьте следующие параметры:

  • ПлатформаWindows Store (если нет, выберите Windows Store -> Switch Platform)
  • SDKUniversal 10.
  • UWP Build TypeXAML.
  • Unity C# Projects и Development Build отмечены флажками.

Затем нажмите на Player Settings и проверьте следующую информацию: игра разработана для режима Landscape. Соответственно, параметр Default Orientation должен быть установлен Landscape. следующим образом:

Затем щелкните кнопку Build из окна Build Settings Вас попросят выбрать папку, в которой вы хотите разместить собранный проект. Там будет создано решение и проект Visual Studio.

Создание пакета приложения и комплекта сертификации при помощи Visual Studio

Поздравляем, вы успешно создали решение Visual Studio. Теперь пора произвести переход и продолжить настройки.

Дважды щелкните по созданному решению.

Visual Studio 2015 откроет три проекта. Не беспокойтесь, если появятся сообщения об ошибках, поскольку Visual Studio загружает ресурсы асинхронно. Просто дождитесь загрузки всех ресурсов и соберите проект в режиме Debug, выбрав Build -> Build Solution из меню.

Теперь:

  1. Проверьте, что сборка прошла успешно.
  2. Переключите режим из Debug, в Master. Это важно, поскольку UWP-приложения следует отправлять в Магазин Windows именно в режиме Master режиме (это режим, в котором для наилучшей производительности удаляются контрольные метки и отключается профайлер).
  3. Выберите Store | Create App Packages... из меню Проект .

Если вы делаете это впервые, или с момента последнего входа прошло несколько дней, вас попросят авторизоваться с учетной записью разработчика Магазина Windows. Чтобы подтвердить допуск, вам понадобится ввести код безопасности.

Если сборка прошла успешно, нажмите кнопку Launch Windows App Certification Kit. Процесс тестирования может занять какое-то время, проверяя, готова ли игра к отправке в Магазин Windows.

Если все пройдет хорошо, вы увидите следующий экран:

Проектирование Unity-игры для UWP

Unity — это развитый инструментарий, позволяющий фокусироваться сразу на нескольких платформах, включая универсальную платформу Windows (UWP). Инструменты Unity способны работать, помимо прочего, с:

  • различными разрешениями и изменением размера экрана;
  • соотношениями сторон экрана.

различными разрешениями и изменением размера экрана;

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

В Unity работает совершенно новая система реализации пользовательского интерфейса, Unity UI. Благодаря этой системе вам больше не понадобятся сторонние плагины, она обеспечивает массу возможностей для создания интерфейса, адаптирующегося под разные разрешения. Очень важно правильно настроить игру и интерфейс, а также проверить их на разных разрешениях. Если вы еще не забыли Windows Forms или WPF, то вы помните, что элементы пользовательского интерфейса можно было закреплять таким образом, чтобы они меняли размер вместе с экраном. Unity предлагает ту же возможность: помимо возможности закрепления, вы можете выбирать, должны ли элементы пользовательского интерфейса менять размер вместе с экраном, или оставаться неизменными.

соотношениями сторон экрана.

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

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

Visual Studio 2015 Tools для Unity

Visual Studio — это полный набор инструментов, которые помогут подготовить Unity-игру к публикации в Магазине Windows. В числе этих инструментов:

  • Unity Project Explorer
  • Создание скриптов и отладка в Visual Studio
  • Graphics Debugger

Инструменты Visual Studio для Unity

Начиная с Unity 5.2, вам больше не нужно отдельно импортировать Visual Studio Tools для Unity. Просто откройте меню Tools -> Extensions and Updates в Visual Studio, чтобы установить их.

В следующем разделе перечислены шаги по установке новейшей версии VSTU, или же алгоритм установки для более ранней версии Unity, чем 5.2. Если вы пользуетесь Visual Studio 2015 с Unity 5.2 или более поздней версии, следующие этапы можно пропустить.

Visual Studio Tools для Unity позволяет создавать и производить отладку Unity-игр средствами Microsoft Visual Studio. Помимо возможности добавлять точки прерывания и оценивать значения переменных и сложных выражений, он предоставляет возможность столь же простого просмотра проекта, как и в Unity Project Explorer в среде Unity. Наконец, консоль вывода в Visual Studio — совершенно такая же, как и в Unity.

Ниже — скриншот установки Visual Studio 2015 Tools для Unity. Примите условия использования, отметив настройку флажком:

По окончании процедуры появится диалоговое окно, указывающее на завершение установки:

Когда установка завершится, нужно будет открыть Unity и добавить инструмент в наш проект.

Вы увидите следующее диалоговое окно Unity. Оставьте все параметры включенными и нажмите на кнопку Import,

После этого в иерархии проекта появится новая папка:

Необходимо удостовериться в том, что настройки Build Settings установлены для Visual Studio именно так, как показано ниже. Должны быть обязательно отмечены флажками настройки Unity C# Projects и Development Build:

Теперь вы готовы писать скрипты и вести отладку при помощи Visual Studio. Помните, что процесс установки необходим только в том случае, если вы используете более раннюю версию Unity, чем 5.2.

Создание скриптов и отладка в Visual Studio

Если вы дважды щелкнете по скрипту в Unity, то запустите Visual Studio. Например, если мы выберем скрипт Shooter.cs и загрузим его в Visual Studio, мы увидим следующее:

Теперь, если нам необходимо отладить вызов GetButtonDown, который инициирует бросание мячей, мы можем поставить точку прерывания на строке 12 и нажать Attach to Unity

Теперь перейдите обратно в Unity. Все, что нужно сделать здесь — нажать кнопку Play, и игра запустится. Поскольку мы знаем, что представляет собой внесенное Обновление кода, то по щелчку левой кнопкой мыши игра сделает паузу на строке 12 в Visual Studio:

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

Graphics Debugger

В Visual Studio 2015 также входит очень мощный графический отладчик, который позволит вам оптимизировать ваши игры.

Во-первых, убедитесь в том, что у вас в системе есть Graphics Tools. Перейдите в «Параметры» Windows и откройте подразделы «Система», Windows и откройте подразделы «Приложения и возможности», Windows и откройте подразделы «Управление дополнительными компонентами». Если они установлены, вы увидите Graphic Tools:

Если у вас их нет, выберите «Добавить компонент» и в списке щелкните Graphics Tools. Пожалуйста, обратитесь в документации MSDN к разделу «Средства диагностики графики», если вы при установке вы столкнулись с какими-либо трудностями.

Вам потребуется сборка Visual Studio из Unity; чтобы воспользоваться Graphics Tools, нужно открыть игру в Visual Studio. Внутри Visual Studio вы можете вызвать этот инструмент из меню, открыв Debug -> Graphics -> Start Graphics Debugging, как показано ниже:

Когда игра запустится, вы увидите следующий пользовательский интерфейс:

Щелкните по значку Capture Frame, чтобы сохранить текущий кадр игры. Так можно сохранить любую часть игрового процесса.

Дважды щелкнув по Frame, вы увидите подробную информацию о текущем кадре. Вы можете перемещаться вперед и назад по вызовам отрисовки в окне Graphics Event List, а также выбирать отдельные пиксели и просматривать их в окне Graphics Pixel History:

Обратите внимание на то, что файл графической диагностики может вырасти до огромных размеров. Чтобы узнать больше, посетите страницу «Обзор диагностики графики Visual Studio».

Создание ресурсов для Магазина Windows

Чтобы отправить приложение в Магазин Window, нужны изображения правильного размера. Именно для этого преднаначено расширение Visual Studio, которое называется UWP Tile Generator. Достаточно выбрать файл, и инструмент сам создаст ZIP-архив с изображениями всех необходимых размеров.

Разница между приложениями Unity и UWP

Для поддержки скриптов Unity использует фреймворк Scripting Backend. На данный момент он поддерживает три среды: Mono, .NET и IL2CPP. Если целевой платформой является Магазин Windows, доступны только .NET и IL2CPP. Вы можете выбрать Scripting Backend, нажав на кнопку Player Settings в окне Build Settings в Unity.

В Unity IDE скрипты на основе .NET ссылаются на .NET версии 3.5. Но когда игры экспортируются в Visual Studio, весь C#-код компилируется для .NET Core, т. е. для .NET версии 4.5. Примечание. (если же вы используете IL2CPP, ваше приложение для Магазина Windows продолжит использовать .NET 3.5). Чтобы проиллюстрировать это, попробуйте написать следующую строку кода в скрипте Unity:

        
          System.Collections.SortedList lst = new SortedList();
        
      

НажмитеF12 при открытом списке SortedList в Visual Studio, чтобы увидеть определение типа. Обратите внимание на то, что этот класс есть в библиотеке mscorlib.

Если вы вставите этот же код в экспортированный проект и нажмете F12 при SortedList выделенном типе, то увидите, что эта версия класса содержит пакет NuGet, который является частью .NET Core.

Ранее это могло приводить к проблемам, когда в .NET 3.5 присутствовали типы или методы, которых нет в .NET Core. В свою очередь, это требовало вспомогательных библиотек, таких как WinRTLegacy, чтобы заполнить пробелы и представить не только типы, но и дополнительные методы.

Совет: Будьте осмотрительны при пользовании руководствами, посвященными несоответствиям типов Unity и .NET Core. Многие из них устарели и могут оказаться неточными.

Понимать основные различия Unity и UWP необходимо, но проблемы с недостающими типами и методами для портирования с .NET 3.5 на .NET Core решаются вместе с наращиванием .NET Core. Например, System.Threading.Tasks, которые впервые появились в .NET 3.5, вошли в .NET Core. Вы также можете испытывать трудности при обратном переносе функций .NET Core, отсутствующих в .NET 3.5.

Стоит упомянуть о том, что при использовании IL2CPP в качестве скриптинг-процессора, API редактора Unity и вашего приложения Магазина Windows становятся одинаковыми.

Функции, характерные для платформы

Поскольку Unity и универсальная платформа Windows — это разные платформы, в портировании между ними есть как плюсы, так и минусы.

Оптимизация производительности

Приложения для UWP используют .NET Native, генерирующую оптимизированный «нативный» машинный код. Это ускоряет время запуска ваших игр и снижает нагрузку на батарею. Эффект оптимизации зависит от сложности вашей игры, но игры Unity, которые используют скриптинг-процессор .NET, обычно получают прирост производительности. В сгенерированном игровом проекте только мастер-сборка компилируется в нативный .NET-код.

Команды

Как вызвать из вашей UWP-игры Toast или Tile? Этого функционала нет в .NET 3.5 — скриптинг-процессоре, который используется при разработке в Unity. В этом случае ваш код будет работать правильно лишь после экспорта в Visual Studio и совсем не будет работать в Unity IDE.

Чтобы обойти эту проблему, Unity используют библиотеку UnityEngine.WSA с такими классами-заглушками, как Application, Cursor, Launcher, Tile и Toast. Вы можете использовать эти типы в ваших скриптах Unity C#, чтобы обеспечить взаимодействие Unity и UWP.

Другой способ вызова функциональности, которой нет в .NET 3.5, заключается в использовании директивы NETFX_CORE в ваших скриптах. Эта директива нужна, чтобы игнорировать участки кода, которые не будут компилироваться в .NET 3.5, но которые потребуются вам, когда игра скомпилируется в .NET Core. Следующий пример, который можно найти в репозитории Unity на bitbucket, показывает, как код, который вызывает фатальный сбой в Unity IDE, может быть пропущен при использовании вызовов.

        
          #if NETFX_CORE
          async
          #endif
          void UpdateTile(byte[] png150x150)
          {
          #if NETFX_CORE
              // In order to change tile image, we should change the uri too
              // in this example we store images in applications local storage
              // we must also take care of cleaning it up
              StorageFolder localFolder = ApplicationData.Current.LocalFolder;
              StorageFolder tilesFolder = null;
              try
              {
                  tilesFolder = await localFolder.GetFolderAsync("tiles");
              }
              catch (Exception)
              { }
              if (tilesFolder != null)
                  await tilesFolder.DeleteAsync();
              tilesFolder = await localFolder.CreateFolderAsync("tiles");
              string tileFile = "tile" + counter++ + ".png";
              StorageFile file = await tilesFolder.CreateFileAsync(tileFile, CreationCollisionOption.ReplaceExisting);
              await FileIO.WriteBytesAsync(file, png150x150);

              string txt = textToTile ? text : "";
              Tile.main.Update("ms-appdata:///local/tiles/" + tileFile, "", "", txt);
          #endif
          }
        
      

Иногда нужно использовать вызов Unity_WSA_10_0 вместо того, чтобы полагаться на NETFX_CORE. Второе, хоть и является вызовом для любого приложения Магазина Windows, Unity_WSA_10_0 особенно часто используется для устройств Windows 10.

Создание плагинов

На плагины также может влиять разница между .NET 3.5 и .NET Core. Иногда код совместим и трудностей не возникает. Когда это не так, Unity, тем не менее, позволяет настроить приложение так, чтобы использовались две разные версии одного плагина, одна для Unity IDE (который основан на .NET 3.5 API), а другая для полной версии игры (которая компилируется на .NET Core).

Для внедрения нескольких плагинов нужно следовать определенным правилам. Ваши плагины должны быть под одним названием и иметь один номер сборки версии. Кроме того, два плагина должны размещаться в разных папках. Например, ваш плагин, совместимый с Editor, разместится в папке ..\Assets\Plugins\MyPlugin.dll, а плагин для UWP — в ..\Assets\Plugins\WSA\MyPlugin.winmd.

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

Выберите Assets\Plugins\MyPlugin.dll в Unity Project Explorer и Editor в качестве платформы.

Затем перейдите в Assets\Plugins\WSA\MyPlugin.winmd и выберите Windows Store Apps как платформу этого плагина.

Чтобы понять этот процесс, давайте проведем сборку набора плагинов.

Откройте Visual Studio 2015 и создайте новый проект под названием MyPlugin. Используйте шаблон проекта Visual C# -> Windows -> Universal -> Windows Runtime Component (также можно использовать шаблон проекта Class Library, но в Windows Runtime Component есть ряд интересных находок: например, его можно использовать из любого окна периода выполнения проекции языка, что дает дополнительные преимущества).

Щелкните по решению правой кнопкой мыши и выберите Add -> New Project. Получится библиотека-заглушка, которая нужна только для редактора Unity. Поскольку она компилируется в .NET 3.5, она создается с использованием шаблона проекта Visual C# -> Windows -> Classic Desktop -> Class Library Назовите этот проект MyPluginStub, поскольку для двух проектов в одном и том же решении нельзя использовать одно имя.

Поскольку обе библиотеки должны называться одинаково, вам нужно настроить файл вывода для MyPluginStub так, чтобы он назывался MyPlugin — так же, как и другой ваш проект. Чтобы сделать это, щелкните по проекту MyPluginStub правой кнопкой мыши в Solution Explorer и выберите Properties. Во вкладке Application замените содержимое полей Assembly Name и Default namespace на MyPlugin, чтобы они соответствовали другому проекту. Кроме того, замените содержимое поля Target framework на .NET Framework 3.5.

Удалите файлы Class1.cs, которые Visual Studio создает для каждого вашего проекта. Затем создайте в MyPlugin Windows Runtime Component новый проект под названием Foo.cs. Мы не будем создавать такой же класс для проекта Windows Desktop, а добавим Foo.cs как связанный файл.

Теперь вы можете редактировать один и тот же файл Foo.cs из проекта MyPlugin и из проекта MyPluginStub. Проверьте файл в редакторе обоих проектов: при просмотре в MyPluginStub в коде появляется красная волнистая линия, добавленная Visual Studio, выделяющая операторы для System.Threading.Tasks. Это происходит потому, что этот тип существует в .NET Core, но его нет в .NET Framework 3.5.

Мы могли бы просто убрать эту строку, чтобы исправить ошибку, поскольку мы не планируем использовать ее. Но вместо этого проверим вызов, чтобы показать, как он работает. Замените оператор, используемый для Tasks, следующими тремя строками кода:

        
          #if NETFX_CORE
            using System.Threading.Tasks;
          #endif
        
      

После этого вы увидите, что проект опять компилируется. Нам все еще нужен метод для класса Foo. Обычно его называют Bar. Метод Bar должен возвращать одно сообщение, если его вызывают из редактора Unity, и другое, если его вызывают из Windows Runtime Component. Добавьте следующую реализацию метода Bar в ваш класс Foo (кроме того, добавьте ключевое слово sealed в раздел объявлений класса, как этого требует Runtime Components).

        
          public sealed class Foo
            {
              public string Bar()
              {
                #if NETFX_CORE
                  return "Windows Store version of the plugin.";
                #endif
                  return "Unity Editor version of the plugin.";
              }
            }
        
      

Соберите обе библиотеки.

Теперь настройте ваш Unity-проект на использование этих библиотек. Откройте проект в Unity, создайте новую папку внутри Assets и назовите ее Plugins. В ней создайте папку WSA (т. е. Windows Store Application). Найдите файл MyPlugins.dll от проекта MyPluginsStub и перетащите его в ..\Assets\Plugins. Затем найдите файл MyPlugins.winmd, который вы скомпилировали, и перетащите в ..\Assets\Plugins\WSA.

Щелкните по Plugins\MyPlugin на панели активов. В инспекторе появится MyPlugin Import Settings. Снимите флажок с Any Platform и выберите Editor. Так IDE узнает о том, что это версия библиотеки, которая должна исполняться из редактора Unity.

Теперь опуститесь на один уровень и выберите Plugins\WSA\MyPlugin. В инспекторе следует выбрать WSAPlayer и ничего более — так Unity узнает о том, что это версия библиотеки, которая должна быть опубликована в Магазине Windows. Перейдите в поле Placeholder и найдите в корневой папке Plugins свою библиотеку-заглушку. Таким образом вы объясните отношения между двумя библиотеками. Plugins\MyPlugin.dll — это заменитель для настоящей библиотеки Plugins\WSA\MyPlugin.winmd.

Пора проверить, правильно ли настроены обе библиотеки в Unity. Создайте в Unity новый скрипт C# под названием TestFooBar. Создайте закрытый экземпляр класса Foo и выпишите значение, возвращаемое методом Bar в Logger.

        
          using UnityEngine;
          using System.Collections;
          using MyPlugin;

          public class TestFooBar : MonoBehaviour {

            private Foo testFoo = new Foo();
             // Use this for initialization
               void Start () {
                  Debug.Log(testFoo.Bar());
                }

            // Update is called once per frame
              void Update () {

              }
            }
        
      

Наконец, перетащите скрипт на один из ваших игровых объектов, например, на Player, чтобы присоединить его. Так мы будем уверены, что метод Start скрипта будет вызван. Запустите игру в Unity и, если все пойдет по плану, в Console появится нужное сообщение.

Наконец, перейдите в Build Settings и нажмите кнопку Build, чтобы экспортировать проект в Visual Studio.

Теперь запустите вашу игру в Visual Studio, и вы увидите в окне вывода Visual Studio следующее сообщение:

На этом примере основано практически все взаимодействие между универсальной платформой Windows и Unity. Если вам удалось добиться правильного сообщения в консоли, вы знаете почти все, что нужно, чтобы инкапсулировать код UWP и получать доступ к нему прямо из игры Unity.

Реклама

Microsoft Ads можно запускать как плагин Unity, загрузив и установив Unity Plugins для Магазина Windows и Azure Services. В плагин также входят API для внутриигровых покупок, проверки лицензий и сверки чеков.

Самый простой способ использования плагинов Unity в Магазине Windows — загрузить пакет Unity с GitHub и импортировать его в ваше приложение при помощи команды Assets -> Import Package -> Custom Packages в редакторе Unity. Как только пакет импортируется, все необходимые двоичные файлы появятся в папках Unity Plugins и Unity Plugins\WSA.

Кроме того вы можете использовать последнее расширение Microsoft Store Engagement and Monetization SDK из экспортированного приложения UWP для показа баннерной рекламы и рекламных видеовставок. Microsoft Store Engagement and Monetization SDK интегрирован в рекламную функциональность Microsoft Universal Ad Client SDK вместе с остальными функциями, относящимися к сервисам Магазина, и устанавливается вместе с ними.

Analytics

Сбор аналитики об игроках может выполняться как через платформу Unity, так и через универсальную платформу Windows. Вы также можете использовать обе платформы, чтобы собирать данные параллельно. Чтобы пойти путем Unity, нужно связать проект с Unity Services ID и затем подключить аналитику проекта. Чтобы узнать больше, обратитесь к документации Unity.

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

  • Покупки
  • Работа
  • Оценки
  • Отзывы
  • Обратная связь
  • Использование
  • Встроенные покупки
  • Работа с рекламой
  • Эффективность рекламы
  • Реклама, связанная с установками
  • Каналы и конверсия

Кроме того, вы сможете просматривать телеметрию игры, если эта возможность включена.

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

Встроенные покупки (IAP)

Поскольку игры Unity, экспортированные в на универсальную платформу Windows (UWP), по сути основаны на двух платформах, Unity и UWP, у вас есть два способа включения встроенных покупок: Unity IAP или Unity Plugins для Магазина Windows и Azure Services.

Чтобы пользоваться Unity IAP, настройте Unity Services Project ID в окне Services в Unity. Вам придется пройти через ряд диалоговых окон, чтобы подключить встроенные покупки для Магазина Windows. Дополнительная информация доступна на сайте Unity. Помните, что Unity IAP не будет работать без скриптинг-процессора IL2CPP.

Вместе с плагинами Unity для Windows Store вы используете Store API, чтобы получать свои листинги из файла скрипта Unity. Сначала необходимо создать для ваших приложений товары при помощи Центра разработчиков Магазина Windows. После этого можно обновить приложение, добавив в него товары из списка, и подключить встроенные покупки. Основной вызов делается через плагин и позволяет включить LoadListingInformation метод для получения товаров, (см. образец кода ниже).

        
          Store.LoadListingInformation((response) =>
          {
            if (response.Status == CallbackStatus.Failure)
              {
                prettyPrintErrors("LoadListingInformation", response);
                return;
              }

            prettyPrintSuccess("LoadListingInformation", response);
            text.text = "\nFinished Loading Listing Information" + text.text + "\n";
            Debug.Log(response.Result.Description.ToString());
            foreach (var productListingKey in response.Result.ProductListings.Keys)
              {
                Debug.Log("Key: " + productListingKey + " value: " + response.Result.ProductListings[productListingKey].Name);
              }
          });
        
      

Полный пример внедрения, демонстрирующий использование Store API, можно найти на GitHub.

Наилучшие методики

В основном ваша игра завершена, однако есть еще пара моментов, которые сделают ее еще лучше. В этом разделе мы расскажем о методиках, которые помогут вам в отправке приложения в Магазин Windows.

Заставочный экран и индикатор загрузки

В процессе загрузки игры важно показывать индикатор загрузки, чтобы пользователь знал, что игра не зависла.

Мы подразумеваем, что вы делаете проект на XAML. Если это не так, большую часть полученной информации вы сможете применить для проекта и на DirectX, но процесс будет несколько иным.

Существует два главных этапа загрузки игры:

  1. Заставочный экран приложения.
  2. Расширенный заставочный экран.

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

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

Обычно сцена Unity загружается довольно долго. Чтобы создать расширенный заставочный экран, вы можете использовать XAML для показа того же заставочного экрана с индикатором загрузки, пока загружается сцена Unity. В файле MainPage.xaml добавьте индикатор загрузки рядом с картинкой заставочного экрана.

        
          <SwapChainPanel x:Name="DXSwapChainPanel">
            <Grid x:Name="ExtendedSplashGrid" Background="#222C37">
              <Image x:Name="ExtendedSplashImage" Source="Assets/SplashScreen.png" 
                VerticalAlignment="Center" HorizontalAlignment="Center"/>
              <ProgressBar x:Name="SplashProgress" Foreground="#FFFFFFFF" 
                Background="#FF333333" Maximum="10000" Width="320" Height="25"/>
            </Grid>
          </SwapChainPanel>
        
      

В файле MainPage.xaml.cs — это файл пользовательского интерфейса XAML — используйте конструктор, чтобы запустить таймер, который заставит индикатор загрузки выводить пользователю изменения.

Форм-фактор устройства

Главная особенность универсальной платформы Windows (UWP) — единая база кода для всех форм-факторов. И все же таким продуктам, как игры, все еще может требоваться дополнительная настройка и оптимизация для некоторых форм-факторов. Чаще всего приходится настраивать средства ввода (например, сенсор, клавиатуру, мышь, геймпад), менять размеры окон, оптимизировать ресурсы и ассеты и внедрять интеграцию с платформой для каждого форм-фактора.

Поддержка ориентации

Поскольку новые устройства в основном ориентируются на использование широкого экрана, редактор Unity по умолчанию экспортирует проекты в ландшафтной ориентации. Если ваша игра поддерживает портретную ориентацию, вам придется изменить манифест приложения в Visual Studio, так как в редакторе Unity это сделать нельзя.

Чтобы отредактировать манифест, дважды щелкните по файлу Package.appxmanifest в корневой папке проекта Windows Store Visual Studio. В редакторе манифестов выберите ориентации, которые необходимо поддерживать.

API ориентации (Input.deviceOrientation и Screen.orientation) хорошо работают в Unity. Вы можете использовать их, чтобы запрашивать ориентацию устройства и даже задавать ориентацию для определенных сцен.

Поддержка окон

Приложения для универсальной платформы Windows (UWP) выводятся в окнах с изменяемыми размерами, а не на полный экран, как это было в Windows 8 и 8.1, поэтому поддержка окон теперь важна в том числе для игр и приложений.

Большая часть этих различий будет вполне понятна разработчику Unity, поскольку параметры Screen.height и Screen.width по-прежнему выдают информацию о доступной площади в пикселях.

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

Пауза и возобновление игры

В Windows движок Unity обычно автоматически делает паузу в игре и возобновляет игру, когда неизвестно текущее окно. Если вам необходимо сделать паузу, не прибегая к автоматическому механизму паузы, например, во время навигации между XAML-страницами, вызов метода UnityPause может решить проблему.

Если в тот момент, когда приложение ставится на паузу, нужно сделать что-то еще, обратный вызов OnApplicationPause в скриптах подойдет лучше.

Ввод с геймпада и мыши

Семейство устройств Windows поддерживает широкий выбор устройств ввода, от клавиатуры и мыши до сенсоров и геймпадов. К счастью, все эти режимы ввода не только прекрасно поддерживаются Unity, но и хорошо абстрагированы при помощи средства Input Manager.

Управляя движением игрока в нашей игре Basketball, мы ждем ввода по оси Fire 1, чтобы выполнить бросок мяча.

        
          void Update()
            {
              if (Input.GetButtonDown("Fire1"))
              {
                var instance = (Rigidbody)Instantiate(this.prefab, transform.position 
                        + (transform.forward * 1.05f), transform.rotation);
                instance.velocity = (transform.forward + transform.up / 2) * this.speed;
              }
            }
        
      

Значение Fire 1 по умолчанию присвоено и левой кнопке мыши, и кнопке геймпада и мини-джойстика, как показано ниже в Input Manager. Чтобы увидеть Input Manager в Unity IDE, выберите Edit -> Project Settings -> Input.

На контроллере Xbox One кнопка мини-джойстика 0, которая отмечена как Fire1 — это кнопка A. Есть и другие способы ввода, которые отмечены в компоненте FPSController как движение и прыжки. По умолчанию для перемещения игрока служат движения мыши, клавиши «влево», «вправо», «вверх» и «вниз», а также A, D, S, W и левый мини-джойстик геймпада Xbox One. Правая кнопка мыши, пробел и кнопка B геймпада нужны для прыжков.

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

Заключение

Из этого документа вы узнали, как настроить и экспортировать игру с Unity в проект для универсальной платформы Windows (UWP) на Visual Studio. Мы также рассказали вам, как подать заявку на публикацию вашей UWP-игру в Магазин Windows, выделили ряд различий между платформой Unity и Universal Windows Platform, рассказали о коде и функциональности платформы, которые вы должны знать как разработчик игр. Наконец, в этом документе рассказано о наилучших методиках, которые помогут довести игру до совершенства перед выпуском.

Ссылки

Наверх
Согласен

Мы используем cookie-файлы, чтобы вам было удобнее работать с нашим веб-сайтом. Подробные сведения смотрите на странице политики обработки cookie-файлов.