Текст книги "Создание игр для мобильных телефонов"

Отслеживание загрузки памяти игрой

Кроме анализа кода J2ME, Wireless Toolkit также содержит инструмент отслеживания памяти, который полезно использовать для мониторинга объемов используемой памяти. Монитор памяти можно найти в том же самом приложении Preferences, которое используется для включения анализатора. На рис. 17.6 показано окошко метки Enable Memory Monitor (Включить монитор памяти), в котором поставлена галочка.

Рис. 17.6. Вкладка Monitor приложения Preferences позволяет включить монитор памяти в эмуляторе J2ME

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

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

По умолчанию монитор памяти открывается на вкладке Graph, которая отображает след использования памяти запущенного мидлета. График отражает текущий объем занятой мидлетом памяти. Точное значение можно узнать в стоке статуса, расположенной в нижней части окна. Играя, интересно наблюдать за увеличениями и уменьшениями объема используемой памяти. Вы можете эмулировать запуск сборщика мусора, для чего щелкните по кнопке Run GC, расположенной в верхней части монитора памяти.

Другая вкладка в мониторе памяти – это вкладка Objects (Объекты), которая отображает информацию об объектах в памяти. На рис. 17.8 показаны данные о памяти для игры Henway.

Рис. 17.8. Вкладка Objects в мониторе памяти дает детальный обзор объектов мобильной игры в памяти

В панели слева на вкладке Objects (Объекты) перечислены все объекты игрового мидлета, находящиеся в памяти. В данном случае это объекты игры Henway. Ниже приведены назначения каждой из колонок списка объектов:

► Name (имя) – полное имя объекта;

► Live (активный) – число активных объектов в памяти;

► Total (всего) – общее число объектов в памяти;

► Total size (общий объем) – полный объем памяти, занимаемый объектами;

► Average size (средний размер) – средний размер одного объекта (в байтах).

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

Совет Разработчику

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

Выполнение оптимизации мобильных игр

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

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

Резюме

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

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

В заключение

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

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

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

2. в методе update() игрового холста в ответ на нажатия клавиш вместо смены фрейма выполните трансформацию спрайта.

Ого! Как все просто! На самом деле это так просто, что вы без проблем можете выполнить аналогичную оптимизацию для большого пиратского судна. Однако фреймы этого спрайта изменяются в классе DriftSprite, поэтому вам придется поработать с методами этого класса.

Глава 18
Space Out: дань игре Space Invaders

Архив Аркад

Выпущенная в 1985 году компанией Capcom, игра Ghosts 'n Goblins (Призраки и гоблины) на тему праздника Хеллоуин (Halloween) стала чрезвычайно популярной благодаря своей трудности. Я сам много играл в эту игру, поскольку это была любимая игра моего старого друга, моего наставника в программировании игр Рэнди Вимса (Randy Weems), который со временем приобрел эту аркаду себе домой. В игре ваш герой – рыцарь по имени Артур, который должен спасти принцессу Гиневру (Guinevere) от злых зомби, летучих мышей, демонов и призраков. В игре есть множество приемов и трюков. Так, например, если вы 15 раз выстрелите в надгробие, то появится демон, который превратит вас в лягушку.

В этой главе вы снова окунетесь в процесс разработки мобильной игры. Эта игра называется Space Out, в ней вы примените все, что узнали о программировании мобильных игр в этой книге. Игра Space Out – это вертикальный шутер, который очень похож на классическую аркаду Space Invaders. Пришельцы в этой игре, конечно, отличаются от пришельцев игры Space Invaders – они движутся намного быстрее и хаотичнее. Независимо от того, являетесь ли вы поклонником игры Space Invaders, я думаю, что игра Space Out будет хорошей мобильной игрой как с точки зрения разработки, так и с точки зрения самой игры.

В этой главе вы узнаете:

► об основах игры Space Out;

► как разработать игру Space Out;

