Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

ВВЕДЕНИЕ

Компьютерные игры появились более полувека назад. С тех пор, игры изменились очень сильно. Вместе с играми развивалось и аппаратное обеспечение, от которого зависели игры. Игры, которые создаются в наше время нельзя было бы запустить на компьютерах того времени, как минимум, из-за недостатка мощности [1].

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

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

Разработка игрового приложения до сих пор остаётся актуальной темой, так 25% приложений в App Store (iOS) являются играми [2]. Ситуация на других платформах примерно такая же.



1. АНАЛИТИЧЕСКИЙ ОБЗОР

1.1 Обзор платформ

На конец 2018 года общая стоимость игрового рынка составила 134,9 млрд. долларов, из них [3]:

? 63,2 млрд. долларов (47%) мобильные устройства;

? 33,4 млрд. долларов (25%) персональные компьютеры;

? 38.3 млрд. долларов (28%) игровые консоли.

На январь 2019 года количество мобильных устройств стало больше персональных компьютеров, количество игровых консолей очень мало, меньше одного процента, количество планшетов немного меньше четырёх процентов [4]. На основе этого можно сделать вывод, что приоритетными платформами для разработки будут:

? мобильные устройства (48,21%);

? персональные компьютеры (47,96%).

1.2 Обзор операционных систем

Среди мобильных операционных систем можно выделить следующие:

? Android (74,15%);

? iOS (23,28%).

Среди операционных систем настольных компьютеров можно выделить [6]:

? Windows (74,44%);

? OS X (13,22%).

Для начала следует реализовать игровое приложение для наиболее многочисленных операционных систем, то есть для Android и Windows, а уже после, возможно, для iOS и OS X.



1.3 Обзор жанра

игра жанр лабиринт операционный

Жанром разрабатываемого игрового приложения был выбран жанр лабиринт.

Лабиринт -- это жанр компьютерных игр, характеризующийся тем, что успех игрока определяется в основном навигацией и ориентацией в лабиринте [7].

Обычно лабиринт представлен в одном из следующих видов: сверху (рисунок 1.1), сбоку (рисунок 1.2) или от первого лица (рисунок 1.3).

Рисунок 1.1 - Лабиринт в игре Pac-Man



Рисунок 1.2 - Лабиринт в игре Lode Runner

Рисунок 1.3 - Лабиринт в игре Doom

В некоторых играх игрок может изменять лабиринт: открывать или закрывать проходы, делать дыры или создавать туннели в лабиринте. Есть игры, в которых игрока преследует враг в лабиринте, но это не является обязательным условием.

Игровой персонаж -- объект, перемещающийся в лабиринте под воздействием игрока.

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

1.4 Обзор аналогов

Кроссплатформенных решений не было найдено.

В первую очередь рассмотрим игры под операционную систему Android.

Первым аналогом будет игра «Лабиринты и многое другое» от разработчика Leo De Sol Games [8]. Игра отличается минимальной 2D графикой. Игровой персонаж в лабиринте передвигается по контрольным точкам (точкам, в которых игроку нужно выбрать, куда двигаться). Контрольным точками являются начальная позиция, тупик, перекрёсток. Игрок с помощью пальца простым движением по экрану в направлении, куда хочет двигаться, определяет направление, в котором будет передвигаться игровой персонаж до следующей контрольной точки.

Все лабиринты в игре сделаны вручную, ни один лабиринт не сгенерирован случайным образом.

В игре представлено несколько режимов. Для каждого режима представлено 100 уровней нарастающей сложности.

Классический режим (рисунок 1.4) представляет собой простой двумерный лабиринт с видом сверху, где нужно просто дойти до выхода.



Рисунок 1.4 - Классический режим игры

Режим темноты (рисунок 1.5) представляет собой классический режим с ограниченной областью видимости вокруг игрока и показом местоположения выхода. Управление не изменено, так что очень сложно понять, в какую точку переместится игровой персонаж.

Режим с врагами (рисунок 1.6) представляет собой классический режим с циклами (из одной точки в другую можно переместиться разными путями) и врагами. Циклы нужны для того, чтобы обмануть врага. Враг пойдёт по одному пути, а игрок должен передвинуть игрового персонажа по другому пути, чтобы избежать врага и достичь выхода. Из минусов данного режима можно ответить долгое ожидание момента, когда враг окажется в цикле или тупике, чтобы обойти его. При игре были ситуации, когда лабиринт невозможно пройти из-за того, что враг быстро ограничил область, доступную игроку.



Рисунок 1.5 - Режим темноты

Рисунок 1.6 - Режим с врагами

Режим с ловушками (рисунок 1.7) представляет собой классический режим, в котором в лабиринт добавлены ловушки. Ловушки выпускают в одном направлении снаряды. При попадании снаряда в игрового персонажа, игрок проигрывает. Из-за управления по контрольным точкам, на контрольных точках игровой персонаж останавливается, что плохо сказывается на игровом процессе, если эта контрольная точка проходит на пути прохождения снаряда от ловушки.

