• Игролог
• Игры
• Об авторе

TowerDefence #11. Вражеские волны

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

Что такое вражеская волна?

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

1. Временной интервал между вражескими волнами, то есть перед началом очередной вражеской волны должна быть некая произвольная временная задержка.
2. Чтобы волны были интересными, у нас должна быть возможность задавать разного вида противников в одной вражеской волне, а так же возможность указывать для каждого вида количество юнитов.
3. Помимо типа и количества противников было бы здорово указывать и их порядок выхода.
4. Так же между появлением врагов нужно задавать временной интервал, чтобы они не появлялись сразу в большом количестве, а выходили поочередно.

Таким образом получается так, что вражеская волна — это некий объект, который живет какое-то время и выполняет функции базы, которая как бы создает и отправляет в бой противников. Конечно, в случае с TD понятие базы будет абстрактным, но принцип реализации будет именно таким. Давайте приступим к её созданию.

EnemyWave.as

Создаем новый класс EnemyWave.as и размещаем его в пакете (папке) com.towerdefence. В классе у нас будет одна публичная переменная:

// Задержка перед началом вражеской волны
public var startDelay:Number = 0;

А так же несколько приватных переменных необходимых для внутренней работы вражеской волны:

// Указатель на игровой мир
private var _universe:Universe;
// Список врагов в волне
private var _enemies:Array = [];
// �?ндекс текущего врага в волне
private var _enemyIndex:int = 0;
// Указатель на текущий объект с информацией о враге
private var _enemy:Object = null;
// Флаг, определяющий выполняется ли волна сейчас
private var _isStarted:Boolean = false;
// Пройденный интервал между респауном врагов 
private var _interval:Number = 0;

В конструкторе класса напишем строчку:

_universe = Universe.getInstance();

Дальше первым делом мы напишем публичный метод addEnemy(), который будет добавлять в волну вид врага:

public function addEnemy(kind:uint, count:int, respawnInterval:Number):void
{
  _enemies[_enemies.length] = { kind:kind, 
    count:count,
    respawn:respawnInterval };
}

Здесь мы создаем новый объект с тремя полями kind — вид врага, count —количество юнитов указанного типа и respawnInterval — временной интервал между появлением юнитов данного типа. Объект с информацией о типе врага тут же добавляется в массив. Теперь напишем метод startWave(), который будет запускать работу волны:

public function startWave():void
{
  if (!_isStarted)
  {
    _enemyIndex = 0;
    _interval = startDelay;
    _isStarted = true;
  }
}

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

public function update(delta:Number):void
{
  if (_isStarted)
  {
    // Уменьшаем текущий интервал
    _interval -= 10 * delta;

    // Если интервал закончился,
    // вызываем следующего врага
    if (_interval <= 0)
    {
      // Если врага вывать не удалось,
      // значит волна закончилась,
      // сбрасываем флаг работы волны
      if (!nextEnemy())
      {
        _isStarted = false;
      }
    }
  }
}

Код получился достаточно простым, и я думаю, что из комментариев его принцип работы должен быть понятен: мы все время уменьшаем интервал со скоростью 10 единиц в секунду. �? тут я хочу обратить ваше внимание на использование delta времени — это необходимо, чтобы временной интервал между появлением врагов был синхронизирован с игровым процессом. К реальному времени появление врагов привязывать не стоит, так как, если вдруг, по какой-то причине, на компьютере игрока игра начнет притормаживать, то может получиться так, что враги начнут появляться быстрее, чем будет прекращаться движение предыдущей волны. То есть, время игры не будет соответсвовать времени появлению врагов и таким образом весь баланс игры просто развалится.

Если вы еще не обратили внимание на метод nextEnemy() в условие — сделайте это сейчас :) Этот метод вызывает следующего врага из списка врагов текущей волны, если следующего врага удалось вызвать, метод возвращает true, а если по какой-то причине следующий враг не вышел (в нашем случае это может случиться только, если очередь врагов закончилась), то метод вернет значение false. Таким образом мы вызываем метод nextEnemy() и если он возвращает false, значит работа волны закончилась. Теперь посмотрим на код метода nextEnemy():

