Как написать игру для андроид на java

Пишем игру для Android. Часть 1 — Идея, архитектура и игровой цикл

Вступительное слово

Этот урок начинает серию статей, посвященных написанию аркадных игр для Android. За основу был взят цикл, который написал и опубликовалв своем блогеTamas Jano. Материал ориентирован, прежде всего, на начинающих программистов, которые хотят попробовать свои силы в создании игр для Android. Я ставлю перед собой цель создать у нас на сайте максимально понятный и доступный учебник для молодой русскоязычной аудитории, поэтому очень надеюсь на вашу критику, вопросы и комментарии. Опубликованный в этом цикле материал будет постоянно перерабатываться с учетом ваших вопросов, пожеланий и замечаний. Надеюсь, что вместе мы сможем успешно осуществить этот небольшой эксперимент.

Идея и архитектура

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

Смоделируем игровую ситуацию. Наш персонаж находится в центре экрана. Роботы каждую 1/10 секунды приближаются к нему. каждую десятую секунду мы проверяем также не произошло ли касание экрана. Если произошло — двигаем наш персонаж в необходимом направлении или делаем выстрел. если выстрел сделан, каждый тик (1/10 секунды) мы проверяем столкновение пули с врагами. Если пуля попала в робота — то и робот и пуля взрываются, если нет — роботы и пуля перемещаются на новые позиции (робот перемещается на 5 пикселей за тик, а пуля — на 50 пикселей). Мы также проверяем не поймал ли робот нашего героя. Если поймал — игра заканчивается.

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

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

Давайте более детально рассмотрим наши модули.

Модуль управления

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

Игровой движок

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

Давайте рассмотрим взаимодействие модуля управления и игрового движка. На представленном выше рисунке показан круг-контроллер. Светлое зеленое пятно символизирует область касания. Модуль управления сообщает игровому движку координаты касания (dx и dy — расстояния в пикселях от центра круга). На основании этих координат игровой движок вычисляет направление и скорость движения нашего героя. Например, если dx>0, наш персонаж движется вправо, eсли dy>0 — в верх.

Аудио модуль

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

Графический модуль

Этот модуль отвечает за вывод игровой ситуации на экран телефона. В Android существует несколько способов формирования изображения на экране. Можно рисовать прямо на canvas, полученный от View или использовать отдельный графический буффер и вы, а затем передавать его View, а можно воспользоваться возможностями библиотеки OpenGL. Полезно при разработке игры постоянно измерять FPS — число кадров в секунду, которые выдает ваш графический движок. Величина в 30 FPS означает, что за одну секунду наша программа успевает 30 раз обновить экран. Забегая вперед скажу, что для мобильного устройства 30 FPS более чем достойный показатель.

Создаем проект-заготовку для будущей Android игры

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

Создайте новый проект. В поле Project Name введитеDroidz. В качестве целевой платформы выберите Android 2.2 или выше. В Package Name — «ru.mobilab.gamesample«. Не забудьте поставить галочку около Create Activity. В качестве имени главной activity введитеDroidzActivity.

Откройте файл src/ru.mobilab.gamesample/DroidzActivity.java

Метод onCreate вызывается при создании activity во время запуска приложения. Этот метод можно рассматривать, как точу входа в программу. Класс R.java автоматически генерируется Eclipse и содержит в себе ссылки на ресурсы. Каждый раз, когда вы изменяете ресурсы в Eclipse класс R пересобирается.

Главный игровой цикл

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

Как вы помните, в Android все происходит внутри Activity. Activity создает View — объект, где происходит все самое интересное. Именно через него мы можем получить информацию о касаниях экрана, здесь же можно вывести картинку на экран.

Давайте откроем файл DroidzActivity.java. В конструкторе класса вы увидите строчку

эта строка выбирает текущий объект View для Activity. Давайте создадим новый объект для View. Наиболее простым способом получения View — создать собственный класс на основании SurfaceView. В нашем классе мы реализуем интерфейс SurfaceHolder.Callback, чтобы ускорить доступ к изменениям поверхности, например когда она уничтожается при изменении ориентации устройства.

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

Устанавливает текущий класс (MainGamePanel) как обработчик событий от поверхности.