Рисунок 1.7 - Режим с ловушками

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



Рисунок 1.8 - Режим с ограничением времени

Вторым аналогом будет игра «Лабиринт» (рисунок 1.9) от разработчика Evgeny Karavashkin [9].

В этой игре игровой процесс представлен в трёхмерном пространстве от третьего лица в двумерном лабиринте.

Рисунок 1.9 - Игровой процесс в игре «Лабиринт»

Управление в игре является свободным в отличии от предыдущего аналога. Перемещение по лабиринту возможно с помощью стиков (элемент управления, которым указывается вектор-направление) или с помощью гироскопа. В игре присутствуют графические дефекты. Например, несоединённый стенки. Присутствует возможность выбора текстуры игрового персонажа. Сложность лабиринтов нарастает с уровнями. В отличии от предыдущего аналога в этой игре лабиринт генерируется случайным образом.



2. ТЕХНИЧЕСКИЕ ПРЕДЛОЖЕНИЯ

Для разрабатываемого игрового приложения можно выделить следующие требования:

? игра в жанре лабиринт;

? поддержка операционных систем Android и Windows;

? лабиринт двумерный (перемещение в многомерных лабиринтах будут неудобны для игроков);

? вид сверху (вид от третьего лица неудобен для пользователей мобильных приложений);

? случайная генерация лабиринта (необходимо для режима, в котором параметры генерируемого лабиринта будет задавать игрок, также чтобы не создавать каждый лабиринт самому, так как на это уйдёт колоссальное количество времени на создание каждой ячейки и соединение их между собой и так для каждого лабиринта);

? лабиринт может состоять как из квадратных или прямоугольных ячеек, так и из шестиугольных ячеек;

? присутствие классического режима из первого аналога;

? присутствие улучшенного режима темноты из первого аналога;

? присутствие свободного режима игры, в котором игрок может настроить размеры лабиринта и режимы;

? несколько способов управления персонажем (кнопками клавиатуры на Windows, свайпами на Android);

? плавное анимированное перемещение игрового персонажа по лабиринту;

? генераций лабиринтов любых размеров;

? присутствие кампании из нескольких уровней, поделённые на секции для каждого режима (иногда с несколькими режимами, если те совместимы).



3. ОБЗОР ТЕХНОЛОГИЙ

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

? Allegro;

? SFML;

? LibGDX;

? MonoGame.

Вот несколько известных игровых движков:

? Cocos2D-X;

? CryEngine;

? Unreal Engine;

? Unity.

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

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

? не нужно писать основной цикл программы (обновление и отрисовка);

? не нужно работать с графикой через код;

? удобная работа с файлами (изображениями, звуковыми файлами, 3d-моделями и т.д.);

? удобная работа с анимациями;

? упрощённая разработка для нескольких платформ;

? продвинутые инструменты отладки.

Для разработки под Android требуется использовать Android SDK. По статистике распространения версий Android на 26 октября 2018 года доля версий ниже 4.4 равна 3,5% [10].

4. ВЫБОР ТЕХНОЛОГИЙ

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

Cocos2D-X поддерживает разработку под Windows, Android, а также под OS X и iOS [11].

CryEngine поддерживает разработку под Windows, но не поддерживает разработку под Android, OS X и iOS [12], так что рассматривать его как игровой движок для разработки планируемого игрового приложения не имеет смысла.

Unity поддерживает разработку под Windows, Android, а также под OS X и iOS [13].

Unreal Engine поддерживает разработку под Windows, Android, а также под OS X и iOS [14].

В итоге остаются следующие игровые движки:

? Cocos2D-X;

? Unreal Engine;

? Unity.

Cocos2D-X и Unreal Engine используют для разработки язык программирования C++, а Unity использует язык программирования C#.

Скорость разработки небольших проектов на C# больше, чем на C++. Размер готовой игры будет больше на Unreal Engine, чем на Cocos2D-X и Unity.

Порог вхождения в разработку на C++ выше чем порог вхождения на C#.

При разработке на C# разработчик будет только выделять память, а сборщик мусора будет освобождать память, когда выделенный блок памяти более не нужен. При разработке на C++ придётся контролировать полностью работу с памятью: выделять и освобождать [15]. Придётся следить за памятью, может возникнуть такая проблема, как утечка памяти.

Unreal Engine при работе потребляет большой оперативной памяти чем Unity.

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

Unity -- межплатформенная среда разработки компьютерных игр. На Unity можно разрабатывать под более чем 20 различных операционных систем, таких как [13]:

? Windows;

? OS X;

? Linus;

? Xbox One;

? Wii;

? Wii U;

? PlayStation 3;

? PlayStation 4;

? PlayStation Vita;

? iOS;

? Android;

? WebGL;

? Tizen;

? Facebook;

? TvOS;

? Nintendo Switch.

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

Будем использовать последнюю версию Unity. На момент написания, это версия 2019.1.4f.

Unity поддерживает для разработки два языка программирования: C# и JavaScript (модификация). До версии 5 была поддержка языка программирования Boo, диалекта Python. Расчёты физики производит физический движок PhysX от NVIDIA.

