1. Начало работы с этим руководством Bomberman
2. Сбрасывание бомбы
3. Замыкание
4. Создание взрывов
5. Добавить маску слоя
6. Больше! Взрывы должны быть больше!
7. Создайте сопрограммы
8. Цепные реакции
9. Смерть игрока и как с этим справиться
10. Объявить победителя
11. Выиграть, проиграть или ничья
12. Куда пойти отсюда?

Примечание об обновлении: этот учебник был обновлен до Unity 2017.1 Брайаном Брумом. Оригинальный урок был написан Эриком Ван де Керкховом.

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

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

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

Оригинальный Bomberman вышел в начале 80-х, и с тех пор были опубликованы побочные продукты. Это вечная формула игры, в которую все еще очень весело играть и строить.

Первоначальный заголовок был 2D, но вы собираетесь создать базовую 3D-версию внутри Unity.

В этом уроке вы узнаете следующее:

• Сбрасывать бомбы и привязывать их к плитке.
• Нерест взрывы с помощью Raycast для проверки свободных плиток.
• Обработка взрывов, сталкивающихся с игроком.
• Обработка взрывов, столкновение с бомбами.
• Обработка смерти игрока (ов) для определения выигрыша / ничьей.

Ослабьте запястья и приготовьтесь кричать «огонь в дыре». Вещи собираются действительно взорваться в Единстве. :]

Примечание. В

этом руководстве Bomberman предполагается, что вы знакомы с редактором Unity и умеете редактировать код в текстовом редакторе. Проверьте некоторые из наших других Учебные пособия по Unity Во-первых, если вы еще не уверены.

Начало работы с этим руководством Bomberman

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

Откройте стартовый проект в Unity и запустите этот учебник Bomberman. Активы отсортированы в нескольких папках:

• Контроллеры анимации : содержит контроллер анимации игрока, включая логику для анимации конечностей игроков, когда они ходят. Если вам нужно освежить анимацию, посмотрите наши Введение в анимацию Unity руководство
• Материалы : Содержит материал блока для уровня.
• Модели : Содержит модели игрока, уровня и бомбы, а также их материалы.
• Музыка : содержит саундтрек
• Физические материалы : Содержит физический материал игроков - это особые виды материалов, которые добавляют физические свойства к поверхностям. В этом уроке он позволяет игрокам легко перемещаться по уровню без трения.
• Сборные : Содержат сборные бомбы и взрывы.
• Сцены : содержит игровую сцену
• Скрипты : Содержит стартовые скрипты; не забудьте открыть их и прочитать их, потому что они сильно комментированы, чтобы их было легче понять
• Звуковые эффекты : содержит звуковые эффекты для бомбы и взрыва.
• Текстуры : содержит текстуры обоих игроков

Сбрасывание бомбы

Если он еще не открыт, откройте игровую сцену и запустите ее.

Оба игрока могут ходить по карте, используя клавиши WASD и клавиши со стрелками .

Обычно, когда игрок 1 (красный) нажимает « Пробел», он должен поместить бомбу у своих ног, игрок 2 должен быть в состоянии сделать то же самое, нажав Enter / Return .

Однако это пока не работает. Вам нужно сначала реализовать код для размещения бомб, поэтому откройте скрипт Player.cs в вашем любимом редакторе кода.

Этот скрипт обрабатывает все движения игрока и логику анимации. Он также включает метод с именем DropBomb, который просто проверяет, присоединен ли игровой объект bombPrefab :