► как разработать специальный класс движущихся спрайтов;

► об основных элементах программирования игры Space Out;

► о том, что тестирование – это один из самых веселых этапов создания игры.

Взгляд на игру Space Out

Один из классических жанров – это вертикальный космический шутер. Все началось с игры Space Invaders, выпущенной в 1978 году, затем многие игры повторяли ее, внося свои особенности. Один из самых интересных вертикальных шутеров – Galaga. В этой игре нескончаемые полчища пришельцев движутся на вас с верхней части экрана и атакуют ваш корабль, который может свободно перемещаться вдоль нижней части экрана. Игра Space Out, которую вы разработаете в этой главе, основана на играх Space Invaders и Galaga, хотя тема игры несколько фантастичнее.

В игре Space Out вы управляете маленьким зеленым автомобилем, который едет по дороге в пустыне. Верите ли вы в НЛО или нет, сложно спорить, что в пустыне трудно увидеть какие-либо достопримечательности. Поэтому ваш путешественник не стремится укрыться от постоянных нападений НЛО. К сожалению, НЛО в игре Space Out стремятся как можно быстрее прервать ваше путешествие. Движения пришельцев в игре Space Out очень комичны и делают игру забавнее. Ниже приведены три типа пришельцев, появляющихся в игре:

► галактические слизняки Bolbbo (Blobbo the Galactic Ooze);

► джеллибиафры, или просто Джелли (Jellybiafra);

► космический червяк Тимми (Timmy the Space Worm).

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

В копилку Игрока

Герои и концепция игры Space Out были созданы Ребеккой Роуз (Rebecca Rose), компьютерным художником и разработчиком игр.

Разработка игры

Теперь, когда вам ясна основная идея игры, давайте рассмотрим ряд деталей, касающихся ее дизайна. Игрок может перемещаться горизонтально вдоль игрового экрана – это означает, что его положение привязано к оси X.

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

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

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

Чтобы помочь вам представить, как выглядит игра Space Out, взгляните на рис. 18.1.

Рис. 18.1. Игра Space Out состоит из фонового изображения пустыни, автомобиля, пришельцев и ракет игрока и пришельцев

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

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

► спрайт автомобиля;

► спрайты пришельцев;

► спрайты ракет (автомобиля и пришельцев);

► спрайт взрыва.

Единственный спрайт, о котором я еще не говорил, – это спрайт взрыва, который используется для изображения взрыва корабля пришельца или автомобиля. Кроме спрайтов, в игре Space Out необходимы несколько растровых изображений:

► фоновое изображение пустыни;

► изображение автомобиля (рис. 18.2);

Рис. 18.2. Растровое изображение маленького автомобиля, направленного вправо

► изображение пришельца Blobbo (рис. 18.3);

Рис. 18.3. Растровое изображение пришельца Blobbo состоит из пяти фреймов

► изображение пришельца Джелли (рис. 18.4);

Рис. 18.4. Изображение пришельца Jelly состоит из пяти фреймов, имитирующих движение щупалец

► изображение пришельца Timmy (рис. 18.5);

Рис. 18.5. Изображение пришельца Timmy состоит из трех фреймов, имитирующих его полет

► изображение ракеты, содержащее различные фреймы, – ракеты игрока и ракеты пришельца (рис. 18.6);

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

► анимационное изображение взрыва (рис. 18.7);

Рис. 18.7. Изображение взрыва

► маленькое изображение автомобиля (рис. 18.8).

Рис. 18.8. Маленькое изображение автомобиля используется для отображения числа оставшихся жизней

Эти изображения определены самим дизайном игры, речь о котором шла ранее, поэтому здесь не должно быть ничего удивительного. Стоит отметить, что спрайты пришельцев являются анимационными (рис. 18.3—18.5), что делает героев интереснее. Другой традиционный для игр спрайт – это анимационный спрайт взрыва (рис. 18.7).