Чаще всего разработчики на Unity используют C# как язык программирования, а не JavaScript. На это есть несколько причин:

? разработчик имеет больше опыта в разработке на C# и ему подобных языков программирования;

? большинство разработчиков, которые разрабатывают что-либо на Unity используют C#, что означает большее количество примеров кода;

? в Visual Studio есть поддержка Unity, которая упрощает написание и отладку кода (при написании можно использовать IntelliSense, а отладка ничем не отличается от отладки обычного приложения на C#).

C# -- объектно-ориентированный язык программирования. Используется как один языков программирования для платформы .NET Framework, .NET Core и в будущем просто .NET, которые имеют открытый исходный код. C# является мультипарадигмальным: объектно-ориентированным, обобщённым, процедурным, функциональным, событийным и рефлективным [16].

В качестве среды разработки выбрана Visual Studio 2019 Community. У неё есть плагин для продвинутой работы с Unity. Среда разработки поддерживает технологии IntelliSense (технология автодополнения кода), возможностью рефакторинга кода, подсветкой синтаксиса и многим другим.

Для разработки под Android будем использовать Android SDK, связанную с версией 4.4, то есть Android SDK 19, так как более 99% устройств поддерживают эту версию Android SDK.

Для рисования текстур игрового приложения применялся графический редактор GIMP.



5. РАЗРАБОТКА ТРЕБОВАНИЙ

Приложение должно поставляться в двух пакетах: пакет установки для Windows и пакет установки для Android.

Минимально поддерживаемая операционная система для Windows: Windows 7 SP1.

Минимально поддерживаемая операционная система для Android 4.4.

Для работы приложения необходимо 128 Мбайт оперативной памяти.

Время загрузки приложения не более 10 секунд на любой платформе.

Для операционной системы Windows видеокарта должна поддерживать DirectX 10 или выше.

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

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

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



6. РАЗРАБОТКА АРХИТЕКТУРЫ

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

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

6.1 Разработка сцены меню

Сцена меню будет состоять из трёх компонентов-экранов:

? главное меню;

? экран кампании;

? экрана настройки режима свободной игры.

На рисунке 6.1 представлена схема переходов между экранами и выходами из сцены.



Рисунок 6.1 - Схема переходов меню

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

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

Наиболее важным компонентом является холст (Canvas). Он отвечает за отрисовку элементов интерфейса на экране. С помощью него мы настраиваем, чтобы интерфейс одинаково выглядел на всех разрешениях экрана, будто HD или FullHD.

Дочерними элементами холста сделаны компоненты-экраны. Для каждого из них добавлен скрипт обработки событий элементов интерфейса соответствующего экрана. Скрипты обработки:

? MainMenuHandler - обработчик главного меню;

? CampaignHandler - обработчик экрана кампании;

? FreePlayHandler - обработчик экрана настроек свободного режима.

Все обработчики наследуются от абстрактного класса, содержащего метод переключения на другой компонент-экрана.

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

UML-диаграмма этих четырёх классов представлена на рисунке 6.2.

В главном меню будут представлены следующие элементы управления:

? кнопка перехода к экрану кампании;

? кнопка перехода к экрану настройки свободного режима;

? кнопка выхода.

Рисунок 6.2 - UML-диаграмма классов обработки меню

На экране кампании будут представлены следующие элементы управления:

? кнопка возврата к главному меню;

? несколько кнопок для выбора уровня.

Помимо возврата по нажатию кнопки возврата к главному меню имеется возможность нажать кнопку «Escape» или кнопку «Назад» Android-устройства.

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

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

? кнопка возврата к главному меню;

? слайдер настройки ширины лабиринта;

? слайдер настройки высоты лабиринта;

? флаг настройки режима (темноты или классический);

? флаг выбора формы ячейки (прямоугольная или четырёхугольная);

? кнопка перехода к игровому процессу.

Слайдеры принимают дискретные значения от 10 до 100 с шагом 5. Каждый слайдер имеет над собой подпись, а справа получаемое значение. Слайдеры были выбраны для ввода значений по той причине, что их легче использовать чем поля ввода на персональных компьютерах, и тем более на Android-устройствах.

При нажатии на кнопку перехода к игровому процессу происходит применение настроек из элементов управления к генерируемому в игровом процессе лабиринту и переход к нему.

Уровни кампании хранятся в проекте как ресурс и поставляются вместе с приложением. Ресурс представляет собой файл в формате JSON. JSON был выбран по причине того, что является более читаемым чем XML или YAML. Unity имеет свой внутренний обработчик JSON документов, поэтому в приложении применялся он. Использование Newtonsoft JSON, самого популярного и быстрого фреймворка с открытым исходным кодом для работы с JSON документом невозожмно по причине его несовместимости с Unity. Для каждого уровня хранится следующая информация:

? тип ячеек: «R» для прямоугольных ячеек и «H» для шестиугольных;

? высота лабиринта, представленная числом;

? ширина лабиринта, представленная числом;

? семя генератора случайных чисел для генерации лабиринта;

? режим: «false» для классического режима и «true» для режима тьмы.

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

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

6.2 Разработка сцены игрового процесса

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

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

В зависимости от настроек, выбранных в сцене меню, будут определены ширина и высота лабиринта.

Перед созданием ячеек определяются размер ячейки, размер стенки ячейки, размер угла ячейки, направления (для которых определяется угол поворота и вектор-направление).

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

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

Для того, чтобы указать направление передвижения игрока на Android-устройстве нужно просто сделать свайп в нужном направлении. Свайп - это специальный жест, когда пользователь кладёт палец на сенсорный экран и ведёт его в нужном направлении. Обычно, свайп заканчивается, когда пользователь отпускает палец от экрана. Направление свайпа «округляется» до ближайшего направления, в котором игрок мог бы переместиться из ячейки, из которой можно переместить в любом из возможных направлений. Если в указанном пользователем направлении перемещение невозможно, игрок остаётся в той же ячейке.

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

? «D» для перемещения вправо;

? «W» для перемещения вверх;

? «A» для перемещения влево;

? «S» для перемещения вниз.

Для перемещения в шестиугольном лабиринте используются следующие кнопки (кнопки «W» и «S» выполняют те же функции):

? «D» для перемещения вправо-вниз;

? «E» для перемещения вправо-вверх;

? «Q» для перемещения влево-вверх

? «A» для перемещения влево-вниз.

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

При перемещении игрок перемещается плавно от ячейки к ячейке. При этом, если он движется по полосе, то он крутится в против часовой стрелки, иначе по часовой стрелке.

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

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

Если игрок проходил уровень кампании, то после прохождения он возвращается к экрану кампании. Также он может вернутся с помощью кнопки «Escape» или кнопки «Назад» на Android-устройстве.

Если игрок проходил уровень свободной игры, то после прохождения для него начинается новый случайный уровень с той же шириной, высотой, типом ячеек и режимом). Игрок может выйти из игрового процесса в данном случае только с помощью кнопки «Escape» или кнопки «Назад» на Android-устройстве.