Эта строка делает наш класс фокусируемым. Это означает, что он может получать фокус, а значит и события.

Давайте создадим поток, внутри которого собственно и будет реализован наш игровой цикл. Разделение игры на несколько параллельно выполняющихся потоков — общепринятая в современном геймдеве практика. Создадим для нашего потока класс MainThread.java

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

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

Мы объявили объект thread

и создали его в конструкторе

в методе surfaceCreated мы установили флаг running в значение true и запустили поток. К этому времени объект thread уже благополучно создан и можем без опасений запускать его.

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

Добавляем взаимодействие с экраном

Чтобы показать, как в Android обработать касания, напишем небольшой пример. Будем выходить из программы, когда пользователь коснется нижней части экрана. Если касание произошло где-то выше — будем просто выводить в лог соответствующие координаты. Добавим в класс MainThread следующие строки:

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

Измените строку в классе MainGamePanel, добабвив в конструктор вновь объявленные параметры

Мы передаем текущий обработчик и панель в новый конструктор. Это позволит нам иметь к ней доступ из потока. В gamePanel мы создадим метод update и будем переключать его из потока, но пока оставим все как есть.

Логирование

Ниже мы напишем вспомогательный код, осуществляющий логирование — запись специальных отладочных строк с текстом, отражающих состояние нашей программы, в специальный файл, который потом можно просмотреть и попытаться понять, что происходило в программе. добавим константу TAG в класс MainThread. Каждый класс будет у нас иметь собственную константу с именем TAG, которая будет содержать название соответствующего класса. Бы будем использовать Android logging framework, чтобы вести логирование, в рамках этой библиотеки каждый лог должен иметь два параметра. Первый параметр определяет место, откуда записан лог. Именно для этих целей мы и создали константу TAG. Второй параметр — собственно сообщение, которое мы хотим записать в лог. Использование имен классов в качестве первого параметра — довольно распространенная в среде java программистов практика.

Чтобы посмотреть записанные в процессе выполнения программы логи нужно выбрать меню
Windows -> Show View -> Other…
а затем в открывшемся диалоге
Android -> LogCat
В открывшемся окне можно не только просматривать логи, но и осуществлять фильтрацию и поиск.

Вернемся к нашему коду. Внесем изменения в MainThread.java

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

Перейдем к файлу MainGamePanel.java и найдем метод onTouchEvent, который является обработчиком касаний экрана.

Сначала мы проверяем произошло ли событие касания экрана (MotionEvent.ACTION_DOWN). Если произошло, проверяем координату y и если она находится в нижней части экрана (50 пикселей снизу), мы посылаем потоку команду на завершение (установив переменную running в false), а затем вызываем метод finish() для главной Activity, который закрывает всю нашу программу.

Замечание. Начало системы координат у экрана находится в левом верхнем углу. Ось y направлена вниз, ось x — вправо. Ширину и высоту экрана можно получить с помощью методов getWidth() и getHeight() соответственно.

Изменим DroidzActivity.java, добавив команды записи в лог

Мы добавили строки, переводящие приложение в полноэкранный режим и добавили команды записи в лог в методах onDestroy() и onStop().

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

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

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

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

Источник статьи: http://www.mobilab.ru/androiddev/androidgamedev01.html

Создание простой 2D игры на Android

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

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

Игра должна представлять из себя поле (сцену) на котором располагается ниндзя и призраки. Нинзя должен защищать свою базу от этих призраков стреляя по ним.

Пример такой игры можно посмотреть в android market’e. Хотя я сильно замахнулся, у нас будет только похожая идея.

Вот как будет выглядеть игра:

Начало разработки

Создаем проект. Запускаем Eclipse — File — Android Project — Defens — Main.java.

Открываем наш файл Main.java и изменяем весь код на код который ниже:

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

Дальше Вам нужно создать класс GameView.java который будет служить для нас главным классом на котором будет производится прорисовка всех объектов. Так же в этом классе будет находится и наш поток в котором будет обрабатываться прорисовка объектов в потоке для уменьшения нагрузки игры на процессор. Вот как будет выглядеть класс когда на сцене у нас ничего не происходит:

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