private void DropBomb () {if (bombPrefab) {// Проверить, назначен ли префаб бомбы первым}}

Чтобы сделать бомбу под игроком, добавьте следующую строку в оператор if:

Instantiate (bombPrefab, myTransform.position, bombPrefab.transform.rotation);

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

Работает отлично!

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

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

Замыкание

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

В Player.cs отредактируйте Instantiate (), который вы только что добавили в DropBomb (), следующим образом:

Instantiate (bombPrefab, новый Vector3 (Mathf.RoundToInt (myTransform.position.x), bombPrefab.transform.position.y, Mathf.RoundToInt (myTransform.position.z)), bombPrefab.transform.rotation);

Mathf.RoundToInt вызывает значения x и z позиции игрока, округляет любое число с плавающей точкой до значения int , которое затем привязывает бомбы к позициям плитки:

Сохраните свои изменения, играйте на сцене и бегайте, сбрасывая бомбы. Бомбы теперь встанут на свои места:

Хотя сбросить бомбы на карту довольно весело, вы знаете, что это все о взрывах! Время добавить огневую мощь к этой вещи. :]

Создание взрывов

Для начала вам понадобится новый скрипт:

• Выберите папку « Сценарии » в представлении «Проект».
• Нажмите кнопку Создать .
• Выберите C # Script .
• Назовите только что созданный скрипт Bomb .

Теперь присоедините скрипт Bomb к сборному Bomb :

• В папке Prefabs выберите Bomb GameObject.
• В окне «Инспектор» нажмите кнопку « Добавить компонент» .
• Введите бомбу в поле поиска.
• Выберите скрипт Bomb, который вы только что сделали.

Наконец, откройте скрипт Bomb в вашем редакторе кода. Внутри Start () добавьте следующую строку кода:

Invoke («Взрыв», 3f);

Invoke () принимает 2 параметра, во-первых, имя метода, который вы хотите вызвать, и, во-вторых, задержку перед вызовом. В этом случае вы хотите, чтобы бомба взорвалась за три секунды, поэтому вы вызываете Explode () - вы добавите ее дальше.

Добавьте следующее под Update ():

void Explode () {}

Прежде чем вы сможете создавать любые объекты GameObject для Explosion, вам потребуется общедоступная переменная типа GameObject, чтобы вы могли назначить Explosionprefab в редакторе. Добавьте следующее прямо над Start ():

публичный GameObject взрыв Prefab;

Сохраните ваш файл и вернитесь в редактор. Выберите префаб Bomb в папке Prefabs и перетащите префаб Explosion в слот Explosion Prefab :

После этого вернитесь в редактор кода. Вы наконец-то можете написать код, который заставляет дела развиваться!

Внутри Explode () добавьте следующие строки:

Instantiate (взрывПрефаб, трансформация.положение, кватернион.идентификация); // 1 GetComponent <MeshRenderer> (). Enabled = false; // 2 transform.Find ("Collider"). GameObject.SetActive (false); // 3 Уничтожить (gameObject, .3f); // 4

Этот кусок кода делает следующее:

1. Создает взрыв на позиции бомбы.
2. Отключает рендерер сетки, делая бомбу невидимой.
3. Отключает коллайдер, позволяя игрокам проходить и идти во взрыв.
4. Уничтожает бомбу через 0,3 секунды; это гарантирует, что все взрывы появятся до уничтожения GameObject.

Сохраните сценарий Bomb, вернитесь в редактор и играйте в свою игру. Положите несколько бомб и согрейтесь в огненной доброте, когда они взрываются!

Крутые ребята, не смотрите на взрывы!

Добавить маску слоя

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

LayerMask выборочно отфильтровывает определенные слои и обычно используется с raycast. В этом случае вам нужно отфильтровать только блоки, чтобы луч не попал ни в что другое.

В редакторе Unity нажмите кнопку « Слои» в правом верхнем углу и выберите « Редактировать слои».

При необходимости нажмите на треугольник расширения перед словом « Слои», чтобы развернуть список слоев, если он не виден.
Щелкните по текстовому полю рядом с User Layer 8 и введите « Blocks ». Это определяет новый слой, который вы можете использовать.

В иерархическом представлении выберите Blocks GameObject внутри объекта контейнера Map .

Измените слой на вновь созданный слой Blocks :

Когда появится диалоговое окно « Изменить слой », нажмите кнопку «Да, изменить детей», чтобы применить ко всем желтым блокам, разбросанным по карте.

Наконец, добавьте общедоступную ссылку на LayerMask, чтобы скрипт Bomb мог получить доступ к слою, добавив следующую строку чуть ниже ссылки на ExplorationPrefab.

публичный LayerMask levelMask;

Не забудьте сохранить свой код.

Больше! Взрывы должны быть больше!

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

Примечание.

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

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

Чтобы узнать больше о сопрограмм и как их определить, проверьте Документация Unity ,

Вернитесь в редактор кода и отредактируйте скрипт Bomb . Под Explode () добавьте новый IEnumerator с именем CreateExplosions:

приватный IEnumerator CreateExplosions (направление Vector3) {return null; // заполнитель на данный момент}

Создайте сопрограммы

Добавьте следующие четыре строки кода между вызовом Instantiate и отключением MeshRenderer в Explode ():

StartCoroutine (CreateExplosions (Vector3.forward)); StartCoroutine (CreateExplosions (Vector3.right)); StartCoroutine (CreateExplosions (Vector3.back)); StartCoroutine (CreateExplosions (Vector3.left));

Вызов StartCoroutine запускает IEnumerator CreateExplosions один раз для каждого направления.

Теперь начинается интересная часть. Внутри CreateExplosions () замените return null; // заполнитель на данный момент с этим фрагментом кода:

// 1 for (int i = 1; i <3; i ++) {// 2 RaycastHit hit; // 3 Physics.Raycast (transform.position + new Vector3 (0, .5f, 0), направление, выход, i, levelMask); // 4 if (! Hit.collider) {Instantiate (ExplosionPrefab, transform.position + (направление i *), // 5jectionPrefab.transform.rotation); // 6} else {// 7 break; } // 8 yield return new WaitForSeconds (.05f); }

Это выглядит как довольно сложный фрагмент кода, но на самом деле это довольно просто. Вот объяснение по разделам:

1. Повторяет цикл for для каждой единицы расстояния, которую вы хотите покрыть взрывами. В этом случае взрыв достигнет двух метров.
2. Объект RaycastHit содержит всю информацию о том, что и в какой позиции Raycast попадает - или не попадает.
3. Эта важная строка кода отправляет лучевую трансляцию из центра бомбы в направлении, которое вы прошли через вызов StartCoroutine. Затем он выводит результат в объект RaycastHit . Параметр i определяет расстояние, которое должен пройти луч. Наконец, он использует LayerMask с именем levelMask, чтобы убедиться, что луч проверяет только блоки на уровне и игнорирует игрока и другие коллайдеры.
4. Если Raycast ничего не попадает, то это бесплатный тайл.
5. Создает взрыв в позиции, проверенной радиопередачей.
6. Raycast попадает в блок.
7. Как только raycast попадает в блок, он выходит из цикла for. Это гарантирует, что взрыв не может перепрыгнуть через стены.
8. Ожидание 0,05 секунды перед следующей итерацией цикла for. Это делает взрыв более убедительным, создавая впечатление, что он расширяется наружу.

Вот как это выглядит в действии:

Красная линия - это Raycast. Он проверяет плитки вокруг бомбы на наличие свободного места, и если он их находит, то порождает взрыв. Когда он попадает в блок, он ничего не порождает и останавливает проверку в этом направлении.

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

Наконец, выберите сборный Bomb в папке Prefabs в представлении проекта и измените маску уровня на Blocks .

Запустите сцену снова и сбросьте несколько бомб. Наблюдайте, как ваши взрывы красиво разлетаются и обходят блоки:

Поздравляем, вы только что прошли через самую сложную часть этого урока!

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

Цепные реакции

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

К счастью, это довольно легко реализовать.

Откройте скрипт Bomb.cs в вашем редакторе кода. Добавьте новый метод с именем OnTriggerEnter ниже CreateExplosions ():

public void OnTriggerEnter (Коллайдер другой) {}

OnTriggerEnter - это предопределенный метод в MonoBehaviour, который вызывается при столкновении триггерного коллайдера и твердого тела. Параметр Collider с именем other является коллайдером объекта GameObject, который вошел в триггер.

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

Во-первых, вам нужно знать, взорвалась ли бомба. Разобранная переменная должна быть объявлена ​​первой, поэтому добавьте следующее прямо под объявлением переменной levelMask:

частный бул взорвался = ложь;

Внутри OnTriggerEnter () добавьте этот фрагмент:

if (! exploded && other.CompareTag ("Explosion")) {// 1 & 2 CancelInvoke ("Explode"); // 2 Explode (); // 3}

Этот фрагмент выполняет три вещи:

1. Проверяет, бомба не взорвалась.
2. Проверяет, назначен ли для коллайдера триггер взрыва.
3. Отмените уже вызванный вызов Explode, сбросив бомбу - если вы этого не сделаете, бомба может взорваться дважды.
4. Взорвать!

Теперь у вас есть переменная, но она еще нигде не была изменена. Наиболее логичное место для этого - внутри Explode (), сразу после отключения компонента MeshRenderer:

... GetComponent <MeshRenderer> (). Enabled = false; взорвался = правда; ...

Теперь все настроено, поэтому сохраните ваш файл и снова запустите сцену. Бросьте несколько бомб рядом и посмотрите, что происходит:

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

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

Смерть игрока и как с этим справиться

Откройте скрипт Player.cs в вашем редакторе кода.

Прямо сейчас нет никакой переменной, чтобы указать, мертв ли ​​игрок или жив, поэтому добавьте логическую переменную в верхней части скрипта, прямо под переменной canMove:

public bool dead = false;

Эта переменная используется для отслеживания смерти игрока от взрыва.

Затем добавьте это выше всех других объявлений переменных:

public GlobalStateManager globalManager;

Это ссылка на GlobalStateManager, скрипт, который уведомляет обо всех смертях игроков и определяет, какой игрок выиграл.

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

Добавьте этот фрагмент под вызовом Debug.Log:

мертв = правда; // 1 globalManager.PlayerDied (playerNumber); // 2 Destroy (gameObject); // 3

Этот фрагмент кода выполняет следующие действия:

1. Устанавливает переменную dead, чтобы вы могли отслеживать смерть игрока.
2. Уведомляет глобального государственного менеджера о том, что игрок умер.
3. Уничтожает игрока GameObject.

Сохраните этот файл и вернитесь в редактор Unity. Вам нужно будет связать GlobalStateManager с обоими игроками:

• В окне иерархии выберите оба объекта GameObject.
• Перетащите GameObject Глобального менеджера состояний в их слоты Глобального менеджера .

Запустите сцену снова и убедитесь, что один из игроков уничтожен взрывом.

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

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

Объявить победителя

Откройте GlobalStateManager.cs в вашем редакторе кода.

Чтобы GlobalStateManager отслеживал, кто из игроков умер, вам нужны две переменные. Добавьте их вверху скрипта над PlayerDied ():

private int deadPlayers = 0; private int deadPlayerNumber = -1;

Прежде всего, deadPlayers будет хранить количество погибших игроков. DeadPlayerNumber устанавливается после смерти первого игрока и указывает, кем он был.

Теперь, когда вы настроили это, вы можете добавить реальную логику. В PlayerDied () добавьте этот фрагмент кода:

deadPlayers ++; // 1 if (deadPlayers == 1) {// 2 deadPlayerNumber = playerNumber; // 3 Invoke ("CheckPlayersDeath", .3f); // 4}

Этот фрагмент делает следующее:

1. Добавляет одного мертвого игрока.
2. Если это первый игрок, который умер ...
3. Он устанавливает номер мертвого игрока для игрока, который умер первым.
4. Проверяет, не умер ли другой игрок, или только один бит пыли через 0,3 секунды.

Эта последняя задержка имеет решающее значение для проверки на ничью. Если вы проверили сразу, вы можете не увидеть, что все умерли. 0,3 секунды достаточно, чтобы определить, все ли умерли.

Выиграть, проиграть или ничья

Вы сделали это до самого последнего раздела! Здесь вы создаете логику выбора между выигрышем или ничьей!

Создайте новый метод с именем CheckPlayersDeath в скрипте GlobalStateManager:

void CheckPlayersDeath () {// 1 if (deadPlayers == 1) {// 2 if (deadPlayerNumber == 1) {Debug.Log («Игрок 2 - победитель!»); // 3} else {Debug.Log («Игрок 1 - победитель!»); } // 4} else {Debug.Log («Игра завершилась вничью!»); }}

Это логика различных операторов if в этом методе:

1. Один игрок умер, и он проиграл.
2. Игрок 1 умер, поэтому игрок 2 является победителем.
3. Игрок 2 умер, поэтому Игрок 1 является победителем.
4. Оба игрока умерли, так что это ничья.

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

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

Куда пойти отсюда?

Загрузите законченный учебник Bomberman Последний проект если вы застряли

Теперь вы знаете, как сделать простую игру, похожую на Bomberman, используя Unity.

В этом уроке Bomberman использовались некоторые системы частиц для бомбы и взрыва. Если вы хотите узнать больше о системах частиц, посмотрите мой Введение в Unity: учебник по системам частиц ,

Я настоятельно рекомендую вам продолжать работать над этой игрой - сделайте ее своей, добавив новые функции! Вот некоторые предложения:

• Сделайте бомбы «толкающими», чтобы вы могли избежать бомб рядом с вами и подтолкнуть их к своему противнику
• Ограничить количество бомб, которые могут быть сброшены
• Сделать это легко, чтобы быстро перезапустить игру
• Добавить хрупкие блоки, которые разрушаются в результате взрывов
• Создавайте интересные бонусы
• Добавьте жизни или способ заработать их
• Элементы пользовательского интерфейса, чтобы указать, что игрок выиграл
• Найдите способ позволить большему количеству игроков

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

Если у вас есть замечания или вопросы, вы можете сделать это в разделе « Комментарии ».