Создание игрового приложения для операционной системы Android

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

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

• Оглавление
• Введение
• 1. Аналитический обзор
• 1.1 Анализ аналогичных игровых приложений

1.2 Анализ путей реализации игровых приложений

• 1.3 Постановка задачи
• 2. Проектирование приложения
• 2.1 Разработка структуры приложения
• 2.2 Разработка алгоритмов работы приложения
• 2.3 Проектирование компонентов приложения
• 2.4 Проектирование интерфейса
• 3. Реализация
• 3.1 Реализация компонентов

3.2 Реализация интерфейса

• 3.3 Сборка программы
• 4. Настройка, отладка и тестировании
• 4.1 Функциональное тестирование
• 4.2 Тестирование установки
• 4.3 Пользовательское тестирование
• Заключение
• Использованные источники
• Приложение

Введение

• Компьютерные игры начали зарождаться еще сороковые годы прошлого столетия. Первая компьютерная, а вместе с ней и самый первый игровой автомат появились в 1940 году. Долгое время они не пользовались популярностью, и лишь в семидесятые годы (в 1970 году появляется первый аркадный автомат Galaxy Game), когда для широкой аудитории появляются аркадные автоматы, игровые консоли, они становятся частью культуры. В результате развития игровой индустрии и вычислительной техники у людей есть возможность играть в видеоигры на своих личных устройствах, в том числе и мобильных.
• Количество мобильных устройств во всем мире уже давно превысило 5 миллиардов. Несмотря на это их количество продолжает расти. Вместе с ними растет и количество приложений для мобильных устройств. Одной из самых востребованных составляющих рынка мобильных приложений являются игровые приложения. Согласно отчету от статистической организации App Annie за 2018 год было установлено 194 миллиарда приложений на мобильные устройства, этот показатель вырос в сравнении с 2016 годом на 35%. Стоит отметить, что операционной системе Android принадлежит наибольший охват рынка -- свыше 70%. У индивидуальных разработчиков есть возможность размещать свои работы в сервисах, предоставляемых самой операционной системой.

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

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

1. Аналитический обзор

1.1 Анализ аналогичных игровых приложений

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

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

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

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

Рисунок 1.1 - Схема жанров

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

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

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

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

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

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

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

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

Классификация по количеству игроков:

- Одиночные -- один игрок, который играет против компьютера.

- Многопользовательские -- несколько человек, которые играют против компьютера, или друг против друга.

Классификация по платформам:

- Персональные компьютеры.

- Игровые консоли.

- Мобильные устройства (смартфоны, планшеты).

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

Рассмотрим наиболее популярные и известные видеоигры в жанре аркада.

Space Invaders--видеоигра, которая была разработана Томохиро Нисикадо и выпущена в1978 году на аркадных автоматах (рисунок 1.2). От разработчика требовалась как программная, так и аппаратная реализация аркадного автомата. Эти автоматы собирались и продавались компанией Taito в Японии. Позже права на распространение этих автоматов купила американская компания Midway.

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

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

Рисунок 1.2 - Игра 1978 года Space Invaders

Galaga--еще одна видеоигра в жанре фиксированного шутера, подхватившая популярность Space Invaders. Разработана компанией Namco в видеаркадного игрового автомата в 1981 году. Издана в Японии компанией-разработчиком и в США компанией Midway.

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

Цель игры «Галаги» -- набрать как можно больше очков, уничтожая насекомых как врагов. Игрок управляет старфайтером, который может двигаться влево и вправо по нижней части поля. Враги собираются в группы в верхней части экрана, а затем начинают лететь вниз в сторону игрока, стреляющего пулями, и пытаются врезаться в него. На более поздних стадиях некоторые враги даже прорываются из входящих в группу в неистовой попытке врезаться в игрока. Игра заканчивается, когда последний корабль игрока будет захвачен или уничтожен.

Рисунок 1.3 - игра 1981 года Galaga

Среди современных игр на мобильные устройства в данном жанре можно выделить Retro Shooting. Это аркадная игра в ретро стиле с пиксельной графикой в жанре Shoot `em up, но уже не фиксированном.

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

Рисунок 1.4 - игра 2018 года Retro Shooting

Retro Shooting вышла в 2018 году. В магазине Google Play распространяется бесплатна, монетизация происходит за счет внутриигровой рекламы, имеет 1 млн загрузок.

1.2 Анализ путей реализации игровых приложений

Центральный программный компонент компьютерных видеоигр и других интерактивных приложений с графикой, обрабатываемой в реальном времени -- это игровой движок (англ. game engine). Он обеспечивает основные технологии, упрощает разработку и часто дает игре возможность запускаться на нескольких платформах. Игровой движок подразумевает целый комплекс прикладных программ, включающий движок рендеринга (визуализатор) для 2D или 3D графики, физический движок, звук, скриптинг, анимацию, искусственный интеллект, сетевой код, streaming, управление памятью, threading и графические сцены. То есть, все части кода, написанные программистами при разработке игры, являются компонентами движка. Геймплей определяется функциями, реализованными в этих программах, поэтому, чем больше этих самых функций, тем разнообразнее будет игровой процесс.

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

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

Unreal Engine -- игровой движок, разрабатываемый и поддерживаемый компанией Epic Games.

Движок написан на языке C++, позволяет разрабатывать игры для многих операционных систем и платформ, таких как Microsoft Windows, Linux, Mac OS и Mac OS X; консолей Xbox, Xbox 360, Xbox One, PlayStation 2, PlayStation 3, PlayStation 4, PSP, PS Vita, Wii, Dreamcast, GameCube и др., а также на различных портативных устройствах, например, устройствах Apple (iPad, iPhone), управляемых системой iOS и прочих.

Чтобы упростить портирование на разные платформы движок использует модульную систему зависимых компонентов; поддерживает разные системы рендера (Direct3D, OpenGL, Pixomatic; в ранних версиях: Glide, S3, PowerVR), воспроизведения звука (EAX, OpenAL, DirectSound3D; ранее: A3D), средства воспроизведения текста голосом, распознавание речи, модули для работы с сетью и поддержки различных устройств ввода. [9]

Unity является кросс-платформенным игровым движком, который был разработан компанией Unity Technologies, релиз был в 2005 году. С 2018 года движок был расширен и стал поддерживать свыше 20 платформ. Движок предназначен для создания игр с трехмерной и двумерной графикой, позволяет работать с дополненной реальностью, также используется в моделировании и прочих проектах. Движок был принят в отраслях, не связанных с видеоиграми, таких как кино, автомобили, архитектура, проектирование и строительство.

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

Редактор Unity имеет простой Drag&Drop интерфейс, который легко настраивать, состоящий из различных окон, благодаря чему можно производить отладку игры прямо в редакторе. Движок поддерживает два скриптовых языка: C#, JavaScript (модификация). Взаимодействует с физическим движком PhysX от NVIDIA.

Проект в Unity делится на сцены (уровни) -- отдельные файлы, содержащие свои игровые миры со своим набором объектов, сценариев, и настроек. Сцены могут содержать в себе как, собственно, объекты (модели), так и пустые игровые объекты -- объекты, которые не имеют модели («пустышки»). К объектам можно применять коллизии, которых существует несколько типов.

Также Unity поддерживает физику твёрдых тел и ткани, а также физику типа Ragdoll (тряпичная кукла).

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

Cocos2d -- это кросс-платформенный фреймворк, который используется для разработки интерактивных и игровых приложений имеет открытый код. У Cocos2d есть несколько разновидностей, таких как Cocos2d-ObjC, Cocos2d-x, Cocos2d-html5 и Cocos2d-XNA. Сообщество Cocos2d предоставляет дополнительные средства для разработки, например, редактор спрайтов, который используется для редактирования шрифтов, карт и спрайтов. Есть даже редакторы такие как CocosBuilder и CocoStudio.

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

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

Большинство релизов Cocos2D уже включают в себя такие 2D физические движки, как Box2D и Chipmunk.

Некоторые сборки Cocos2D могут быть дополнены звуковыми библиотеками, обертками над OpenAL или прочими библиотеками. Очень многое зависит от конкретной реализации Cocos2D. Поддерживается биндинг с Javascript, Lua и другими.

libGDX - кросс-платформенный фреймворк, предназначенный для создания игр. Работа в фреймворке происходит на языке Java, последняя рабочая версия JDK 1.8. Сам фреймворк написан на Java, некоторые более нативные компоненты были написаны C и C++, специально для увеличения производительности. В LibGDX можно написать весь исполняемый код в отдельном пакете однажды, и всё это будет собрано фреймворком под конкретную платформу, будь то Windows, MacOs, Android, HTML5, не производя модификации в исходном коде.

libGDX может дать прямой доступ к файловой системе, устройствам ввода и аудио и OpenGL через единый OpenGL ES интерфейс.

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

Наверху таких низкоуровневых возможностей создан мощный набор API, который позволяет решать общие в разработке игр задачи, такие как визуализация спрайтов, текста, построение пользовательских интерфейсов, проигрывание звуковых эффектов и музыки, линейная алгебра и тригонометрические вычисления, разбор JSON и XML, и так далее.

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

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

Android Studio -- это интегрированная среда разработки (IDE) для работы с платформой Android.

Android Studio, основанная на программном обеспечении IntelliJ IDEA от компании JetBrains, - официальное средство разработки Android приложений. Данная среда разработки доступна для Windows, OS X и Linux.

Основные функции Android Studio:

- Расширенный редактор макетов: WYSIWYG, способность работать с UI компонентами при помощи Drag-and-Drop, функция предпросмотра макета на нескольких конфигурациях экрана.

- Сборка приложений, основанная на Gradle.

- Различные виды сборок и генерация нескольких .apk файлов

- Рефакторинг кода

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

- Встроенный ProGuard и утилита для подписывания приложений.

- Шаблоны основных макетов и компонентов Android.

- Поддержка разработки приложений для Android Wear и Android TV.

- Встроенная поддержка Google Cloud Platform, которая включает в себя интеграцию с сервисами Google Cloud Messaging и App Engine.

- Android Studio 2.1 поддерживает Android N Preview SDK, а это значит, что разработчики смогут начать работу по созданию приложения для новой программной платформы.

- Новая версия Android Studio 2.1 способна работать с обновленным компилятором Jack, а также получила улучшенную поддержку Java 8 и усовершенствованную функцию Instant Run.

- Начиная с Platform-tools 23.1.0 для Linux исключительно 64-разрядная.

- В Android Studio 3.0 будут по стандарту включены инструменты языка Kotlin основанные на JetBrains IDE. [13]

Android SDK (Software Development Kit) - это набор всех необходимых для создания Android приложений библиотек и файлов, универсальное средство разработки мобильных приложений для операционной системы Android. Отличительной чертой от обычных редакторов для написания кодов является наличие широких функциональных возможностей, позволяющих запускать тестирование и отладку исходных кодов, оценивать работу приложения в режиме совместимости с различными версиями ОС Android и наблюдать результат в реальном времени (опционально). Поддерживает большое количество мобильных устройств, среди которых выделяют: мобильные телефоны, планшетные компьютеры, умные очки (в том числе Google Glass), современные автомобили с бортовыми компьютерами на ОС Андроид, телевизоры с расширенным функционалом, особые виды наручных часов и многие другие мобильные гаджеты, габаритные технические приспособления.

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

1.3 Постановка задачи

Разработка игры в жанре Arcade поджанре Shoot`em up. Игра будет представлять собой несколько измененный клон Space Invaders.

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

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

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