Создание спрайтов

Спрайты это маленькие картинки в 2D-играх, которые передвигаются. Это могут быть человечки, боеприпасы или даже облака. В этой игре мы будем иметь три различных типа спрайта: Нинзя , призрак , и снаряд .

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

Теперь загрузите эти картинки в папку res/drawable для того, чтобы Eclipse мог увидеть эти картинки и вставить в Ваш проект.

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

Скучная картинка… Давайте лучше создадим этого самого игрока.

Нам нужно разместить спрайт на экране, как это сделать? Создаем класс Player.java и записываем в него следующее:

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

Создаем еще один файл классов и назовем его Bullet.java, этот класс будет определять координаты полета, скорость полета и другие параметры пули. И так, создали файл, и пишем в него следующее:

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

Рисуем спрайты на сцене

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

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

Дальше нам нужно присвоить картинки нашим классам, находим конструктор GameView и вставляем в самый конец две строчки:

GameView.java — Конструктор GameView

И в методе onDraw(Canvas c); делаем видимыми эти спрайты. Проходим по всей коллекции наших элементов сгенерировавшихся в списке.

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

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

Если хотите сделать что бы нажатие обрабатывалось не единоразово, т.е. 1 нажатие — 1 пуля, а 1 нажатие — и пока не отпустишь оно будет стрелять, нужно удалить if(e.getAction() == MotionEvent.ACTION_DOWN)
и оставить только ball.add(createSprite(R.drawable.bullet));.

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

Враги

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

И так что происходит в этом классе? Рассказываю: мы объявили жизненно важные переменные для нашего врага, высота ширина и координаты. Для размещения их на сцене я использовал класс Random() для того что бы когда они будут появляться на сцене, появлялись на все в одной точке, а в разных точках и на разных координатах. Скорость так же является у нас рандомной что бы каждый враг шел с разной скоростью, скорость у нас начинается с 0 и заканчивается 10, 10 — максимальная скорость которой может достигнуть враг. Двигаться они будут с права налево, для того что бы они не были сразу видны на сцене я закинул их на 900 пикселей за видимость экрана. Так что пока они дойдут можно уже будет подготовиться по полной к атаке.

Дальше нам нужно отобразить врага на сцене, для этого в классе GameView.java делаем следующее:

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

Далее создаем новый поток для задания скорости появления врагов на экране:

И имплементируем класс Runuble, вот как должна выглядеть инициализация класса GameView:

Теперь у Вас еклипс требует создать метод run(), создайте его, он будет иметь следующий вид:

В самом низу класса GameView

Здесь мы создаем поток который будет создавать спрайт от 0 до 2000 милисекунд или каждые 0, 1 или 2 секунды.

Теперь в конструкторе в самом конце пишем инициализируем наш спрайт с классом для отображения на сцене:

Ну и конечно же нам нужно объявить эти методы в onDraw(); Вот значит и пишем в нем следующее:

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

Запускаем нашу игру и что мы увидим? А вот что:

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

Обнаружение столкновений

И так, у нас есть спрайт, у нас есть сцена, у нас все это даже движется красиво, но какая польза от всего этого когда у нас на сцене ничего не происходит кроме хождения туда сюда этих спрайтов?

С этой функцией я навозился по полной, даже как-то так выходило что психовал и уходил гулять по улице)) Самый трудный метод, хотя выглядеть совершенно безобидно…

Ладно, давайте уже создадим этот метод и не будем много разглагольствовать… Где то в конце класса GameView создаем метод testCollision() и пишем следующий код:

В самом низу класса GameView.java

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

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

Внутри ифа происходит сравнения двух прямоугольников Модуль от (Пуля по координате Х минус координата врага по координате Х меньше либо равен ширина пули плюс ширина врага / 2 (делим на два для нахождения центра прямоугольника)) и (Модуль от (Пуля по координате У минус координата врага по координате У меньше либо равен ширина пули плюс ширина врага / 2 (делим на два для нахождения центра прямоугольника)));

И в конце всего, если пуля таки достала до врага — мы удаляем его со сцены с концами.

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

Вот что у нас получается после запуска приложения:

Источник статьи: http://habr.com/ru/post/136802/