private function nextEnemy():Boolean
{
  // Если список врагов не закончен
  if (_enemyIndex < _enemies.length)
  {
    // �?звлекаем информацию о следующем виде врага
    if (_enemy == null)
    {
      var o:Object = _enemies[_enemyIndex];
      // Копируем информацию о виде
      // и количестве единиц врагов
      // в новый объект.
      _enemy = { kind:o.kind,
        count:o.count,
        respawn:o.respawn };
    }
                
    // Создаем единицу врага
    _universe.newEnemy();
                
    // Устанавливаем задержку до
    // появления следующей единицы врага.
    _interval = _enemy.respawn;
                
    // Уменьшаем количество вышедших врагов
    _enemy.count--;
    if (_enemy.count <= 0)
    {
      // Если все единицы врагов для 
      // текущего вида созданы, переходим
      // к следующему виду врагов.
      _enemyIndex++;
      _enemy = null;
    }
                
    return true;
  }
            
  return false;
}

При каждом вызове метода мы проверяем наличие объекта в _enemy, если он равен null, значит нужно извлечь новый вид и количество единиц из списка врагов. После чего мы сразу же вызываем публичный метод игрового мира Universe.newEnemy(); —этот метод пока остался у нас в оригинальном виде без указания типа врага, позже мы этот момент доработаем. Далее по коду мы устанавливаем новый интервал между появлением единиц и уменьшаем количество вышедших юнитов на один. Если количество юнитов равно нулю, значит все враги данного типа вышли и можно переключиться на следующий вид врагов в списке: увеличиваем индекс врага и сбрасываем указатель на объект с информацией о враге, чтобы при следующем вызове этого метода была выполнена инициализация следующего вида врага из списка. Вот собственно и все, осталось добавить геттер, который позволит нам отслеживать завершение работы волны в игровом мире, и можно будет протестировать работу класса.

public function get isFinished():Boolean
{
  return !_isStarted;
}

Геттер работает просто: если волна не запущена, значит она закончена :)

EnemyWave в игре

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

Открываем класс Universe.as и первым делом добавляем тройку новых приватных переменных:

// Список всех вражеских волн на текущем уровне
private var _waves:Array = [];
// �?ндекс текущей вражеской волны в списке
private var _waveIndex:int = 0;
// Указатель на экземпляр класса текущей вражеской волны
private var _currentWave:EnemyWave = null;

Теперь перейдем к конструктору класса Universe и добавим инициализацию пары тестовых вражеских волн:

// Временная инициализация двух вражеских волн
var wave:EnemyWave = new EnemyWave();
wave.startDelay = 10;
wave.addEnemy(0, 2, 3);
wave.addEnemy(1, 3, 3);
_waves.push(wave);
            
wave.startDelay = 20;
wave.addEnemy(0, 4, 2);
wave.addEnemy(2, 2, 2);
_waves.push(wave);
_waveIndex = 0;

Здесь мы просто создаем два экземпляра класса EnemyWave, устанавливаем стартовую задержку перед началом действия волны, потом добавляем по паре видов врагов и сохраняем волну в список волн. Далее необходимо добавить обработку вражеских волн, для этого создадим метод updateWaves(), который будем вызывать в методе enterFrameHandler() каждый кадр. Метод updateWaves() будет выглядеть следующим образом:

private function updateWaves(delta:Number):void
{
  // Обновление текущей вражеской волны
  if (_currentWave == null)
  {
    // Если волна не задана, выбираем новую
    // из списка по индексу
    _currentWave = _waves[_waveIndex] as EnemyWave;
    _currentWave.startWave();
  }
  else
  {
    // Обновляем вражескую волну
    _currentWave.update(_deltaTime);
    if (_currentWave.isFinished)
    {
      // Если текущая вражеская волна закончилась,
      // увеличиваем индекс волны и сбрасываем
      // текущую волну. Если все волны в списке
      // были выполнены, то переходим в начало 
      // списка всех волн и процесс выполняется
      // по кругу.
      _waveIndex = (_waveIndex + 1 >= _waves.length) ? 0 : _waveIndex + 1;
      _currentWave = null;
    }
  }
}

Добавляем вызов метода updateWaves() в методе enterFrameHandler() и можно протестировать работу наших вражеских волн. Если все сделано правильно, то в двух случайных точках будут появляться враги с заданным нами интервалом, волны будут идти по кругу. Теперь если все работает правильно, можно приступать к доработке.

Типы врагов

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

public static const KIND_JEEP:int = 1;
public static const KIND_TANK:int = 2;