Чтобы было удобнее выделить требования, предъявляемые к игре, составим диаграмму вариантов использования Use Case (рисунке 1.5).

На основании составленной диаграммы Use Case и предварительного описания сформулируем функциональные требования:

Рисунок 1.5 - Диаграмма вариантов использования (Use Case)

1. Выстрель при нажатии на экран

2. Отображение максимального количества набранных очков в стартовом окне;

3. Начало игры при выстреле по кнопке в стартовом окне;

4. Расположение защитных укрытий для игрока на игровом поле;

5. Противники перемещаются из стороны в сторону и спускаются вниз;

6. Перемещение игрового юнита вдоль нижней границы экрана за счет поворота мобильного устройства (акселерометр);

7. Разрушение бункеров выстрелами, как противников, так и игрока;

8. Уничтожение противников выстрелами;

9. Получение и накопление очков за уничтожение противников;

10. При победе на уровне переход на следующий

11. Сохранение рекорда.

2. Проектирование приложения

2.1 Разработка структуры приложения

В качестве основного средства разработки был выбран игровой фреймворк LibGDX. В бенчмарках он показывает хорошую производительность на Android. В качестве среды разработки будет использоваться Android Studio, так эта среда рекомендована для Android разработки компанией Google.

В фреймворке уже предусмотрена своя структура проекта. Файл настройки проекта создаст директорию с именем проекта со следующей структурой:

- settings.gradle - Определение подмодулей. Здесь будут выбраны Android и Desktop (для удобства тестирования)

- build.gradle - Основной Gradle файл сборки, определяет зависимости и плагины.

- gradlew.bat - Скрипт который будет запускать Gradle на ОС Windows.

- Gradle - Локальная обертка Gradle.

- core/build.gradle - Gradle файл сборки для основного(core) проекта.

- src/ - Папка исходного кода для всей игры.

- desktop/build.gradle - Gradle файл сборки для desktop проекта.

- src - Папка исходного кода для Desktop проекта, содержит Lwjgl класс для запуска.

- android/build.gradle - Gradle файл сборки для android проекта.

- AndroidManifest.xml - Файл Android конфигурации.

- assets/ - Содержит графику, аудио и т.д., общие для всех проектов.

- res/ - Содержит иконки для приложения и другие ресурсы.

- src/ - Папка исходного кода для Android проекта, содержит класс для запуска Android.

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

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

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

3. Логический модуль. Модуль, который будет производить все логические вычисления и изменять поведение объектов.

4. Физический модуль будет отвечать за взаимодействие объектов друг с другом и со сценой.

5. Модуль обновления будет обновлять состояние объектов в соответсвии с физическими и логическими вычислениями.

2.2 Разработка алгоритмов работы приложения

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

Алгоритм жизненного цикла игры реализуется в главном классе игры, который создается автоматически сборщик проекта от libGDX. Алгоритм жизненного цикла приложения продемонстрирован на следующей схеме (Рисунок 2.2).

Главный класс игры реализует интерфейс Aplication Listener, расширяя абстрактный класс Aplication Adapter, чтобы не использовать все методы интерфейса. После передачи интерфейса в Application, методы Application Listener будут вызываться следующим образом:



Рисунок 2.2 - Жизненный цикл приложения

1. create() вызывается однократно при создании приложения, используется как правило для инициализации.

2. resize(int width, int height) этот метод вызывается, если окно приложения изменило размер и если приложение не находилось в этот момент в состоянии паузы, в качестве параметров принимает значения ширины и высоты экрана в пикселях, которые меняются каждый раз при переопределении экрана. На Android вызывается один раз сразу после создания приложения.

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

4. pause() перед закрытием приложения вызывается этот метод, на Android каждый раз при нажатии кнопки Home или поступающем входящем вызове.

5. resume() когда приложение возобновляет свою работу после pause(), вызывается этот метод (только на Android).

6. dispose() вызывается при закрытии приложения, после pause(), здесь уничтожаются использованные рессурсы.

