Как сделать рестарт уровня в unity

Обновлено: 03.07.2024

Вам когда-либо приходилось думать над тем, как сделать управление сценами в вашем проекте менее болезненным? Когда у вас достаточно простая игра, в которой всего несколько сцен идущих одна за другой, то, зачастую, всё проходит гладко. Но когда количество сцен растёт и усложняются переходы между ними — они могу загружаться в разном порядке и поведение некоторых из них должно зависеть от входящих параметров — задача становится менее тривиальной.

Ниже несколько подходов к ее решению, которые мне приходилось видеть чаще всего:

  • Файлы — при переходе из одной сцены в другую, все необходимые данные записываются в JSON/XML файл, а когда следующая сцена загрузилась, считывают их обратно. Как минимум, это медленно (говоря о чтении и записи в файл), да и процесс дебага становится менее удобным.
  • Огромный статический класс, который обрабатывает все возможные переходы между сценами. Они очень похожи на божественные объекты и довольно часто являются причиной утечек памяти, а также боли в нижней части спины, когда новый разработчик пытается понять, что вообще происходит в этой тысяче строк статического кода.
  • DontDestroyOnLoad GameObject — этот подход похож на предыдущий, но представлен GameObject'а в сцене с кучей ссылок в Инспекторе. По сути, это один из тех синглтонов, которые каждый из нас видел в большинстве проектов.

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

В каждой сцене у меня есть SceneController . Он отвечает за проброс всех необходимых ссылок и инициализацию ключевых объектов. В некотором смысле, его можно считать точкой входа сцены. Для представления аргументов я использую класс SceneArgs и у каждой сцены есть свой класс, представляющий ее аргументы и являющийся наследником SceneArgs .

Как я уже написал выше, у каждой сцены есть свой контроллер, который наследуется от SceneController .

Я использую отдельный класс для представления аргументов по одной простой причине. Изначально, метод загрузки сцены принимал аргументы в виде массива объектов params object[] args . Это был унифицированный способ для загрузки любой сцены с возможностью передать аргументы. Когда контроллер сцены получал управление, он парсил этот массив объектов и получал все необходимые данные. Но, кроме банального боксинга, здесь была ещё одна проблема — ни для кого, кроме разработчика, который писал этот контроллер (а со временем и для него самого) не было очевидно, какого типа аргументы и в каком порядке нужно передать, чтобы потом не возникло ошибок кастинга. Когда мы создаём новый метод, то в его сигнатуре указываем порядок и типы аргументов и затем IDE может нам подсказать, если при его вызове мы допустили ошибку. Но с аргументом params object[] args мы видим лишь то, что нужно передать массив аргументов и каждый раз, чтобы понять их порядок и типы, разработчику нужно лезть в код контроллера и смотреть как же они парсятся. Мне хотелось сохранить метод запуска таким же унифицированным (один метод для запуска любой сцены), но при этом дать возможность жестко ограничить типы аргументов для каждой из сцен. И для этого нужны ограничения where , которые есть в SceneController .

Как известно, мы должны каждый раз передавать name или buildIndex сцены, чтобы загрузить её через метод LoadScene() или LoadSceneAsync() в Unity API. Этого хотелось бы избежать, потому я использую кастомный атрибут SceneControllerAttribute , чтобы привязать конкретный контроллере к конкретной сцене. Здесь используется имя сцены, а не её buildIndex лишь по той причине, что, на моём опыте, оно реже подвергается изменениям.

Допустим, у нас есть сцена MainMenu . В таком случае, классы её аргументов и контроллера будут иметь следующий вид:

Собственно, это всё (из того, что касается контроллера сцены и её аргументов). Осталось лишь понять, как происходит переход от одной сцены к другой. Этим занимается внезапно статический класс SceneManager . Очень важно, чтобы он был как можно меньше, проще и понятнее. Чтобы он не превратился в один из тех ненавистных божественных объектов с тоннами зависимостей. У него всего лишь одна простая задача — передать управление от контроллера одной сцены к контроллеру следующей. За все последующие инициализации и прочее отвечает уже сам контроллер.

Позвольте мне немного объяснить этот код. При вызове OpenSceneWithArgs() вы передаёте тип контроллера ( TController ) сцены, которую нужно загрузить, тип параметров ( TArgs ) и, собственно, сами параметры ( sceneArgs ). В первую очередь, SceneManager проверяет, есть ли у TController атрибут SceneControllerAttribute . Он должен быть, потому именно он определяет, к какой сцен привязан контроллер TController . Дальше мы просто добавляем аргументы sceneArgs в словарь. Если не было передано каких-либо аргументов, мы создаём экземпляр типа TArgs и присваиваем его свойству IsNull значение true . Если всё прошло гладко, то будет вызван метод из Unity API LoadSceneAsynс() и ему будет передано имя сцены, которое берётся из атрибута SceneControllerAttribute .

Загружается следующая сцена и у её контроллера вызывается метод Awake() . Дальше, как видим в SceneController , TController вызывает SceneManager.GetArgs() , чтобы получить аргументы, которые были переданы и записаны в словарь, а затем производит все необходимые инициализации.

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

Есть несколько методов, используемых для создания меню в Unity, два основных из которых — встроенная система графического интерфейса и использование GameObjects с коллайдерами, которые реагируют на взаимодействие с мышью. С графической системой Unity может быть сложно работать, поэтому мы собираемся использовать подход GameObject, который, я думаю, также более интересен для достижения наших целей.

Окончательный результат предварительного просмотра

Шаг 1: Определите разрешение вашей игры

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

Единый учебник меню UI

Шаг 2: Выбор фона меню

Как вы уже видели в превью, сцена нашего меню будет иметь нашу игровую среду в фоновом режиме, поэтому при нажатии кнопки Play вы легко войдете в игру.

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

Единый учебник меню UI

Давайте теперь приступим к созданию сцены меню!

Шаг 3: Создание сцены меню

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

Шаг 4: Настройка параметров сборки

Шаг 5: Добавление кнопки воспроизведения

Наконец, добавьте Box Collider через верхнее меню: Компонент> Физика> Box Collider. Измените размер Box Collider, чтобы он соответствовал тексту, если он ему не подходит.

Единый учебник меню UI

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

Единый учебник меню UI

Единый учебник меню UI

Так что наша кнопка Play все настроена. Теперь давайте заставим это играть!

Шаг 6: скрипт обработчика мыши

Читайте также: