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

Программирование спрайта преследователя

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

private int speed;

private TiledLayer barrier;

private boolean directional;

private Sprite chasee; //Спрайт преследуемого

private int aggression; // 0 – 10

Переменная speed хранит значение скорости преследующего спрайта, скорость задается в пикселях за игровой цикл. Каждый раз, когда спрайт преследователя совершает движение в направлении преследуемого спрайта, он перемещается на число пикселей, задаваемое этой переменной. Переменная barrier указывает на слой, ограничивающий перемещение спрайта преследователя. Важно отметить, что этой переменной вы можете присвоить значение null, если не хотите, чтобы перемещения этого спрайта были чем-то ограничены. Например, если вы создали лабиринт в замке и населили его всевозможными существами, то, вероятно, для привидений не имеет смысла создавать преграды, поскольку они могут свободно проходить сквозь стены. Или, например, в игру High Seas вы можете добавить дракона, которому земля – не помеха.

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

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

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

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

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

Листинг 13.1. Конструктор ChaseSprite() вызывает родительский конструктор и инициализирует переменные класса

public ChaseSprite(Image image, int frameWidth, int frameHeight, int chaseSpeed,

TiledLayer barrierLayer, boolean hasDirection, Sprite chaseeSprite,

int aggressionLevel) {

super(image, frameWidth, frameHeight);

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

rand = new Random();

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

speed = chaseSpeed;

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

barrier = barrierLayer;

// установить, направленный ли спрайт

directional = hasDirection;

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

chasee = chaseeSprite;

// установить уровень агрессии

aggression = aggressionLevel; //Чем больше значение, тем агрессивнее спрайт. Это значение лежит в диапазоне от 0 до 10

}

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

Помимо переменных, работу класса определяет единственный метод – update(). Этот метод вызывается один раз за игровой цикл, он обновляет спрайт и перемещает его. Листинг 13.2 содержит код метода update() метода ChaseSprite.

Листинг 13.2. Метод update() класса ChaseSprite реализует преследование

public void update() {

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

int xPos = getX();

int yPos = getY();

int direction = 0; // up = 0, right = 1, down = 2, left = 3

// Преследовать или переместиться случайным образом в зависимости от

уровня агрессии

if (Math.abs(rand.nextInt() % (aggression + 1)) > 0) {

// преследовать

if (getX() > (chasee.getX() + chasee.getWidth() / 2)) { //Преследование продолжается, пока преследуемый не входит в граничную зону преследователя

// преследовать влево

move(-speed, 0);

direction = 3;

}

else if ((getX() + getWidth() / 2) < chasee.getX()) {

// преследовать вправо

move(speed, 0);

direction = 1;

}

if (getY() > (chasee.getY() + chasee.getHeight() / 2)) {

// преследовать вверх

move(0, -speed);

direction = 0;

}

else if ((getY() + getHeight() / 2) < chasee.getY()) {

// преследовать вниз

move(0, speed);

direction = 2;

}

}

else {

// переместиться случайным образом

switch (Math.abs(rand.nextInt() % 4)) { //Если спрайт не преследует, то он просто перемещается случайным образом

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

case 0:

move(-speed, 0);

direction = 3;

break;

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

case 1:

move(speed, 0);

direction = 1;

break;

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

case 2:

move(0, -speed);

direction = 0;

break;

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

case 3:

move(0, speed);

direction = 2;

break;

}

}

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

if (barrier != null && collidesWith(barrier, true)) {

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

setPosition(xPos, yPos);

}

// если спрайт направленный, то перейти к нужному фрейму

if (directional) //Если спрайт является направленным, то выбирается соответствующий фрейм анимации, в противном случае выводится следующий фрейм анимации

setFrame(direction);

else

nextFrame();

}

Я знаю, что это достаточно сложный метод, но помните, что это практически весь код класса ChaseSprite. Метод update() начинается с сохранения текущего положения спрайта преследователя. Это важно, потому как этот метод обновляет положение и направление спрайта позже, но в случае, если есть преграда на его пути, то необходимо восстановить положение после предыдущего перемещения. Обратите внимание, что направление спрайта выражается целым числом от 0 до 3 (вверх = 0, вправо = 1, вниз = 2, влево = 3).

Поведение спрайта преследователя определяется переменной aggression. Случайное число из диапазона от 0 до aggression получается вызовом метода nextInt(). Если это число отлично от 0, то спрайт преследует свою цель. Это означает, что чем больше значение переменной aggression, тем чаще спрайт преследует жертву. Ниже приведены некоторые значения переменной aggression и их влияния на частоту преследования спрайтом:

► агрессия 0 – нет преследования;

► агрессия 1 – преследование один раз за два игровых цикла;

► агрессия 5 – преследование выполняется пять раз за 6 игровых циклов;

► агрессия 10 – преследование выполняется 10 раз за 11 игровых циклов.

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

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

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

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

Вы с легкостью можете объединить классы ChaseSprite и DriftSprite в один многофункциональный класс. На самом деле класс ChaseSprite уже на 90 % выполняет функции класса DriftSprite. Одно значительное отличие заключается в диапазоне случайных чисел, используемых для перемещения спрайта. Чтобы облегчить восприятие, я решил оставить эти классы отдельно. Однако с точки зрения будущих разработок, полезно объединить их в один класс.

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

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

Создание игры High Seas 2

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

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

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

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

Перед тем как приступить к изменению кода, давайте посмотрим, что сделает этот вариант игры интереснее предыдущего:

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

► добавить спрайт корабля, который также будет преследовать игрока.