7. РАЗРАБОТКА КОДА

Разработка приложения проходила по методологии объектно-ориентированного программирования [17], с учётом таких принципов как:

? абстрагирование -- использование тех характеристик объекта, которых достаточно для его представления в системе;

? инкапсуляция -- ограничение доступа одних компонентов системы к другим, а также связь данных с методами, предназначенными для их обработки;

? наследование -- концепция повторного использования особенностей одних объектов в других;

? полиморфизм -- способность объектов и методов обрабатывать разные типы данных.

Под объектами в языке программирования C# понимаются классы и интерфейсы. В разрабатываемом приложении имеется множество классов. Далее они будут рассмотрены.

Исходный код приложения и файл-ресурс с уровнями кампании находятся в приложении 1.

Класс направление (Direction) - это класс, представляющий направление в двухмерном пространстве. Он имеет следующие поля:

? Id - идентификатор: по нему различаются направления и все сравнения направлений производятся с его помощью;

? Vector - трёхмерный вектор в двухмерном пространстве (координата z равна нулю): представляет собой нормализованный вектор-направление (единичный вектор);

? Angle - угол поворота в радианах, по модулю не превышает число Пи: представляет собой угол поворота направления;

? Quaternion - поворот: не стоит путать с Angle, Quaternion имеет тип из Unity и используется для поворота объектов Unity;

? directions - приватное поле-массив, содержащее все направления, включая самого себя.

Поле directions используется для получения следующего направления, предыдущего направления и противоположного, зная текущий, для этого используются методы Next(), Previous() и Opposite().

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

Для создания направлений существует статический метод CreateDirections(Int32 count), где count - это количество направлений. Метод возвращает список созданных направлений в порядке от 0° и против часовой стрелки.

Для работы с лабиринтом был разработан класс система лабиринта (MazeSystem). Этот класс содержит в себе следующие шаблоны (Prefab):

? TilePrefab - шаблон ячейки;

? WallPrefab - шаблон стены ячейки;

? WallEdgePrefab - шаблон углового элемента ячейки.

Система лабиринта определяется количеством направлений (DirectionCount), вышеперечисленными шаблонами, используемыми при генерации, и клавишами, отображаемыми в направления, применяемые для персональных компьютеров при управлении с клавиатуры. Есть также вычисляемые поля, которые применяются во внутренней логике приложения (расчёт размеров шаблонов, других полей), так и во внешней (в классе лабиринта).

Система лабиринта содержит следующие методы:

? Initialize - инициализация всех полей класса;

? GetDirection - получение экземпляра класса направления по индексу, при этом индекс должен быть от нуля до количества направлений не включительно;

? GetInputDirection - получение экземпляра класса направления, которые получается при вводе (клавиатурой на персональных компьютерах или свайпами на Android-устройствах), при этом, если ввода не было, возвращается null.

