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

Создание водной карты

Как я объяснял ранее, в игре High Seas используются два различных замощенных слоя: слой воды и слой суши. Водяной слой – «пассивный» – он используется лишь как фон и не взаимодействует со спрайтами. Несмотря на это, в этом замощенном слое есть анимационные элементы, создающие иллюзию движения воды.

Подобно фоновому слою из мидлета Wanderer 2 из предыдущей главы, в этом слое не нужно задавать граничные элементы – это сделает слой суши. Поэтому края слоя воды – пустые элементы (рис. 12.7).

Рис. 12.7. В слое воды не нужны краевые элементы, поскольку они будут скрыты под слоем суши

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

Ниже представлен код карты водного слоя:

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, -1, 1, -1, 1, 1, -1, -2, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -2, 0, 0,

0, 0, 1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -2, 1, -1, 1, 1, -2, 1, 1, -1, 1, 0, 0,

0, 0, -2, -1, 1, -1, 1, -2, 1, 1, -2, 1, 1, -1, 1, -2, 1, 1, -2, 1, 1, -1, 0, 0,

0, 0, -1, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 1, -1, -1, 1, 1, -1, 1, 0, 0,

0, 0, 1, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -2, 1, -1, 1, 1, -1, 1, 1, 1, 0, 0,

0, 0, -1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, 1, -1, 1, -1, 0, 0,

0, 0, 1, -1, -2, 1, 1, 1, -1, 1, 1, -2, -1, 1, 1, -2, 1, 1, -2, 1, -1, -2, 0, 0,

0, 0, -2, 1, 1, 1, -1, -2, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, 1, 1, 0, 0,

0, 0, 1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -2, -1, 1, 1, 1, -1, 1, -1, 1, -1, 0, 0,

0, 0, 1, -1, -2, 1, -1, -2, 1, -2, -1, 1, -1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 0, 0,

0, 0, -2, 1, 1, 1, 1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, -2, 1, 1, -2, -1, 0, 0,

0, 0, -1, 1, -1, -1, 1, -1, -2, -1, 1, 1, -2, 1, -1, 1, -1, 1, 1, -1, 1, 1, 0, 0,

0, 0, 1, -2, 1, 1, -1, 1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 0, 0,

0, 0, -1, 1, 1, -2, 1, -2, -1, 1, -1, 1, -1, 1, 1, -1, -2, 1, -1, 1, -2, 1, 0, 0,

0, 0, -2, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -2, -1, 1, 1, -1, 1, -1, 1, 1, 0, 0,

0, 0, 1, 1, -1, 1, 1, -1, 1, 1, -2, 1, -1, 1, 1, 1, -1, 1, -1, 1, -1, -1, 0, 0,

0, 0, 1, -1, 1, -2, 1, -2, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, -2, -1, 1, 1, 0, 0,

0, 0, -1, 1, -1, 1, 1, -1, 1, -2, -1, 1, -2, -1, -2, 1, -1, -2, 1, -1, -2, 1, 0, 0,

0, 0, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, 0, 0,

0, 0, -2, -1, 1, 1, -2, 1, -1, 1, -1, -2, 1, -2, 1, -1, -2, 1, 1, -2, -1, 1, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

Приведенный код вам вряд ли что-то скажет, если не посмотреть на ассоциированное с ним изображение. На рис. 12.8 показаны изображения, ассоциированные с данным замощенным слоем. Конечно, вы уже знаете, что ячейки с отрицательными индексами содержат анимационные элементы.

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

Разница между элементами этого слоя невелика, но помните, что основная идея – создать иллюзию «живого» океана. Хотя, посмотрев на рис. 12.7, вы можете подумать, что этот слой – большое статическое изображение, рис. 12.8 в совокупности с картой слоя развеивает это впечатление.

Создание карты суши

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

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

Рис. 12.9. В слое суши есть острова, побережья, небольшие скалы. Все они являются барьерами на пути пиратского корабля

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

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 32, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 1, 1,