В игре Space Out используется традиционный анимационный спрайт и для изображения ракеты (рис. 18.6). Изображение содержит несколько фреймов анимации, но каждый фрейм – это отдельный тип ракеты, а не кадр анимации. Иначе говоря, фреймы изображения ракет никогда не выводятся последовательно, как в случае с обыкновенными анимационными изображениями. Напротив, каждый фрейм изображения – это отдельный тип ракеты. Четыре типа ракеты – это ракеты игрока и трех пришельцев.

Другие важные элементы игры Space Out – это счет, который необходимо вести во время игры, а также число жизней (автомобилей). Игра завершается, когда уничтожены все четыре автомобиля. Сложность игры хранится в переменной и увеличивается по мере уничтожения пришельцев игроком. Другое важное хранилище информации – это переменная булевского типа, которая отслеживает, завершена ли игра.

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

► число оставшихся жизней (автомобилей);

► счет;

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

Эта информация отражает ядро игровых данных, которые необходимо отслеживать во время игры. Помните, что игровые спрайты – очень важный компонент состояния игры. Зная это, вы можете перейти к проработке кода игры Space Out. Так же, как и игра High Seas, созданная в главе 12, игра Space Out потребует значительных сил, но труд будет вознагражден! Вы увидите!

Реализация игры

Структура игры аналогична структуре игр, разработанных ранее. В следующих разделах вы разработаете код и ресурсы игры.

Создание движущихся спрайтов

Разработку игры Space Out начнем с создания нового класса спрайтов, который будет использоваться в игре для реализации движущихся спрайтов. Этот класс MovingSprite аналогичен классу DriftSprite из главы 12 за исключением того, что в первом будут использоваться компоненты X и Y скорости, а также обрабатываться столкновения спрайта со стенкой экрана.

Любой спрайт в итоге может достичь края экрана, и в этом случае возможны несколько вариантов. Например, в игре Pong спрайт, достигающий границы экрана, отскакивает от нее. В игре Asteroids при достижении границы экрана спрайт может появиться у противоположной стороны. В некоторых играх спрайт просто замирает или уничтожается (скрывается). Все эти возможности реализует класс MovingSprite. Давайте перечислим эти возможности снова:

► скрыться – сокрытие спрайта по достижении им края экрана;

► переместиться – при достижении спрайтом края экрана он появляется у противоположного края;

► оттолкнуться – по достижении спрайтом границы экрана направление его движения изменяется на противоположное;

► остановиться – если спрайт достигает края экрана, он останавливается.

Все эти случаи реализуются константами класса MovingSprite. Ниже приведены константы и переменные этого класса:

private int xSpeed, ySpeed;

private int action;

private Canvas canvas;

public static final int BA_HIDE = 1; //Эти константы описывают различные действия на границах игрового поля при перемещении спрайтов

public static final int BA_WRAP = 2;

public static final int BA_BOUNCE = 3;

public static final int BA_STOP = 4;

Переменные xSpeed и ySpeed хранят соответствующие компоненты скорости спрайта, которые измеряются в пикселях за один игровой цикл. Переменная action содержит код действия, выполняемого по достижении спрайтом границы экрана – значение одной из констант класса. Поэтому каждый движущийся спрайт по достижении края экрана должен остановиться, появиться у другого края экрана, оттолкнуться или скрыться.

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

Переменные класса MovingSprite инициализируются конструктором MovingSprite (листинг 18.1).

Листинг 18.1. Конструктор класса MovingSprite создает как анимационный, так и неанимационный спрайт

public MovingSprite (Image image, int xMoveSpeed, Int yMoveSpeed,

int boundsAction, Canvas parentCanvas) {

super(image); //Вызов родительского конструктора Sprite()

// скорость XY

xSpeed = xMoveSpeed;

ySpeed = yMoveSpeed;

// действие при достижении границы экрана

action = boundsAction;

// родительский холст

canvas = parentCanvas;

}