В приложении основной класс будет расширять класс Game (еще один абстрактный класс, предусмотренный библиотекой), который в свою очередь расширяет класс AplicationAdapter. Отличается он от AplicationAdapter наличием поля Screen и соответствующими методами setScreen() и getScreen().

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

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

- Экран меню, где будет кнопка, по которой надо выстрелить;

- Экран игрового процесса;

- Экран окончания игры, всплывающий после поражения;

Ниже приведена примерная схема переключения между экранами (рисунок 2.2).

Рисунок 2.2 - Блок-схема цикла работы с экранами



Рисунок 2.3 - Блок-схема игрового цикла

В интерфейсе Screen имеются уже знакомые методы dispose(), pause(), render(), resize(int width, int heght), resume(), которые выполняют те же функции, что и в классе Game. Также имеются два новых метода hide() и show(). Метод show() вызывается при создании экрана в основном классе в методе create(), так же как cteate() в основном классе, в скрине используется в основном для инициализации. Метод hide() вызывается при переключении экранов, когда уже не является текущим.

Главным экраном в приложении будет игровой экран, где будет происходить игровой процесс. Примерный цикл игрового процесса представлен на блок-схеме ниже (рисунок 2.3).

2.3 Проектирование компонентов приложения

Для реализации игрового процесса на игровом поле необходимо разместить защитные заграждения, противников, игрока, НЛО (будет выступать в качестве бонусного противника), также игрок и противники буду стрелять, значит нужны пули. Для всех этих объектов необходимо создать классы. Отрисовка игровых объектов будет реализована за счет вывода на экран текстурной области (спрайта). Для этого в libGDX предусмотрен специальный класс SpriteBatch, который и будет выполнять роль модуля рендера. SpriteBatch накапливает отправляемые на отрисовку текстуры и отрисовыввает всё сразу, что оптимизирует процесс рендеринга. SpriteBatch группирует собранные текстуры и регионы в одну текстуру и отправляет ее на отрисовку. Отрисовка игровых объектов будет реализована за счет вывода на экран текстурной области (спрайта). Для этого в libGDX предусмотрен специальный класс SpriteBatch, который и будет выполнять роль модуля рендера. SpriteBatch накапливает отправляемые на отрисовку текстуры и отрисовыввает всё сразу, что оптимизирует процесс рендеринга. SpriteBatch группирует собранные текстуры и регионы в одну текстуру и отправляет ее на отрисовку.

Класс Player будет реализовывать нашего игрока. Как и любой класс он будет состоять из полей и методов. Основные поля игрока -- это позиция на экране, очки здоровья, очки прогресса, звук выстрелов, звук попадания, текущее состояние (жив, мертв и т.д.), наличие усилений (за уничтожение НЛО), задержка до следующего выстрела. Основные методы, которые буду реализованы в классе Player: методы создания игрока, отрисовки игрока на экран, стрельбы, перемещения. В качестве средства управления для перемещения унита по экрану, будет использоваться акселерометр. Модуль управления перемещением будет реализован внутри класса игрока. Стрельба будет реализована по нажатию на экран, а так как экранов в игре несколько, и у игрока должна быть возможность стреть на всех, то потребуется создать отдельный класс InputHandler для управления касаниями на всех экранах.

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

Для перемещения захватчиков всех вместе скорее всего потребуется еще один класс. Класс Swarm хранить в себе следующие поля: количество захватчиков в строке и столбце, задержка перемещения, массив Enemy[], массив Bullet[], направление перемещения, задержка перед перемещением. Методы будут реализовывать отрисовку, перемещение, обновления состояния.

Заграждения, как и отряд захватчиков буду состоять из нескольких частей. Для иммитации разрушаемости объекта класс Shield для создания щита будет использовать ShieldPart. ShieldPart будет иметь следующие параметры: размер, координаты, очки здоровья, цвет. Shield в дополнение к этим полям будет иметь массив ShieldPart[].

Класс Bullet потребуется для реализации пуль будет хранить в себе координаты, размер, скорость, цвет, метод отрисовки, перемещения.

Класс MotherShip -- бонусный противник. Поля: размеры, текстура, звук, цвет, шрифт, для отображения наименования бонуса. Методы: методы создания, обновления (перемещения), отрисовки, уничтожения.

Это все необходимые классы необходимые для реализации игрового процесса.

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

2.4 Проектирование интерфейса

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

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

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

3. Реализация

3.1 Реализация компонентов

В процессе разработки была получена следующая компонентная структура, которая представлена на рисунке 3.1. Реализация большинства компонентов приложения представлена в ПРИЛОЖЕНИИ А.

Рисунок 3.1 - структура классов игрового приложения.

3.2 Реализация интерфейса

За интерфейс отвечают два класса PlayerHUD и Button. PlayerHUD отвечает за вывод надписей на экран, Button за кнопку в меню. Heads-Up Display, HUD-- часть визуального интерфейса игрока, отображающаяся на фоне виртуального игрового пространства в видеоигре. Назначение HUD в игре: индикация количества жизней, количество набранных очков за текущий игровой сеанс, время перезарядка (полоска в левом нижнем углу экрана).

Рисунок 3.2 - стартовый экран игры.

Рисунок 3.3 - HUD