1, 1, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 0, 0, 0, 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 6, 7, 0, 27, 1, 1,

1, 1, 31, 0, 0, 0, 0, 0, 0, 0, 10, 12, 0, 0, 0, 0, 0, 6, 14, 12, 0, 27, 1, 1,

1, 1, 31, 0, 6, 11, 11, 11, 11, 11, 14, 12, 0, 0, 0, 0, 0, 10, 16, 8, 0, 27, 1, 1,

1, 1, 31, 0, 10, 16, 9, 9, 9, 9, 9, 8, 0, 0, 0, 0, 0, 5, 8, 0, 0, 27, 1, 1,

1, 1, 31, 0, 10, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 10, 15, 7, 0, 0, 6, 11, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 10, 16, 8, 0, 6, 14, 16, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 10, 12, 0, 0, 10, 1, 12, 0, 0, 0, 0, 6, 11, 11, 7, 0, 0, 27, 1, 1,

1, 1, 31, 0, 10, 15, 11, 11, 14, 16, 8, 0, 0, 0, 0, 10, 1, 1, 12, 0, 0, 27, 1, 1,

1, 1, 31, 0, 5, 9, 9, 9, 9, 8, 0, 0, 0, 0, 0, 10, 1, 1, 12, 0, 0, 27, 1, 1,

1, 1, 31, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 9, 9, 8, 0, 0, 27, 1, 1,

1, 1, 31, 0, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 19, 20, 17, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 0, 27, 1, 1,

1, 1, 31, 0, 0, 0, 19, 20, 0, 17, 18, 0, 0, 0, 6, 11, 7, 0, 5, 8, 0, 27, 1, 1,

1, 1, 31, 0, 17, 18, 0, 0, 0, 19, 20, 0, 0, 0, 10, 1, 12, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 19, 20, 0, 17, 18, 0, 17, 18, 0, 0, 5, 9, 8, 0, 0, 0, 0, 27, 1, 1,

1, 1, 31, 0, 0, 0, 0, 19, 20, 0, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 1, 1,

1, 1, 30, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 28, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1

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

Рис. 12.10. Карта элементов, необходимых для построения замощенного слоя

Взяв за основу рис. 12.10, вы сможете понять, как изображение на рис. 12.9 задается приведенной картой. Не забывайте, что все черные области карты задаются индексом 0 – это пустые прозрачные ячейки. Рисунок 12.11 иллюстрирует, что получается, если объединить два слоя.

Рис. 12.11. Игра High Seas состоит из двух перекрывающихся замощенных слоев, суша – это препятствия, а по воде могут перемещаться спрайты

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

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

Когда созданы слои и необходимые спрайты, можно перейти к написанию игрового кода.

Создание дрейфующего спрайта

Первое, что вам необходимо для игры High Seas, – это новый класс, он пригодится во многих играх. При работе над игрой High Seas вы поймете, что некоторые спрайты должны дрейфовать или медленно перемещаться по экрану случайным образом. Хотя для создания таких спрайтов вы можете использовать стандартный класс Sprite, а затем заставить их дрейфовать в методе update(), целесообразнее создать собственный класс DriftSprite, производный от Sprite.

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

В классе DriftSprite требуются только две переменные:

private int speed;

private TiledLayer barrier;

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

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

Обе переменные класса DriftSprite инициализируются в конструкторе DriftSprite(), код которого представлен в листинге 12.1.

Листинг 12.1. Конструктор DriftSprite() инициализирует переменные скорости и слоя-барьера

public DriftSprite(Image image, int frameWidth, int frameHeight, int driftSpeed,

TiledLayer barrierLayer) {

super(image, frameWidth, frameHeight);

// инициализация генератора случайных чисел

rand = new Random();

// установить скорость

speed = driftSpeed;

// установить замощенный слой-барьер

barrier = barrierLayer;

}