Прежде чем перейти к классу лабиринта, следует рассмотреть класс ячейки (Tile) и класс игрока (Player). Этот класс содержит несколько полей. Четыре поля являются коллекциями типа словарь (Dictionary), отображающими направление на какой-либо объект:

? NearTiles - отображение направления на ячейку, находящуюся рядом, не обязательна возможность перехода в эту ячейку из текущей;

? ConnectedTiles - отображение направления на ячейку, в которую возможен переход из текущей, если можно перейти в ячейку, то она находится рядом;

? Walls - отображение направления на игровой объект-стенку, стенка существует в том направлении, в которое возможен переход из текущей ячейки;

? WallEdges - отображение направления на игровой объект-угол ячейки, угол ячейки, направление при этом принято считать повёрнутым на половину угла между двумя соседними направлениями.

Также ячейка содержит следующие четыре поля:

? Content - поле типа содержимое ячейки (TileContent), может быть null или ссылаться на экземпляр какого-либо наследника класса TileContent;

? Opacity - вещественное поле, определяющее прозрачность ячейки;

? Visible - логическое поле, определяющее видна ли ячейка;

? Animator - поле класса аниматор (Animator) библиотеки Unity, применяется для анимации.

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

Класс содержимое ячейки является абстрактным и содержит поле Tile - ссылка на ячейку, к которой принадлежит содержимое ячейки, и абстрактный метод Run, в который передаётся лабиринт.

Единственным наследником от этого класса является класс выход (Exit), в переопределённом методе Run которого активируется триггер Win аниматора игрока, по которому начинается анимация победы игрока, после которой происходит выход из уровня или перегенерация лабиринта в зависимости от того уровень чего это был (кампании или свободного режима).

Класс игрока (Player) используется для взаимодействия игрока с лабиринтом. Класс содержит четыре поля:

? tile - текущая ячейка игрока, при установке на напрямую (через свойство Tile) меняет ячейки меняет позицию игрового объекта Unity игрока на позицию устанавливаемой ячейки и вызывает действие ячейки (RunAction);

? Maze - лабиринт, к которому принадлежит игрок, используется для взаимодействия с лабиринтом;

? MoveSystem - система передвижения, представленная интерфейсом IMoveSystem;

? MoveSequence - последовательность движений, представленная классом MoveSequence, используется для обработки перемещения, его плавности, анимации вращения игрока, направления вращения игрока (по часовой или против часовой стрелки), отвечает за логику построения линии, рисуемой за игроком;

? Animator - поле класса аниматор (Animator) библиотеки Unity, применяется для анимации.

Основным методом класса является метод Update, блок-схема которого приведена на рисунке 7.1.



Рисунок 7.1 - Блок-схема метода Update класса Player

Интерфейс IMoveSystem имеет один метод, принимающий ячейку, из которой начинается движение, и направление движения. Возвращаемое значение метода - односвязный список ячеек, начиная с ячейки, передаваемой в метод, заканчивая последней ячейкой, в которой окажется игрок после прохождения пути по указанному движению.

Односвязный список был выбран по той причине, что добавление элемента в односвязный список имеет алгоритмическую сложность O(1) во всех случаях, а добавление элемента в динамический массив в худшем случае имеет алгоритмическую сложность O(n). Получение элемента по индексу в данном случае не планируется, поэтому учитывать то, что получение элемента по индексу в динамическом массиве имеет алгоритмическую сложность O(1), а O(n) в односвязном списке, не имеет смысла.

Разработано два класса, реализующих этот интерфейс:

? PathMoveSystem;

? StepMoveSystem.

При использовании PathMoveSystem игрок перемещается в указанном направлении до тех пор, пока не встретит развилку или тупик, а в StepMoveSystem игрок просто перемещается до следующий ячейки в указанном направлении.

Класс лабиринт (Maze) отвечает за создание лабиринта, расстановку объектов в лабиринте. Класс имеет следующие поля:

? PlayerPrefab - шаблон игрока;

? ExitPrefab - шаблон выхода;

? Player - игрок;

? TilesTransform, WallsTransofrm, WallEdgesTransform - объекты типа Transform, для создания ячеек в отдельной группе лабиринтов (рисунок 7.2);

? Tiles, Walls, WallEdges - списки ячеек, стен и углов ячеек;

? RectangularMazeSystemPrefab - шаблон системы прямоугольного лабиринта, состоящего из квадратных ячеек);

? HexagonalMazeSystemPrefab - шаблон системы шестиугольного лабиринта, состоящего из ячеек в форме правильного шестиугольника;

? MazeSystem - систем лабиринта;

? Seed - семя генератора случайных чисел.

Рисунок 7.2 - Группы для ячеек, стен и углов ячеек лабиринта

В классе имеется следующие методы:

? Start - метод, который вызывается перед первым кадром игры, блок-схема которого представлена на рисунке 7.3;

Рисунок 7.3 - блок-схема метода Start

? Update - метод, который вызывается перед каждым кадром игры, в нём происходит обработка нажатия клавиши «Escape» персонального компьютера или кнопки «Назад» Android-устройства, по которым происходит выход в главное меню игры;