Если вы думаете о том, как эти спрайты будут работать в игре, то осьминоги, несомненно, будут быстрее корабля противника, однако корабль будет «умнее». Чтобы воплотить это в игре, спрайты осьминогов должны иметь большую скорость, но меньший уровень агрессии, в то время как корабль противника будет намного более агрессивным, но медленнее, чем осьминоги.

Написание программного кода

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

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

private ChaseSprite enemyShipSprite;

Изменяя класс спрайта осьминога, вы также должны изменить и код его инициализации, предоставив необходимую информацию конструктору класса ChaseSprite. Приведенный ниже код добавлен в метод strat() класса HSCanvas:

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

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

landLayer);

placeSprite(mineSprite[i], landLayer);

squidSprite[i] = new ChaseSprite(Image.createImage("/Squid.png"), 24, 35, 3, //Конструктор ChaseSprite() принимает ряд важных параметров,

landLayer,false, playerSprite, 3); //включая скорость спрайта, слой-барьер, направленный спрайт или нет, спрайт-преследователь и его агрессивность

placeSprite(squidSprite[i], landLayer);

}

Четвертый параметр – это первый новый параметр, определяющий спрайт преследующего. Скорость спрайта осьминога равна 3, что в принципе является достаточно высокой скоростью. Затем передается слой-барьер (в данном случае переменная landLayer). Следующий параметр определяет, направленный спрайт или нет. В случае осьминога этот параметр равен false.

Предпоследний параметр, передаваемый конструктору ChaseSprite() – это преследуемый спрайт, очевидно, это должен быть спрайт игрока – playerSprite. И наконец, последний параметр – это агрессия спрайта осьминога, она равна 3. Это одна из тех настроек, с которой вы можете поэкспериментировать. Поиграйте с этим параметром, подберите наилучший вариант!

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

enemyShipSprite = new ChaseSprite(Image.createImage(«/EnemyShip.png»),

86, 70, 1, landLayer, true, playerSprite, 10);

Если снова начать с указания специфических для преследующего спрайта параметров, то первым указывается скорость спрайта, она равна 2 – очень медленно. Слой landLayer служит барьером для спрайта, а значение true показывает, что создаваемый спрайт – направленный (вспомните рис. 13.5), а спрайт playerSprite – это преследуемый спрайт. Самый интересный параметр передается последним, он устанавливает уровень агрессии, в данном случае это значение равно 10. Это чрезвычайно большое значение агрессии компенсируется медлительностью пиратского корабля.

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

enemyShipSprite.setPosition(

(landLayer.getWidth() – enemyShipSprite.getWidth()) / 2,

(landLayer.getHeight() – enemyShipSprite.getHeight()) / 2);

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

layers = new LayerManager();

layers.append(playerSprite);

layers.append(enemyShipSprite); //Новый корабль противника добавляется в менеджер слоев точно так же, как и прочие спрайты

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);

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

enemyShipSprite.update();

Теперь спрайт корабля противника обновляется так же, как и остальные спрайты игры, но вы должны обрабатывать столкновение между спрайтом игрока и спрайтом корабля противника. Можно отметить, что вражеский корабль должен наносить большой ущерб кораблю игрока. Следующий код, расположенный в методе update() класса HSCanvas, выполняет это:

if (playerSprite.collidesWith(enemyShipSprite, true)) {

// воспроизвести звук столкновения с вражеским кораблем

try {

minePlayer.start();

}

catch (MediaException me) {

}

// уменьшить энергию игрока

energy -= 10; //Уменьшить энергию игрока, потому что он столкнулся с кораблем противника

}

Звук, похожий на звук столкновения корабля с миной, воспроизводится при столкновении корабля игрока с вражеским кораблем. Кроме того, при столкновении энергия игрока уменьшается на 10 пунктов. Хотя это может звучать не так устрашающе, помните, что если вы быстро не сможете убежать от корабля, то вы можете сталкиваться с ним много раз, а следовательно, потерять много энергии за очень небольшой промежуток времени. Я надеюсь, вы понимаете, что благодаря новому классу ChaseSprite код игры High Seas 2 остался таким же простым и понятным. Теперь остается лишь протестировать созданную игру, посмотреть, стали ли осьминоги и вражеский корабль агрессивными. Тестирование – это трудная работа, но ее кто-то должен выполнять!

Тестирование готового приложения

Искусственный интеллект – это не только самая сложная часть игры, но и самая интересная для тестирования. Есть что-то особенное в том, когда видишь реакцию компьютера на определенные действия игрока, как машина принимает решения. В игре High Seas 2 спрайты осьминога и вражеского корабля – это преследующие спрайты, которые знают, как найти игрока и последовать за ним. На рис. 13.6 показан фрагмент игры High Seas 2, здесь осьминог начинает погоню за кораблем игрока.

Рис. 13.6. Осьминогу не нужно много времени, чтобы продемонстрировать свою агрессию и начать преследовать корабль игрока

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

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

Сцену из игры, представленную на рис. 13.7, можно рассмотреть как слабость искусственного интеллекта преследующего спрайта: более умный ИИ знал бы, как обойти препятствия, чтобы догнать корабль игрока. Это правда, но вы должны согласиться, что я старался привести пример ИИ, который был бы достаточно прост и не нагружал процессор. Но даже в этом случае я советую вам поработать с алгоритмом ИИ плохих парней в игре High Seas 2.

Кто знает, может быть, вы сможете найти интересный способ сделать преследующие спрайты умнее, написав небольшой код. На рис. 13.8 показан фрагмент игры High Seas 2, где вражеский корабль преследует корабль игрока.

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

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

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

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

Резюме

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

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

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