Конструктор DriftSprite() вызывает родительский конструктор Sprite(), создающий основной спрайт, а затем инициализирует специальные переменные класса DriftSprite.

Метод update() – это интересная часть кода класса DriftSprite(). В листинге 12.2 приведен код этого метода.

Листинг 12.2. Метод update() класса DriftSprite перемещает Sprite в произвольном направлении и определяет столкновение со слоем-барьером

public void update() {

// временно сохранить положение

int xPos = getX();

int yPos = getY();

// переместить спрайт случайным образом, чтобы создать иллюзию дрейфа

switch (Math.abs(rand.nextInt() % 4)) {

// переместить влево

case 0:

move(-speed, 0);

break;

// переместить вправо

case 1:

move(speed, 0);

break;

// переместить вверх

case 2:

move(0, -speed);

break;

// переместить вниз

case 3:

move(0, speed);

break;

}

// проверить столкновение со слоем-барьером

if ((barrier != null) && collidesWith(barrier, true)) { //Если в новом положении детектировано столкновение, то необходимо вернуть спрайт в предыдущее положение

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

setPosition(xPos, yPos);

}

// перейти к следующему фрейму анимации спрайта

nextFrame();

}

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

Фрагмент кода в конце метода update() проверяет столкновение спрайта со слоем-барьером, чтобы убедиться, что значение barrier отлично от null. Этот код позволяет ограничивать перемещение спрайтов. Если определено столкновение, то спрайт возвращается в положение, предшествующее смещенному.

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

Если значение переменной barrier равно null, то спрайт будет ограничен в методе update(). Иначе говоря, вы можете создать свободно перемещающиеся спрайты, для чего конструктору DriftSprite()достаточно передать значение null. Если бы вы захотели добавить в игру High Seas птицу или летающего противника, вероятно, вы бы поступили именно так, ведь для такого объекта земля – не помеха.

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

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

Объявление переменных класса

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

private LayerManager layers;

private int xView, yView;

private TiledLayer waterLayer;

private TiledLayer landLayer;

private int waterDelay;

private int[] waterTile = { 1, 3 }; //В слое воды используются два различных анимационных изображения

private Image infoBar;

private Sprite playerSprite;

private DriftSprite[] pirateSprite = new DriftSprite[2];

private DriftSprite[] barrelSprite = new DriftSprite[2];

private DriftSprite[] mineSprite = new DriftSprite[5];

private DriftSprite[] squidSprite = new DriftSprite[5];

private Player musicPlayer;

private Player rescuePlayer;

private Player minePlayer;

private Player gameoverPlayer;

private boolean gameOver;

private int energy, piratesSaved;

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

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

Звуковые эффекты и музыка в игре воспроизводятся с помощью объектов класса Player. И наконец, состояние игры отражается переменными energy и piratesSaved.

Разработка метода start()

Метод start() в игре High Seas выполняет инициализацию всех переменных класса. Например, следующий код создает изображение для информационной строки, а также замощенные слои воды и суши:

try {

infoBar = Image.createImage("/InfoBar.png");

waterLayer = new TiledLayer(24, 24, Image.createImage("/Water.png"), 32, 32);

landLayer = new TiledLayer(24, 24, Image.createImage("/Land.png"), 32, 32);

}

catch (IOException e) {

System.err.println("Failed loading images!");

}

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

waterLayer.createAnimatedTile(1);

waterLayer.createAnimatedTile(3);

Два анимационных элемента имеют различные индексы (1 и 3), это важно, поскольку элементы при создании анимации будут отображать различные картинки. Если использовались одинаковые инициализирующие значения, то вы не увидите никакой разницы.

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

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

int column = i % 24;

int row = (i – column) / 24;

waterLayer.setCell(column, row, waterMap[i]);

}

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

waterDelay = 0;

Подобно водному слою, слой суши описывается картой индексов landMap, содержание которой вы видели ранее. Следующий код выполняет инициализацию слоя суши:

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