? CreateMaze - метод, с помощью которого происходит создание лабиринта, блок-схема представлена на рисунке 7.4, на рисунке 7.3 представлен блоком с текстом «Создание лабиринта»;

Рисунок 7.4 - Блок-схема метода CreateMaze

? CreateField - метод, создающий экземпляр класса списка ячеек и выбираюший, в зависимости от количества направлений системы лабиринта, метод CreateRectangularField или метод CreateHexagonalField;

? CreateRectangularField - метод, создающий поле из четырёхугольных ячеек определённой ширины в ячейках и высоты в ячейках, в начале создав ячейки, потом установив для каждой из них соседние, чтобы каждая ячейка «знала» свои соседние ячейки;

? CreateHexagonalField - метод, создающий поле из шестиугольных ячеек определённой ширины в ячейках и высоты в ячейках, в начале создав ячейки, потом установив для каждой из них соседние, чтобы каждая ячейка «знала» свои соседние ячейки;

? ConnectTiles - метод, соединяющий ячейки между собой, под соединением понимается возможность перехода из одной ячейки в другую, этот метод реализует алгоритм рекурсивного поиска в глубину с модификацией выбора ячейки для дальнейшего поиска, блок-схема алгоритма приведена на рисунке 7.5;

Рисунок 7.5 - Блок-схема обобщённого алгоритма создания лабиринта

? CreateWalls - метод, отвечающий за создание стен между ячейками;

? CreateWallEdges - метод, отвечающий за создание углов ячеек;

Методы CreateWalls и CreateWallEdges не должны создавать дубликаты стен и углов ячеек в тех местах, где они расположены, так как при анимации появления они будут накладываться друг на друга и это увидит игрок.

? ApplyHiddenMode - метод устанавливающий видимость каждой ячейки в зависимости от режима (классический или режим тьмы);

? CreatePlayer - метод отвечающий за создание игрока по шаблону, установку для него ссылки на лабиринт, которому он принадлежит, выбор системы передвижения (PathMoveSystem или StepMoveSystem);

? SetPlayerAndExitTiles - метод, в котором производится расчёт позиций игрока и выхода, а после производится установка этих позиций для игрока и выхода;

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

После того, как позиции определены, позиция игрока устанавливается для него, а по позиции выхода для ячейки по этой позиции устанавливается содержимое (TileContent) - выход.

? Restart - метод, в котором происходит уничтожение всех объектов лабиринта и их повторное создание.

При загрузке меню кампании создаются кнопки уровней. Уровни берутся из файла «campaign.json», документа в формате JSON. JSON имеет более читабелен чем XML и обладает меньшим размером. В этом файле описывается каждый уровень кампании. Уровень описывается следующими параметрами:

? ширина поля;

? высота поля;

? вид ячейки - четырёхугольная или шестиугольная;

? режим - режим тьмы или классический;

? семя.

Для загрузки уровней используются два сериализуемых класса: Campaign и Level. Загрузка происходит с помощью класса JsonUtility библиотеки Unity. Загрузка выполнена отложенный, по требованию. Сделано это, чтобы не загружать уровни до тех пор, пока это не потребуется.

В проекте представлены и другие менее значимые классы:

? обработчики меню: интерфейс MenuHandler, классы MainMenuHandler, CampaignHandler, FreePlayHandler;

? классы, связанные с работой меню: LevelButton, представляющая кнопку уровня, по нажатию которой происходит запуск уровня, перечисление MenuStates, используемое для возврата в нужное меню, SliderHandler, используемое для дискретности ползунка настройки режима свободной игры;

? классы, отвечающие за анимацию: Appearance, Disappereance, Visible, Invisible, Move, Win;

? вспомогательные классы: IOManager, TileHelper.



8. ТЕСТИРОВАНИЕ

Ни одна разработка программного продукта не проходит без тестирования. Данное игровое приложение не является исключением.

При разработке проводилась отладка приложения с помощью средств Microsoft Visual Studio и ручное тестирование с помощью редактора Unity, который поддерживает запуск приложения без сборки проекта.

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

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

Рисунок 8.1 - Ошибка рисования линии поверх игрока

После нахождения ошибки в проект вносятся коррективы и проект заново собирается.

Дальше проверялась правильность отображения меню и работоспособность всех элементов меню.

Экран главного меню показан на рисунке 8.2.



Рисунок 8.2 - Экран главного меню

Кнопки при наведении или зажатии левой кнопки мыши на них, меняют визуально их.

При нажатии на кнопку «Campaign» происходит переход в меню выбора уровня кампании. При нажатии на кнопку «Free play» происходит переход в меню настройки режима свободной игры. При нажатии на кнопку в виде дверцы в правом верхнем углу экрана происходит выход из приложения.

На рисунке 8.3 представлен экран выбор уровня кампании.

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



Рисунок 8.3 - Меню выбора уровня кампании

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

? прямоугольный лабиринт;

? ширина в 5 ячеек;

? высота в 5 ячеек;