3.3 Сборка программы

Сборка производится средствами, предусмотренными Android Studio. Пункт меню, который необходимо выбрать в Android Studio для сборки проекта продемонстрирована на рисунке 3.4

Рисунок 3.4 - сборка APK(s) для установки на Android

компьютерный игра arcade интерфейс

4. Настройка, отладка и тестировании

4.1 Функциональное тестирование

Таблица 4.1 - функциональное тестирование

Функции	Результат
Выстрель при нажатии на экран	Происходит выстрел
Отображение макимального количества набранных очков в стартовом окне;	В стартовом окне отображается максимальный результат
Начало игры при выстреле по кнопке в стартовом окне;	Игра начинается
Расположение защитных укрытий для игрока на игровом поле;	На поле есть щиты
Противники перемещаются из стороны в сторону и спускаются вниз;	Противники премещеются и спускаются
Перемещение игрового юнита вдоль нижней границы экрана за счет поворота мобильного устройства (акселерометр);	Игровой юнит перемещается
Разрушение бункеров выстрелами, как противников, так и игрока;	Бункеры разрушаются
Уничтожение противников выстрелами;	Противники уничтожаются
Получение и накопление очков за уничтожение противников;	Очки прибавляются
При победе на уровне переход на следующий	Происходит переход на следующий уровень
Сохранение рекорда.	Рекорд сохраняется и отображается в стартовом окне

4.2 Тестирование установки

Установка производилась на реальные устройства с операционной системой Android версии 5.1 и старше. Установка прошла успешна. При разработке использовался Android SDK API 28, следовательно, более поздние версии тоже поддерживаются (согласно утверждениям представителей Google, при установке SDK). Для установки необходимо перекинуть APK полученный из среды разработки Android Studio, на мобильное устройство. Операционная система потребует согласия, после чего начнется установка приложения.

4.3 Пользовательское тестирование

Было произведено тестирование на двух устройствах Prestigio MULTIPAD WIZE 30508(Android 5.1) и Tele2 Midi (Android 6.0). Игра запустилась на обоих устройства. Время запуска меньше 2 секунд. Количество используемой оперативной памяти менее 10 Мб. Время отклика на действия пользователя меньше 0.5 секунды. На обоих устройства не наблюдается снижения количества кадров в секунду заметного глазу, играть комфортно.

Заключение

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

Использованные источники

1. Классификация компьютерных и видеоигр: Словари и энциклопедии на Академике.

2. Компьютерная игра: Википедия - свободная энциклопедия.

3. Wiki Style Guide libGDX: GitHub.

4. Площадка для создания игр, или что такое «Игровой движок»?: Игры @mail.ru.

5. Unreal Engine: Википедия - свободная энциклопедия

6. Cocos2d: Википедия - свободная энциклопедия.

7. Unity (игровой движок): Википедия - свободная энциклопедия.

8. libGDX - фреймворк для разработки игр: libGDX.

9. Android Studio: Википедия - свободная энциклопедия.

10. Android SDK: Википедия - свободная энциклопедия.

Приложение А

package com.mygdx.spacedefender;

import com.badlogic.gdx.Game;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Preferences;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.GL20;

import com.badlogic.gdx.graphics.OrthographicCamera;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import com.badlogic.gdx.graphics.g2d.TextureRegion;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.utils.viewport.ExtendViewport;

import com.mygdx.spacedefender.Entities.Button;

import com.mygdx.spacedefender.Entities.Enemy;

import com.mygdx.spacedefender.Entities.EnemyOne;

import com.mygdx.spacedefender.Entities.EnemyThree;

import com.mygdx.spacedefender.Entities.EnemyTwo;

import com.mygdx.spacedefender.Entities.MotherShip;

import com.mygdx.spacedefender.Entities.Player;

import com.mygdx.spacedefender.Entities.ShieldPart;

import com.mygdx.spacedefender.Entities.Swarm;

import com.mygdx.spacedefender.GameScreens.GameOverScreen;

import com.mygdx.spacedefender.GameScreens.GameScreen;

import com.mygdx.spacedefender.GameScreens.MenuScreen;

import com.mygdx.spacedefender.GameScreens.PlayScreen;

import com.mygdx.spacedefender.Input.InputHandler;