А так же добавил два новых класса: EnemyJeep.as и EnemyTank.as — оба класса унаследованы от EnemyBase.as и практически ничем не отличаются от EnemySoldier.as. Основные отличия только в скорости движения, количестве жизни, внешнем виде, ну и другие незначительные изменения. Так же для новых боевых единиц техники я сделал плавные развороты, чтобы их движение выглядело более интересным и живым. Как это сделано я не буду здесь описывать, так что если вам это интересно, не забудьте заглянуть в исходники и посмотреть на изменения.

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

public var cacheEnemyJeep:SimpleCache;
public var cacheEnemyTank:SimpleCache;

�?нициализация кэшев в конструкторе класса должна выглядить так:

cacheEnemyJeep = new SimpleCache(EnemyJeep, 10);
cacheEnemyTank = new SimpleCache(EnemyTank, 10);

А теперь изменим метод newEnemy() следующим образом:

public function newEnemy(kind:int):void
{
  // Создание врага в зависимости от указанного типа
  var enemy:EnemyBase = null;
  switch (kind)
  {
    case EnemyBase.KIND_SOLDIER :
      enemy = cacheEnemySoldier.get() as EnemySoldier;
    break;
                
    case EnemyBase.KIND_JEEP :
      enemy = cacheEnemyJeep.get() as EnemyJeep;
    break;
                
    case EnemyBase.KIND_TANK :
      enemy = cacheEnemyTank.get() as EnemyTank;
    break;
  }
            
  if (enemy != null)
  {
    // Выбираем случайную стартовую точку и финишную
    var startPos:Avector = _startPoints[Amath.random(1, _startPoints.length) - 1];
    var finishPos:Avector = _finishPoints[Amath.random(1, _finishPoints.length) - 1];

    // �?нициализируем юнита с выбранными точками
    enemy.init(startPos.x, startPos.y, finishPos.x, finishPos.y);
  }
}

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

var wave:EnemyWave = new EnemyWave();
wave.startDelay = 10;
wave.addEnemy(EnemyBase.KIND_JEEP, 5, 6);
wave.addEnemy(EnemyBase.KIND_SOLDIER, 10, 2);
_waves.push(wave);
            
wave.startDelay = 30;
wave.addEnemy(EnemyBase.KIND_JEEP, 4, 6);
wave.addEnemy(EnemyBase.KIND_TANK, 3, 14);
wave.addEnemy(EnemyBase.KIND_JEEP, 2, 6);
_waves.push(wave);
_waveIndex = 0;

При добавлении нового вида врага мы теперь явно указываем его вид, используя константы из класса EnemyBase, а не какие-нибудь абстрактные числа, таким образом код стал намного понятнее.

Дальше необходимо вернуться в класс EnemyWave и при вызове метода newEnemy() передавать вид врага из волны. Откройте класс EnemyWave, перейдите в метод nextEnemy() и найдите строку:

_universe.newEnemy();

�? замените её на строку:

_universe.newEnemy(_enemy.kind);

Еще не забудьте, что до этого момента новых врагов мы могли вызывать клавишой пробел, которая обрабатывалась в классе Game.as. Откройте класс Game и закомментируйте содержимое метода keyDownHandler(). Теперь вновь можно протестировать волны и, если вы позаботились о новых классах EnemyJeep и EnemyTank, а так же о внешнем виде новых боевых едениц, то вы в полной мере сможете насладиться разнообразием врагов, выходящих в атаку с заданным нами интервалом. Сейчас уже можно поиграться немного со скоростью движения врагов, с их количеством жизни, а так же со скоростью атаки единственной пока башни и её уроном, чтобы попробовать уже найти хоть какой-то баланс.

Домашнее задание

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

Кстати, первым делом не забудьте определиться:

• Вы хотите задавать точку появления/точку цели для каждого вида врага в волне отдельно?
• �?ли может быть следует задавать точку появления/точку цели для всей волны целиком?

Что выбрать — это ваше дело, а я в следующем уроке напишу, что выбрал я и почему.

Заключение

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

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

Ссылка на исходники — CS4, *.zip, 180кб.

Результат

Атака врагов происходит автоматически и в бесконечной цикличности, поэтому просто ставьте башни и смотрите на бесконечный отстрел вражеских единиц :)

Содержание

1. Вступление
2. Структура игры
3. Карта проходимости
4. Первый враг
5. Готовимся к поиску пути
6. Поиск пути
7. Редактор уровней
8. Движение врагов
9. Первая башня
10. Кэширование объектов
11. Полоса жизни
12. Вражеские волны
13. Загрузка вражеских волн
14. Продолжение следует...