int column = i % 24;

int row = (i – column) / 24;

landLayer.setCell(column, row, landMap[i]);

}

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

try {

playerSprite = new Sprite(Image.createImage("/PlayerShip.png"), 43, 45);

int sequence2[] = { 0, 0, 0, 1, 1, 1 };

int sequence4[] = { 0, 0, 1, 1, 2, 2, 3, 3 };

for (int i = 0; i < 2; i++) {

pirateSprite[i] = new DriftSprite(Image.createImage("/Pirate.png"), //Четвертый и пятый параметры конструктора DriftSprite() – это скорость спрайта и слой-барьер соответственно

29, 29, 2, landLayer);

pirateSprite[i].setFrameSequence(sequence2);

placeSprite(pirateSprite[i], landLayer);

barrelSprite[i] = new DriftSprite(Image.createImage("/Barrel.png"),

24, 22, 1, landLayer);

barrelSprite[i].setFrameSequence(sequence4);

placeSprite(barrelSprite[i], landLayer); //Метод placeSprite () случайным образом размещает спрайт на карте

}

for (int i = 0; i < 5; i++) {

mineSprite[i] = new DriftSprite(Image.createImage("/Mine.png"),

27, 23, 1, landLayer);

mineSprite[i].setFrameSequence(sequence2);

placeSprite(mineSprite[i], landLayer);

squidSprite[i] = new DriftSprite(Image.createImage("/Squid.png"),

24, 35, 3, landLayer);

squidSprite[i].setFrameSequence(sequence2);

placeSprite(squidSprite[i], landLayer);

}

}

catch (IOException e) {

System.err.println("Failed loading images!");

}

Спрайт игрока создается в тот момент, когда размер фрейма передается конструктору. Остальные спрайты – это объекты класса DriftSprite, они имеют различные скорости. Например, спрайты пиратов имеют скорость 2, а спрайты мин и бочек перемещаются со скоростью 1. Смысл в том, что пираты могут плавать, поэтому они должны перемещаться быстрее бочек и мин, которые на самом деле просто дрейфуют. Аналогично, спрайты осьминогов имеют скорость 3. Важно отметить, что переменная landLayer выполняет функции барьера для всех спрайтов.

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

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

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

layers = new LayerManager();

layers.append(playerSprite);

for (int i = 0; i < 2; i++) {

layers.append(pirateSprite[i]);

layers.append(barrelSprite[i]);

}

for (int i = 0; i < 5; i++) {

layers.append(mineSprite[i]);

layers.append(squidSprite[i]);

}

layers.append(landLayer);

layers.append(waterLayer); //Последним добавляется слой воды, он будет выведен под остальными элементами

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

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

try {

InputStream is = getClass().getResourceAsStream("Music.mid");

musicPlayer = Manager.createPlayer(is, "audio/midi");

musicPlayer.prefetch();

musicPlayer.setLoopCount(-1);

is = getClass().getResourceAsStream("Rescue.wav");

rescuePlayer = Manager.createPlayer(is, "audio/X-wav");

rescuePlayer.prefetch();

is = getClass().getResourceAsStream("Mine.wav");

minePlayer = Manager.createPlayer(is, "audio/X-wav");

minePlayer.prefetch();

is = getClass().getResourceAsStream("GameOver.wav");

gameoverPlayer = Manager.createPlayer(is, "audio/X-wav");

gameoverPlayer.prefetch();

}

catch (IOException ioe) {

}

catch (MediaException me) {

}

Как видно, для музыки создается один MIDI-проигрыватель, а также три проигрывателя – по одному на каждый из воспроизводимых в игре звуков (звук спасения пирата, звук подрыва на мине и звук окончания игры).

Последний фрагмент метода start() начинает новую игру, для чего вызывается метод newGame():

newGame();

Чуть позже вы узнаете, как работает этот метод. А пока давайте перейдем к рассмотрению метода update(), который выполняет всю основную работу мидлета.