public MovingSprite(Image image, int frameWidth, int frameHeight, int xMoveSpeed,

int yMoveSpeed, int boundsAction, Canvas parentCanvas) {

super(image, frameWidth, frameHeight); //Вызов родительского анимационного конструктора Sprite()

// скорости XY

xSpeed = xMoveSpeed;

ySpeed = yMoveSpeed;

// действие при достижении границы экрана

action = boundsAction;

// родительский холст

canvas = parentCanvas;

}

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

В отличие от класса DriftSprite, разработанного в главе 12, метод update() в классе MovingSprite удивительно прост:

public void update() {

// Move the sprite based on its speed

move(xSpeed, ySpeed);

// Check for a collision with the screen boundary

checkBounds();

}

Сначала метод update() перемещает спрайт на основании текущей скорости, хранящейся в целочисленных переменных xSpeed и ySpeed. Метод завершается проверкой, находится ли спрайт внутри границ. Это выполняется методом checkBounds(), код которого приведен в листинге 18.2.

Листинг 18.2. Метод checkBounds() проверяет столкновение спрайта с границей экрана и в случае столкновения выполняет соответствующие действия

private void checkBounds() {

// спрятать спрайт при необходимости

if (action == BA_HIDE) { //Спрятать спрайт при ударении о границу экрана

if (getX() < 0 || getX() > (canvas.getWidth() – getWidth()) ||

getY() < 0 || getY() > (canvas.getHeight() – getHeight()))

setVisible(false);

}

// переместить спрайт к противоположному краю экрана

else if (action == BA_WRAP) { //При достижении границы экрана спрайтом переместить спрайт к противоположному краю

//Wrap the sprite around the edges of the screen

if (getX() < -getWidth())

setPosition(canvas.getWidth(), getY());

else if (getX() > canvas.getWidth())

setPosition(-getWidth(), getY());

if (getY() < -getHeight())

setPosition(getX(), canvas.getHeight());

else if (getY() > canvas.getHeight())

setPosition(getX(), -getHeight());

}

// изменить направление движения спрайта на противоположное

else if (action == BA_BOUNCE) { //При ударении спрайта о границу экрана изменить направление его скорости на противоположное

// Bounce the sprite at the edges of the screen

if (getX() < 0 || getX() > (canvas.getWidth() – getWidth()))

xSpeed = -xSpeed;

if (getY() < 0 || getY() > (canvas.getHeight() – getHeight()))

ySpeed = -ySpeed;

}

// остановить спрайт

else { //Остановить спрайт по достижении границы экрана

if (getX() < 0)

setPosition(0, getY());

else if (getX() > (canvas.getWidth() – getWidth()))

setPosition(canvas.getWidth() – getWidth(), getY());

if (getY() < 0)

setPosition(getX(), 0);

else if (getY() > (canvas.getHeight() – getHeight()))

setPosition(getX(), canvas.getHeight() – getHeight());

}

}

Метод checkBounds() – это рабочая лошадка класса MovingSprite. Его целью является проверка столкновения спрайта с границей экрана и обработка этого события. Сначала метод проверяет, нужно ли выполнять действие BA_HIDE, которое соответствует сокрытию спрайта. Затем проверяется, необходимо ли выполнить действие, соответствующее константе BA_WRAP, и при столкновении спрайта с границей экрана переместить спрайт к противоположной границе. Константа BA_BOUNCE соответствует отталкиванию спрайта от границы экрана. И наконец, последний блок условия метода checkBounds() просто останавливает спрайт по достижении им границы экрана.

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

public int getXSpeed() {

return xSpeed;

}

public int getYSpeed() {

return ySpeed;

}

public void setXSpeed(int xMoveSpeed) {

xSpeed = xMoveSpeed;

}

public void setYSpeed(int yMoveSpeed) {

ySpeed = yMoveSpeed;

}

Эти методы позволяют считывать и изменять значения переменных xSpeed и ySpeed.

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