public class MainGame extends Game {

public static final int MENU_STATE = 0;

public static final int PLAY_STATE = 1;

public static final int GAMEOVER_STATE = 2;

public static final int WIDTH = 640;

public static final int HEIGHT = 360;

public static float xOff = 0;

public static float yOff = 0;

public static float viewportWidth = MainGame.WIDTH;

public static float viewportHeight = MainGame.HEIGHT;

public static final int UNIT = 10;

public static Texture SPRITE_SHEET;

public static float volume = 1.0f;

public SpriteBatch sb;

public ShapeRenderer sr;

private int currentState;

private GameScreen[] screens;

private InputHandler inputHandler;

public ExtendViewport gameport;

private Preferences prefs;

@Override

public void create () {

initXOffYOffVpWidthVpHeight();

prefs = Gdx.app.getPreferences("HighScore");

Gdx.graphics.setContinuousRendering(true);

initAssets();

OrthographicCamera cam = new OrthographicCamera(viewportWidth, viewportHeight);

cam.translate(viewportWidth / 2, viewportHeight / 2);

cam.translate(-xOff, -yOff);

cam.update();

gameport = new ExtendViewport(viewportWidth, viewportHeight, cam);

sb = new SpriteBatch();

sb.setProjectionMatrix(cam.combined);

sr = new ShapeRenderer();

sr.setProjectionMatrix(cam.combined);

Player p1 = new Player();

screens = new GameScreen[3];

getHighScore();

currentState = MENU_STATE;

screens[MENU_STATE] = new MenuScreen(this, p1);

screens[PLAY_STATE] = new PlayScreen(this, p1);

screens[GAMEOVER_STATE] = new GameOverScreen(this, p1);

screens[currentState].init();

setScreen(screens[currentState]);

inputHandler = new InputHandler(this);

Gdx.input.setInputProcessor(inputHandler);

Gdx.gl.glClearColor(0, 0, 0, 1);

Gdx.gl20.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

gameport.apply();

}

public void initAssets(){

SPRITE_SHEET = new Texture("spriteSheet2.png");

EnemyOne.IMAGE_ONE = new TextureRegion(MainGame.SPRITE_SHEET, 0, 0, 12, 8);

EnemyOne.IMAGE_TWO = new TextureRegion(MainGame.SPRITE_SHEET, 12, 0, 12, 8);

EnemyTwo.IMAGE_ONE = new TextureRegion(MainGame.SPRITE_SHEET, 24, 0, 11, 8);

EnemyTwo.IMAGE_TWO = new TextureRegion(MainGame.SPRITE_SHEET, 35, 0, 11, 8);

EnemyThree.IMAGE_ONE = new TextureRegion(MainGame.SPRITE_SHEET, 0, 8, 8, 8);

EnemyThree.IMAGE_TWO = new TextureRegion(MainGame.SPRITE_SHEET, 8, 8, 8, 8);

MotherShip.image = new TextureRegion(MainGame.SPRITE_SHEET, 29, 8, 16, 7);

ShieldPart.hitSound = EnemyTwo.firstHitSound = Gdx.audio.newSound(Gdx.files.internal("phaseJump1.mp3"));

Button.hitSound = Enemy.hitSound = Gdx.audio.newSound(Gdx.files.internal("bomb.wav"));

MotherShip.sound = Gdx.audio.newSound(Gdx.files.internal("zapTwoTone.mp3"));

Player.gong = Gdx.audio.newSound(Gdx.files.internal("gong.mp3"));

Player.shootSound = Gdx.audio.newSound( Gdx.files.internal("laser1.mp3"));

Player.hitSound = Gdx.audio.newSound( Gdx.files.internal("explosion16bit.wav"));

Swarm.moveSound = Gdx.audio.newSound( Gdx.files.internal("fastinvader116bit.wav"));

Button.exitSymbol = new Texture("exitSymbol.png");

Button.playSymbol = new Texture("playSymbol512.png");

Button.retrySymbol = new Texture("retrySymbol.png");

Button.okaySymbol = new Texture("thumbsUp512.png");

}

@Override

public void render () {

Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

screen.render(Gdx.graphics.getDeltaTime());

}

@Override

public void dispose(){

Button.hitSound.dispose();

MotherShip.sound.dispose();

Player.gong.dispose();

Player.shootSound.dispose();

Player.hitSound.dispose();

Swarm.moveSound.dispose();

ShieldPart.hitSound.dispose();

SPRITE_SHEET.dispose();

Button.exitSymbol.dispose();

Button.playSymbol.dispose();

Button.retrySymbol.dispose();

sb.dispose();

sr.dispose();

for(int i = 0; i < screens.length; ++i)

screens[i].dispose();

}

@Override

public void resume(){}

@Override

public void pause(){}

@Override

public void resize(int width, int height){

gameport.update(width, height);

}

public void changeScreen(int screen){

if(screen < 0 || screen > 4)

return;

currentState = screen;

inputHandler.setScreen(screens[currentState]);

screens[currentState].init();

setScreen(screens[currentState]);

}

public static void mix(Color from, Color too, float percent, Color outColor){

outColor.set(

(1f - percent) * from.r + percent * too.r,

(1f - percent) * from.g + percent * too.g,

(1f - percent) * from.b + percent * too.b,

(1f - percent) * from.a + percent * too.a

);

}

public int getHighScore(){

return prefs.getInteger("Score", 0);

}

public void setHighScore(int score){

prefs.clear();

prefs.putInteger("Score", score);

prefs.flush();

}

public void initXOffYOffVpWidthVpHeight(){

float deviceWidth = Gdx.graphics.getWidth();

float deviceHeight = Gdx.graphics.getHeight();

float deviceRatio = deviceWidth/deviceHeight;

float neededRatio = 16f/9f;

if(neededRatio < deviceRatio){

float ourWidth = deviceHeight*(16f/9f);

float widthScale = deviceWidth/ourWidth;

xOff = (deviceWidth - ourWidth)/2f;

yOff = 0;

viewportHeight = MainGame.HEIGHT;

viewportWidth = MainGame.WIDTH * widthScale;

}

else if(neededRatio > deviceRatio){

float ourHeight = deviceWidth*(9f/16f);

float heightScale = deviceHeight/ourHeight;

xOff = 0;

viewportWidth = MainGame.WIDTH;

viewportHeight = MainGame.HEIGHT * heightScale;

yOff = (viewportHeight- MainGame.HEIGHT)/2;

}

}

}