? на рисунке 8.1 точно такой же уровень, что значит, что используется одно и тоже семя;

? классический режим.

Посмотрев файл «campaign.json» из проекта (представлен в приложении А), видно, что именно такие параметры имеет первый уровень игры.



Рисунок 8.4 - Первый уровень кампании

Нажатие кнопки Escape возвращает игрока в меню выбора уровня кампании.

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

Рисунок 8.5 - Завершение первого уровня

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

Рисунок 8.6 - Тестирование шестиугольного лабиринта в пятом уровне

Выход из уровня представлен на рисунке 8.7.

Рисунок 8.7 - Выход из пятого уровня

Далее протестируем уровень с режимом тьмы шестиугольного лабиринта.

Таким уровнем является десятый уровень. Начало десятого уровня представлено на рисунке 8.8.

Рисунок 8.8 - Начальная позиция игрока в десятом уровне

При перемещении ячейки плавно появляются вместе со стенками и углами ячеек. Момент появления представлен на рисунке 8.9.

Рисунок 8.9 - Появление ячеек, стенок и углов при открытии новых ячеек лабиринта

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

Рисунок 8.10 - Перед завершением десятого уровня

Теперь перейдём к меню настройки режима свободной игры. Меню представлено на рисунке 8.11.

Рисунок 8.11 - Меню настройки свободного режима

Попробуем создать лабиринт 10 на 15 в режиме тьмы с шестиугольными ячейками. Сделаем это два раза. Результаты представлены на рисунках 8.12 и 8.13.

Рисунок 8.12 - Первый лабиринт

Рисунок 8.13 - Второй лабиринт

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

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

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

При тестировании управления на Android-устройстве проверялись лабиринт с четырёхугольной ячейкой и лабиринт с шестиугольной ячейкой. В обоих случаях всё работает без ошибок и недочётов.



9. РАЗВЁРТЫВАНИЕ НА РАЗНЫХ ПЛАТФОРМАХ

Развёртывания приложения -- это механизм их распространения для установки на других компьютерах или устройствах.

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

Подобная операция имеется в Unity. В случае с Android-устройством создаётся apk-файл, а в случае с Windows создаётся папка с exe-файлом и ресурсами.

Для создания apk-файла использовались настройки, представленные на рисунке 9.1 и 9.2.

Рисунок 9.1 - Настройки сборки приложения под Android

Рисунок 9.2 - Настройки идентификации приложения под Android



Настройки для сборки под Windows представлены на рисунке 9.3.

Рисунок 9.3 - Настройки сборки приложения под Windows

Apk-файл передаётся на Android устройство и устанавливается пользователем запуском файла и нажатием кнопки «Установить».

Папка с файлами, полученная после сборки под Windows, поставляется целиком на устройство пользователя. Для запуска используется exe-файл.

Для Windows также возможна поставка установочным файлом (msi или exe) или в саморазархивирующимся архивом.



10. РАЗРАБОТКА ДОКУМЕНТАЦИИ

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

Для обоих устройствах пользователь при запуске попадет в главное меню. Для закрытия приложения пользователь в главном меню должен нажать кнопку в виде красной двери в правом верхнем углу экрана. Для открытия меню кампании пользователь должен нажать на кнопку с надписью «Campaign». Для открытия меню настройки свободного режима пользователь должен нажать на кнопку с надписью «Free play».

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

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

? ширина лабиринта;

? высота лабиринта;

? режим тьмы или классический;

? четырёхугольные ячейки или шестиугольные ячейки.

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

В игровом процессе игрок попадает в лабиринт. Для перемещения в лабиринте игрок на Windows должен использовать для четырёхугольного лабиринта клавиши «W», «A», «S» и «D», для шестиугольного лабиринта к этим клавишам ещё добавляются клавиши «Q» и «E». Для перемещения на Android пользователь должен сделать свайп по направлению, в котором хочет перемещаться.

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

Цель игрового процесса является нахождение выхода в лабиринте.

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

В любой момент игрок может вернуться из игрового процесса в меню, из которого он перешёл в игровой процесс (в меню кампании или в меню настройки свободного режима).



ЗАКЛЮЧЕНИЕ

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

Приложение было представлено только для Windows и Android, но есть вариант и для iOS. Приложение можно разместить в Google Play заплатив 25 долларов единовременно и можно разместить в AppStore за 99 долларов в год после разработки под iOS. Есть также возможность разместить приложение в таком игровом магазине как Steam или его аналоги.



ПРИЛОЖЕНИЕ 1

Исходный код игрового приложения

MoveSequence.cs

using Maze.Reals;

using System;

using System.Collections.Generic;

using UnityEngine;

namespace Maze