package com.mygdx.spacedefender.GameScreens;

import com.badlogic.gdx.Screen;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.Entities.Player;

import com.mygdx.spacedefender.MainGame;

public abstract class GameScreen implements Screen {

public final int STATE_ENTERING = 0;

public final int STATE_NORMAL = 1;

public final int STATE_TRANSITION_MENUSCREEN = 2;

public final int STATE_TRANSITION_PLAYSCREEN = 3;

public final int STATE_TRANSITION_GAMEOVERSCREEN = 4;

public final int STATE_TRANSITION_TUTORIALSCREEN = 5;

protected int state;

protected final float transitionPeriod = 5;

protected MainGame game;

protected Player p1;

protected Rectangle[] recievePlayerRectangles;

protected Color backgroundColor;

protected float transitionTime;

protected boolean leftPressed, rightPressed;

public GameScreen(MainGame game, Player p1){

this.recievePlayerRectangles = new Rectangle[]{new Rectangle(), new Rectangle(), new Rectangle()};

this.backgroundColor = new Color();

this.game = game;

this.p1 = p1;

this.transitionTime = 0;

}

public boolean isLeftPressed() {

return leftPressed;

}

public boolean isRightPressed() {

return rightPressed;

}

public void keyDown(int keyCode){

}

public void touchDown(float x, float y){

}

public void changeScreen(int screen){

if(screen < 0 || screen > 3)

return;

transitionTime = 0;

if(screen == MainGame.PLAY_STATE) {

state = STATE_TRANSITION_PLAYSCREEN;

p1.setState(Player.State.ENTERING);

}

else if(screen == MainGame.MENU_STATE) {

state = STATE_TRANSITION_MENUSCREEN;

p1.setState(Player.State.NORMAL);

}

else if(screen == MainGame.GAMEOVER_STATE) {

state = STATE_TRANSITION_GAMEOVERSCREEN;

}

}

public abstract void init();

public void init(final Color BG_COLOR){

transitionTime = 0;

backgroundColor.set(BG_COLOR);

p1.setCurrentScreen(this);

state = STATE_ENTERING;

}

public void onPlayerRespawnStart(){}

public void onPlayerRespawnEnd(){}

@Override

public void show() {

}

@Override

public void render(float delta) {

update(delta);

draw(delta);

}

public abstract void update(float delta);

public abstract void draw(float delta);

@Override

public void resize(int width, int height) {

}

@Override

public void pause() {

}

@Override

public void resume() {

}

@Override

public void hide() {

}

@Override

public void dispose() {

}

}

package com.mygdx.spacedefender.GameScreens;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Input;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.GL20;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.BitmapFont;

import com.badlogic.gdx.graphics.g2d.GlyphLayout;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

import com.mygdx.spacedefender.Entities.Button;

import com.mygdx.spacedefender.Entities.Player;

import com.mygdx.spacedefender.MainGame;

public class MenuScreen extends GameScreen {

public static final Color BG_COLOR = new Color(0f, 0f, 0f, 2f);

private Button playButton;

private BitmapFont highScoreFont;

private GlyphLayout highScoreLayout;

private String highScoreText;

public MenuScreen(MainGame game, Player p1){

super(game, p1);

playButton = new Button(MainGame.WIDTH/2f - 100f/2f, MainGame.HEIGHT/5f*2.2f - 100f/2f + MainGame.UNIT*2, 100, new Color(0f, 250f, 0f, 1f), Color.BLACK, Button.ButtonSymbol.PLAY);

this.highScoreFont = new BitmapFont();

highScoreFont.getRegion().getTexture().setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);

highScoreFont.getData().setScale(4);

this.highScoreLayout = new GlyphLayout();

}

public void init(){

super.init(BG_COLOR);

this.playButton.reset();

this.highScoreText = "High Score: "+game.getHighScore();

p1.setState(Player.State.NORMAL);

}

@Override

public void touchDown(float x, float y){

p1.shoot();

}

public void update(float delta){

if(state == STATE_ENTERING){

transitionTime += delta;

if(transitionTime > transitionPeriod) {

state = STATE_NORMAL;

}

}

else if(state == STATE_TRANSITION_PLAYSCREEN){

transitionTime += delta;

MainGame.mix(BG_COLOR, PlayScreen.BG_COLOR, transitionTime/transitionPeriod, backgroundColor);

if(transitionTime > transitionPeriod) {

game.changeScreen(MainGame.PLAY_STATE);

}

}

p1.update(delta);

collision();

}

public void draw(float delta){

float fadeTransparancy = 1f;

if(state == STATE_ENTERING)

fadeTransparancy = transitionTime/transitionPeriod;

else if(state == STATE_TRANSITION_PLAYSCREEN || state == STATE_TRANSITION_TUTORIALSCREEN){

fadeTransparancy = 1f - transitionTime/transitionPeriod;

}

Gdx.gl.glEnable(GL20.GL_BLEND);

game.sr.begin(ShapeRenderer.ShapeType.Filled);

game.sr.setColor(backgroundColor);

game.sr.rect(-MainGame.xOff, -MainGame.yOff, MainGame.viewportWidth, MainGame.viewportHeight);

game.sr.end();

game.sr.begin(ShapeRenderer.ShapeType.Filled);

p1.drawBullets(game.sr);

p1.draw(game.sr);

game.sr.setColor(1f, 1f, 1f, 0.25f);

game.sr.rect(0 - MainGame.xOff, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

game.sr.rect(MainGame.WIDTH, 0 - MainGame.yOff, MainGame.xOff, MainGame.viewportHeight);

playButton.drawShape(game.sr, fadeTransparancy);

game.sr.end();

game.sb.begin();

playButton.drawSymbol(game.sb, fadeTransparancy);

highScoreFont.setColor(1, 1, 1, fadeTransparancy);

highScoreLayout.setText(highScoreFont, highScoreText);

highScoreFont.draw(game.sb, highScoreLayout, MainGame.WIDTH / 2 - highScoreLayout.width / 2, MainGame.HEIGHT - highScoreLayout.height / 2);

game.sb.end();

Gdx.gl.glDisable(GL20.GL_BLEND);

}

@Override

public void dispose() {

highScoreFont.dispose();

playButton.dispose();

}

public void collision(){

p1.bulletsBounds();

for(int i = p1.getNumBullets()-1; i >= 0; --i) {

Rectangle bulletRect = p1.bullets[i].getRect();

if (playButton.visible && bulletRect.overlaps(playButton.getRect())) {

transitionTime = 0;

playButton.hit();

p1.bullets[i].hit();

p1.removeBullet(i);

changeScreen(MainGame.PLAY_STATE);

}

}

}

@Override

public void show() {

}

@Override

public void resize(int width, int height) {

}

@Override

public void pause() {

}

@Override

public void resume() {

}

@Override

public void hide() {

}

@Override

public void keyDown(int keyCode) {

if(keyCode == Input.Keys.SPACE)

p1.shoot();

}

}

package com.mygdx.spacedefender.GameScreens;

import com.badlogic.gdx.Gdx;

import com.badlogic.gdx.Input;

import com.badlogic.gdx.graphics.Color;

import com.badlogic.gdx.graphics.GL20;

import com.badlogic.gdx.graphics.Texture;

import com.badlogic.gdx.graphics.g2d.BitmapFont;

import com.badlogic.gdx.graphics.g2d.GlyphLayout;

import com.badlogic.gdx.graphics.glutils.ShapeRenderer;

import com.badlogic.gdx.math.Rectangle;

import com.badlogic.gdx.utils.Array;

import com.mygdx.spacedefender.Entities.Bullet;

import com.mygdx.spacedefender.Entities.Enemy;

import com.mygdx.spacedefender.Entities.MotherShip;

import com.mygdx.spacedefender.Entities.Player;

import com.mygdx.spacedefender.Entities.ShieldPart;

import com.mygdx.spacedefender.Entities.SpecialBullet;

import com.mygdx.spacedefender.Entities.Swarm;

import com.mygdx.spacedefender.Entities.Shield;

import com.mygdx.spacedefender.Level.Level;

import com.mygdx.spacedefender.MainGame;

public class PlayScreen extends GameScreen {

public static final Color BG_COLOR = new Color(0f, 0f, 0f, 1f);

public static final int LOSE_HEIGHT = Player.Y + Player.HEIGHT;

private static final int START_ENTER_POS = -MainGame.WIDTH*2;

private Swarm swarm;

private float enterPos;

private BitmapFont font;

private GlyphLayout layout;

private MotherShip motherShip;

private Array<Level> levels;

private String levelName;

private Shield shields[];

public PlayScreen(MainGame game, Player p1){

super(game, p1);

this.swarm = new Swarm();

this.motherShip = new MotherShip();

shields = new Shield[4];

for(int i = 0; i < shields.length; ++i){

float x = (i+1)*Shield.GAP_WIDTH + i*Shield.WIDTH;

shields[i] = new Shield(x, Shield.AT_HEIGHT, new Color(0f, 255f, 0f, 2.0f));

}

this.font = new BitmapFont();

font.getRegion().getTexture().setFilter(Texture.TextureFilter.Linear, Texture.TextureFilter.Linear);

font.getData().setScale(5);

this.layout = new GlyphLayout();

}

public void init(){

super.init(BG_COLOR);

levels = Level.getLevels();

loadNextLevel();

p1.reset();

for(int i = 0; i < shields.length; ++i){

shields[i].reset();

}

}

public void loadNextLevel(){

motherShip.dieNow();

if(levels.size > 0) {

this.state = STATE_ENTERING;

p1.setState(Player.State.ENTERING);

p1.killSpecialBullet();

this.enterPos = START_ENTER_POS;

this.transitionTime = 0;

this.levelName = levels.peek().getName();

layout.setText(font, levelName);

swarm.loadLevel(levels.pop());

for(int i = 0; i < shields.length; ++i){

shields[i].reset();

}

}

else{

changeScreen(MainGame.GAMEOVER_STATE);

}

}

public void update(float delta){

if(state == STATE_NORMAL) {

...