{

public class MoveSequence : MonoBehaviour

{

private LinkedList<Tile> tiles;

public event Action<Vector3> OnUpdate;

public event Action<Tile> OnEnd;

public event Action OnStartSequence;

public event Action OnEndSequence;

private Single currentTime;

private HashSet<Tile> visitedTiles;

public Single Duration;

public Player Player;

public LineRenderer LineRenderer;

private Boolean isDirectOrder;

private void Start()

{

currentTime = 0f;

isDirectOrder = true;

visitedTiles = new HashSet<Tile>() { Player.Tile };

LineRenderer.positionCount = 1;

LineRenderer.SetPosition(0, Player.Tile.transform.position);

Player.MoveSequence.OnUpdate += position => Player.transform.localPosition = position;

Player.MoveSequence.OnEnd += tile => Player.Tile = tile;

Player.MoveSequence.OnStartSequence += () =>

{

Player.Animator.SetBool("Direct Order", isDirectOrder);

Player.Animator.SetTrigger("Move");

};

Player.MoveSequence.OnEndSequence += () => Player.Animator.SetTrigger("Idle");

if (!Properties.IsStepMoveSystem)

{

Duration *= 0.5f;

}

}

public void SetTiles(LinkedList<Tile> tiles)

{

this.tiles = tiles;

ChooseDirectOrder();

OnStartSequence?.Invoke();

OnStartOfMove();

}

private void ChooseDirectOrder()

{

Tile source = tiles.First.Value;

Tile target = tiles.First.Next.Value;

isDirectOrder = visitedTiles.Contains(source) && !visitedTiles.Contains(target);

}

public void Update()

{

if (tiles != null)

{

currentTime += Time.deltaTime;

Vector3 currentPosition = GetCurrentPosition();

OnUpdate?.Invoke(currentPosition);

if (currentTime > Duration)

{

OnEndOfMove();

tiles.RemoveFirst();

currentTime -= Duration * (Int32)(currentTime / Duration);

if (tiles.Count == 1)

{

tiles = null;

OnEndSequence?.Invoke();

return;

}

OnStartOfMove();

}

LineRenderer.SetPosition(LineRenderer.positionCount - 1, GetCurrentPosition());

}

}

private void OnStartOfMove()

{

Tile source = tiles.First.Value;

Tile target = tiles.First.Next.Value;

if (visitedTiles.Contains(source) && !visitedTiles.Contains(target))

{

LineRenderer.SetPosition(LineRenderer.positionCount - 1, source.transform.position);

LineRenderer.positionCount++;

LineRenderer.SetPosition(LineRenderer.positionCount - 1, source.transform.position);

}

}

private void OnEndOfMove()

{

Tile source = tiles.First.Value;

Tile target = tiles.First.Next.Value;

if (visitedTiles.Contains(source))

{

if (visitedTiles.Contains(target))

{

visitedTiles.Remove(source);

LineRenderer.SetPosition(LineRenderer.positionCount - 1, target.transform.position);

LineRenderer.positionCount--;

}

else

{

visitedTiles.Add(target);

LineRenderer.SetPosition(LineRenderer.positionCount - 1, target.transform.position);

}

}

OnEnd?.Invoke(target);

}

private Vector3 GetCurrentPosition()

{

Vector3 firstPosition = tiles.First.Value.transform.position;

Vector3 secondPosition = tiles.First.Next.Value.transform.position;

Single multiplier = currentTime / Duration;

return firstPosition + (secondPosition - firstPosition) * multiplier;

}

public Tile GetCurrentTargetPosition()

{

if (tiles == null)

{

throw new ArgumentException($"{nameof(GetCurrentTargetPosition)}: нет перемещений");

}

return tiles.First.Next.Value;

}

public Tile GetCurrentSourcePosition()

{

if (tiles == null)

{

throw new ArgumentException($"{nameof(GetCurrentSourcePosition)}: нет перемещений");

}

return tiles.First.Value;

}

public Boolean IsFinished()

{

return tiles == null;

}

}

}

Properties.cs

using Maze.Commons;

using Maze.IO;

using Maze.Menu;

using System;

using UnityEngine;

namespace Maze

{

public static class Properties

{

// Maze settings

public static Int32? LevelNumber = null;

public static Int32 MazeWidth = 5;

public static Int32 MazeHeight = 5;

public static Int32? MazeSeed = null;

public static Boolean IsHiddenMode = true;

public static Boolean IsRectangularMazeSystem = true;

public static Boolean IsFreePlay = true;

public static Boolean IsExitVisibleInHiddenMode = true;

public static MenuStates MenuState = MenuStates.Default;

// General settings

#if UNITY_ANDROID || UNITY_IOS

public static Boolean IsStepMoveSystem = false;

#else

public static Boolean IsStepMoveSystem = true;

#endif

// Visual settings

public static Color MazeWallColor;

public static Color MazeFloorColor;

private readonly static Lazy<CampaignInfo> campaignInfo = new Lazy<CampaignInfo>(() => IOManager.LoadLevels());

public static LevelInfo[] Campaign => campaignInfo.Value.Campaign;

}

}

SwipeManager.cs

#if UNITY_ANDROID || UNITY_IOS

using Maze.Commons;

using System;

using UnityEngine;

namespace Maze

{

public static class SwipeManager

{

private static Vector3 firstPosition;

private static Vector3 lastPosition;

...