Как создать игру 2d игру: 🏓 Создаем 2D-игру на Unity: инструкция для новичка

Курс создания 2D-игр с нуля

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

• Преподаватель курса: Game Development Instructor Наталья Чуба

• Возрастная категория: 14–19 лет

• Продолжительность курса: 35 академических часов

Выбирай сам знания, которым хочешь  научиться

Мир онлайн-знаний безграничен. Учись тому, что тебя действительно интересует!

Учись вместе с экспертами

Все преподаватели Edumus School – профессионалы, работающие каждый день в сфере курса.

Учись там, где тебе удобно

Все уроки проходят онлайн в видеозвонках, а материалы курса доступны на нашей онлайн-платформе.

Сертификат в конце курса

В конце курса ты получишь сертификат об обучении (при посещении онлайн-уроков и выполнении домашних заданий).

В этом курсе ты научишься создавать свои собственные игры!

На каждом уроке будет создана одна полноценная 2D-игра с самого начала и до конца. Яркие персонажи, коварные враги, бонусы, сбор монет, разные уровни, динамичная музыка, непредсказуемые сюжеты – все это ты научишься делать с легкостью, в игровой форме, забывая о времени! Тебе решать, когда выигрывать и кто главный! Если ты любишь играть в игры, то поверь, что создавать их гораздо круче и интереснее!

В финале ты сможешь создать свою индивидуальную 2D игру.


Empty space, drag to resize

Что нужно для онлайн занятий:

• персональный компьютер;
• компьютерная мышь;
• устойчивое Интернет-соединение.

Empty space, drag to resize

Как проходит курс:

• Онлайн формат. Уроки проходят на платформе LearnWorlds, Zoom;
• Курс состоит из 35 академических часов, которые включают домашние задания для закрепления материала;
• Проверка домашних заданий с обратной связью куратора;
• Курс стартует 6 октября и продлится 9 недель. Online занятия будут проходить 2 раза в неделю по расписанию: понедельник, четверг с 18:30 до 20:00 (Eastern European Summer Time (EEST).
  

Empty space, drag to resize

Что будет на курсе? 

Модуль 1

1.1. Игра “Лабиринт”. Знакомство с интерфейсом и с первыми строками кода.

1.2. Игра “Пещера”. Управление персонажем, добавление графических элементов из Интернета.

1.3. Игра “Платформер”. Создание различных уровней.

Модуль 2

2.1. Игра “Морская”. Простая анимация, эффект взрыва на основании системы частиц.

2.2. Игра “Космический шутер”. Система стрельбы и бесконечного появления врагов.

2.3. Игра “Полет в космосе”. Создание звездного неба, система подсчета баллов.

2.4. Игра ”Бесконечный раннер”. Имитация игры дракона, когда отсутствует Интернет.

2.5. Игра “Сортер”. Перемещение предмета, удерживанием на нем мышки.

Модуль 3

3.1. Игра “Мячи”. Простая физика, гравитация мира.

3.2. Игра “Арканоид”. Система бонусов.

3.3. Игра “Птичка”. Имитация игры “Fluppy birds”.

3.4. Игра “Лодка”. Псевдо 3D графика.

3.5. Игра “Огонь и лед”. Переключение между режимами управления.

3.6. Игра “Математическая”. Система выбора правильного ответа.

3.7. Игра “Собирание монет на время”. Добавление таймера.

3.8. Игра “Гонки”. Управление как реальным автомобилем.

3.9. Игра “Лопни шарик”. Добавление музыки в игру.

Empty space, drag to resize

На курсе тебя ожидает:

Эффективная работа

по отработке новых навыков обучения в мире игр

Практические задания

для создания индивидуальной 2D-игры 

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

для закрепления материала

Empty space, drag to resize

Ты получишь:

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

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

Преподаватель курса

Курс ведёт Game Development Instructor Наталья Чуба. Знающий и внимательный к деталям программист игр c опытом преподавания более 3-х лет. Кредо преподавателя: “Все сложное объясняется простыми словами”. В работе главный ориентир – качественный результат. Более 150 успешных учеников по всему миру, самому младшему из которых всего 6 лет.

Наталья Чуба

Game Development Instructor

Как проходит обучение в Edumus School?

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

Кто ученики в Edumus School?

Учащиеся из разных школ всего мира могут учиться в Edumus School. Курсы предназначены для подростков-старшеклассников (14-19 лет), но и младшие учащиеся могут принимать участие.

Кто учителя в Edumus School?

В Edumus School Вы познакомитесь с преподавателями — профессионалами своего дела. Преподаватели имеют, кроме профессионального образования по специальности, большой практический опыт в своей сфере.

Когда проходят онлайн-уроки?

Online-уроки проходят один или два раза в неделю, во внешкольное время или в выходные дни. Точное время проведения занятий указано на странице курса.

Оптимизация 2D игр на Unity

Этот пост будет периодически дополняться и обновляться.
Обновлено 13.10.2021

На Youtube куча уроков по созданию простейших 2D игр на Unity. Реально, сделать неплохой платформер можно за день, при наличии опыта и готовых ассетов. Но многие начинающие игроделы сделав проект и протестировать его на ПК, с ужасом наблюдают как их творение тормозит на мобильном устройстве.

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

Что нужно предпринять, чтобы повысить производительность, поднять FPS, снизить CPU?

1. Кешируем все!

Все, что будет использоваться больше одного раза лучше закешировать. Операции типа GameObject.Find() или GetComponent() достаточно ресурсозатратны, а если они вызываются где-нибудь в цикле или в Update (), то производительность может упасть.

void Awake () {
	_cachedTransform = transform;
}
 
void Update () { 
	_cachedTransform.
  localPosition = _newPosition;		
}

Не используйте Resources.Load () каждый раз когда нужно в рантайме загрузить что либо, это тоже дорогая операция. Лучше при старте закешировать и работать с кешем. Ну и конечно, объединяйте в префабы.

2. Настройки графики

В Unity есть 6 стандартных пресетов настройки качества графики. Но так как мы говорим про оптимизацию для 2D и для мобильных устройств, то все что выше Simple нет смысла ставить. Конечно, если у вас есть какие-то специфические моменты, частицы, и т. д., то с параметры можно поэкспериментировать найдя оптимальный баланс.

3. Используем FrameRate

По-умолчанию FrameRate равен 30. И зачастую этого бывает достаточно. Но например, при создании UI где есть прокручивающие списки и движущие элементы, может появится дрожание или шлейф. Я это заметил при тестировании на iPhone, поэтому вручную повысил FrameRate. А понижая FrameRate на сценах или игровых меню, где ничего не двигается, можно значительно снизить CPU, а следовательно продлить жизнь батарее устройства.

Пользователи не любят когда игра сжирает аккумулятор за час.

public int _frameRate = 60;

void Start () {
	#if UNITY_IOS
		QualitySettings.vSyncCount = 0;
	#endif
}

void Update () {
	#if UNITY_IOS
		if (_frameRate != Application.targetFrameRate)
			Application.targetFrameRate = _frameRate;
	#endif
}

4. Атлас текстур

Определенно, нужно упаковывать все свои спрайты в атласы. Для этого есть как встроенный инструмент Sprite Packer, так и продвинутый TexturePacker. Для работы встроенного упаковщика, достаточно задавать теги в настройках импорта, объединяя текстуры и спрайты по смыслу и месту использования.

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

5. Используем пул объектов

GameObject.Instantiate () — очень дорогая операция! Если есть возможность не использовать ее в процессе игры — не используйте. Для большого количества однотипных объектов надо использовать пул объектов. Один раз инициализировав определенное количество, например пуль, они будут использоваться снова и снова, вместо создания и уничтожения каждый раз. Урок по пулу объектов и готовый шаблон, для начала будет достаточно.

6. Меньше Update — больше событий

Метод Update () вызывается каждый кадр, FixedUpdate () в некоторых случаях еще чаще. Если у вас в этих местах происходит много различных проверок и действий, это можно сказаться на производительности. Я использую событийную модель: вместо проверки условия в Update (), когда происходит какое-либо действие, отправляется событие, а в нужном месте это событие «слушается» и обрабатывается в зависимости от переданных параметров. Для этого можно использовать менеджер событий о котором я писал ранее.

7. Выключаем неиспользуемые компоненты

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

8. Настройки билда

Билд под конкретную платформу, тоже можно оптимизировать. Например, если акселерометр не используется в игре, его лучше вообще отключить. Кроме того, я не использую автовыбор графического API, а задаю его сам убирая все остальные, опять же, если вы не используете какие-то специфические функции из OpenGLES 3.0, а так второй версии вполне хватает, она уже давно протестирована. Включаем статичный и динамический батчинг, а для Android многопоточный рендеринг. Для iOS включаем Script Call Optimization в Fast but no Exceptions, но тут момент — если будет какое-то исключение, то игра крашится.

9. Используем Profiler

Не стоит обделять вниманием профайлер. Обязательно протестируйте свою игру и посмотрите, в какие моменты идет максимальная нагрузка. Эти места нужно оптимизировать в первую очередь. Большинство ответов можно найти на stackoverflow.com или форуме Unity, просто загуглив название метода который тратит больше всего ресурсов.

10. Использование материала для UI Image и SpriteRenderer

Если у вас сложный интерфейс и много компонентов, особенно UI Image, то они существенно будут влиять на FPS. Чтобы повысить производительность, улучшить плавность анимаций, можно применить такой хак: там где вы не используете маски, у картинок нужно задать материал Sprites-Default. Если это сделать вместе с маской, то маска не сработает и получите примерно такой варнинг:

Material Sprites-Default doesn’t have _Stencil property

Чтобы убрать эту ошибку нужно немного изменить стандартный шейдер, сделать новый материал и применить его там где есть маска, тогда все сработает. Ссылка на измененный шейдер.


Цена плавности — повышение CPU 🙁

11. Уменьшаем размер текстур

Отличная утилита которая позволяет снизить потребления памяти для текстур до 3х раз. Как это работает и ссылка на Github, в статье на Хабре.

12. Практическое руководство по оптимизации Unity игр

Подойдет как для 2D, так и для 3D. Много полезной информации которую в документации вряд ли найдешь. Тут и про инструменты, и про опыт. Рассказывает специалист по эксплуатации из Unity Technologies — очень интересно. Узнал про memory profiler и то, что Camera.main не закеширована О_О. Обязательно смотреть всем.

13. Используем оптимизированный код

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

14. Используем одинаковые материалы

Если на объектах стоят разные материалы, они не будут батчится и будет больше вызовов отрисовки. Соответственно, нужно по возможности использовать как можно меньше разных шейдеров и материалов. Для понимания, как работает начальная оптимизация графики 2D, на Lynda.com есть небольшой курс.

15. Размеры атласов и спрайтов

Для применения сжатия спрайтов на мобильных устройствах нужно использовать атласы с размерами кратными степени 2, т. е. 1024х1024, 2048х2048.

16. Используйте UI Profiler

В Unity 2017 появился UI Profiler! Крутая штука, теперь можно выяснить почему в интерфейсе много вызовов отрисовки, увидеть какие материалы на объектах и всё это оптимизировать. Особенно актуально, если у вас сложные интерфейсы со множеством элементов, которые например, прокручиваются в ScrollRect.

17. Уголок оптимизатора

На сайте Unity появился специальный раздел посвященный оптимизации — Optimization corner. Там и про UI, и профайлеры, и основные ошибки, в общем, стоит ознакомиться.

18. Несколько советов по оптимизации UI

Раннее уже упоминали про Camera.main, но в новой статье описаны ещё несколько интересных особенностей оптимизации UI.

19. Сборник советов от FunCorp

Хорошая статья про оптимизацию UI. Многое уже описано тут, но есть и замечания по новым компонентам, например TextMeshPro.

20. Оптимизация UI без кода

Статья от Banzai Games про основные способы не делать неправильно Unity UI. Есть и интересные замечания. Зачем только снова про древний текстовый компоненты говорить… Думаю уже все перебрались на TMP.

21. Оптимизация мобильных 3D-проектов

Хорошая статья про оптимизацию в 3D. Многое подойдет и для 2D. Рассмотрены все аспекты и UI, и текстуры, шейдеры, батчинг и т. д.

22. Топ-10 ошибок в оптимизации Unity

Хороший вебинар от юнитеков, рассмотрены частые ошибки совершаемые при оптимизации, обзор инструментов по оптимизации, примеры с пояснениями.

23. Оптимизация игр на Unity: проверенный в деле план

Перевод отличной статьи по оптимизации игр на Unity. Как подготовиться к оптимизации, что лучше делать, что не делать, как правильно использовать профайле и многое другое.

Пока все. Тут не было про физику, потому что пока я ее не использовал. Возможно, в будущем добавлю. Пишите в комментариях ваши проверенные способы оптимизации для 2D игр под Unity.

Как я сделал простую мобильную 2D-игру в Unity | Автор Adam Herd

Привет! Я хочу поделиться с вами тем, как я сделал очень простую мобильную игру для Android, используя игровой движок Unity. Я ни в коем случае не являюсь экспертом в этом игровом движке, поскольку до этого делал два или три небольших проекта, но я чувствую, что могу дать несколько хороших советов, когда дело доходит до создания собственного.

Игра, которую я сделал, называется Stack ’em High. Небольшой вывод подскажет вам, что это игра, цель которой состоит в том, чтобы складывать объекты друг на друга как можно выше. Оригинальность во всей красе.

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

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

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

Я не буду описывать вещи в хронологическом порядке, как они были реализованы. Я склонен работать над тем, что мне нравится в данный момент. Однако в этой статье я разобью ее на разделы: оформление, кодирование, анимация, музыка/звуковые эффекты, публикация . Это облегчит вам переход к различным разделам и обратно.

Итак, начнем!

Настройка

При загрузке хаба Unity вы увидите список проектов. Это поле будет пустым, если вы ничего не сделали заранее. Нажмите на кнопку New справа синего цвета. Здесь вам будет предоставлена ​​возможность сделать 2D или 3D игру. Stack ’em High — это 2D-игра, поэтому я выбрал ее. Затем я дал ему имя и нажал Create .

Некоторые общие вещи, которые полезно сделать перед началом: установите соотношение сторон 16:9.. Это проблема мобильных игр. Существует так много устройств с разными размерами экрана, что трудно обслуживать их все, не испортив что-то. Я обнаружил, что 16:9 работает хорошо в большинстве случаев, поэтому я выбрал его по умолчанию. Делая это в начале, вы сэкономите много времени позже, когда будете корректировать размер всех ваших активов, чтобы они соответствовали новому соотношению сторон. Не весело.

Вы можете изменить соотношение сторон, щелкнув раскрывающийся список под вкладкой игры. Там будет много перечисленного. Моя игра ведется в портретном режиме, поэтому я выбрал 16:9.портрет.

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

Графическое изображение

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

Существует множество инструментов, которые можно использовать для создания игрового/пиксельного искусства. Некоторые из них также бесплатны, например Gimp. Однако для своей игры я использовал фотошоп. У Adobe есть сделка с фотографией, по которой вы можете получить фотошоп примерно за 12 евро в месяц.

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

После того, как я загрузил фотошоп, я выбрал настройки для арта. Размер не так важен, так как его можно отрегулировать в любой момент в процессе и после. Для начала я выбрал холст размером 40 x 40 пикселей с разрешением 72 пикселя на дюйм.

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

Теперь при рисовании пиксель-арта рекомендуется иметь на экране несколько сеток, чтобы мы могли лучше видеть наш арт и знать, где мы нажимаем. Для этого перейдите на Правка вкладка. В разделе Preferences найдите Guides, Grid и Slices .

Я изменил значение Gridline Every на 1 пиксель, а также значение Subdivisions на 1. Нажмите «ОК» и выйдите.

Теперь, чтобы увидеть сетку, я нажал Ctrl + ’. Это нарисует много маленьких квадратов по всему холсту, как вы можете видеть на изображении ниже.

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

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

Если при использовании инструмента «Карандаш» все выглядит размытым по краям, вернитесь к Вкладка Preferences и под General измените интерполяцию на Nearest Neighbor . Это позволит сохранить резкие края и избавиться от любого размытого качества изображения.

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

ДоскаЗемляЛебедка (вот где мои любительские художественные навыки особенно выделяются)Фон

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

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

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

Я изменил размер многих из них, чтобы они соответствовали рисунку. Это легко сделать через вкладку Image вверху. Нажмите на Размер изображения и работайте дальше.

Теперь, когда все искусство готово, следующим шагом был экспорт и импорт его в Unity. Для экспорта перейдите на вкладку File и в разделе Export щелкните Quick Export as PNG . Теперь получите этот сохраненный файл и перетащите его на вкладку ресурсов Unity. Рекомендуется создать несколько папок, чтобы ваша работа была организована. Я поместил свое искусство в папку под названием Pixel Art 9.0025 .

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

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

Кодирование

Предполагаю, что это будет самый длинный раздел этой статьи.

Честно говоря, в этой игре не так много кода, но я хочу быть уверен, что объясню все как можно яснее.

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

Домашняя сцена

Для домашней сцены у нас будет заголовок и две кнопки; кнопка запуска игры и кнопка выхода из игры.

Игровая сцена

Для игровой сцены у нас будет лебедка, которая перемещается влево и вправо по экрану. Когда он достигает левой границы, он будет двигаться вправо, а когда он достигает правой границы, он снова будет двигаться влево.

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

Игра закончится, когда стек упадет.

Конечный экран

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

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

Итак, давайте теперь углубимся в код. Мы будем проходить сцену за сценой, начиная с домашней сцены.

Домашняя сцена

Домашняя сцена

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

Далее были две кнопки. Я создал новую кнопку TextMeshPro, щелкнув правой кнопкой мыши и наведя курсор на UI , а затем изменил текст на «Начать игру». Я скопировал и вставил это, чтобы сделать еще одну кнопку, назвав ее «Выйти из игры».

Теперь нам нужен какой-то код, чтобы что-то делать при нажатии на них.

Я сделал скрипт под названием Buttons и написал внутри следующий код:

Итак, при нажатии кнопки Start Game будет вызываться функция changeToMainScene. Затем эта функция загрузит основную сцену, которая является игровой сценой. Простой.

При нажатии кнопки «Выход из игры» приложение закрывается. Идеальный.

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

Для этого создадим новый игровой объект и прикрепим к нему наш скрипт Buttons. Затем мы нажимаем на кнопку и спускаемся туда, где написано «On Click». Мы перетаскиваем туда игровой объект со скриптом и выбираем из выпадающего списка функцию, которую хотим вызвать. Проделываем это для обеих кнопок и теперь они обе работают.

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

Игровая сцена

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

Во-первых, мы настроим сцену так, как мы хотим. Вот как я это сделал ниже.

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

Во-первых, нам нужно, чтобы доска действительно падала во время игры. Для этого мы щелкнем по доске и добавим компонент под названием RigidBody 2D и применим к нему следующие настройки.

Как видите, шкала гравитации в настоящее время установлена ​​на 0, это значит, что планка не падает, пока висит на лебедке. Мы хотим, чтобы он падал только тогда, когда пользователь касается экрана.

Для этого нам нужен скрипт. Я сделал новый скрипт под названием MakePlankFall и добавил следующий код.

Во-первых, у нас есть условие if, которое выполняется только при касании экрана. Затем мы получаем ссылку на твердое тело, которое мы только что создали, и устанавливаем шкалу гравитации на 1. Это заставит доску падать при касании экрана.

Однако доска продолжает падать за пределы экрана и не останавливается, когда падает на землю. Это потому, что нам нужно добавить столкновение, чтобы доска и земля могли столкнуться. Для этого нажмите на объект и добавьте компонент под названием Box Collider 2D. Мы делаем это как для доски, так и для земли. Теперь, когда доска падает, она сталкивается с землей и останавливается. Идеальный.

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

Этот код заставляет кабель перемещаться вперед и назад по экрану, и когда достигается определенная граница по оси X, он меняет направление.

Чтобы это работало и с доской, мы добавляем следующий код в скрипт MakePlankFall.

Теперь наша лебедка и доска будут двигаться вперед и назад по экрану вместе.

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

Итак, нам нужно создать доску там, где в данный момент лебедка находится на экране. Мы также хотим, чтобы была небольшая задержка между моментом падения одной доски и моментом, когда ее место заняла другая. Для этого мы используем энумератор, который будет ждать одну секунду, прежде чем создать еще одну планку, когда пользователь коснется экрана. И помните, когда пользователь касается экрана, мы устанавливаем шкалу гравитации досок на 1, чтобы они падали. Итак, прежде чем мы создадим новую, нам нужно сбросить это значение до 0. Затем мы используем функцию создания экземпляра, чтобы создать доску в текущем положении лебедки, которую мы постоянно отслеживаем в функции обновления.

Функция Begin вызывается в конце нашего оператора if, проверяющего нажатие пользователя.

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

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

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

Я сделал это с помощью следующего кода.

Вы можете видеть, что у меня есть переход сцены в файле под названием Crossfade. Это потому, что у меня есть анимация, которая переносит нас между сценами. Не волнуйтесь, я расскажу обо всем этом в разделе анимации. На данный момент вам просто нужно сосредоточиться на строке «SceneManager.LoadScene(levelName)», так как это то, что переводит нас между сценами.

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

Чтобы сделать это, я проверил, в какой момент стопка оказалась слишком близко к верхней части экрана, и выбрал ее как точку, в которой мы двигались вверх. Код для этого очень прост. У меня есть значение счетчика, которое увеличивается каждый раз, когда падает доска. Когда счет достигает 11, все сдвигается вверх, и мы сбрасываемся обратно на 0. Я уверен, что это не оптимальный способ сделать это, но для игры это работает.

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

Привязан к объекту лебедкеПрикреплен к фоновому объектуПрикреплен к основной камере

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

А теперь подведем итоги. Это тоже довольно легко. Мы создаем холст и текстовый элемент TextMeshPro и устанавливаем для ввода текста значение 0. Затем мы создаем пустой игровой объект в сцене и создаем новый сценарий C#, присоединяя указанный сценарий к игровому объекту. Вам нужен скрипт, прикрепленный к игровому объекту, чтобы он что-то делал.

В нашем новом партитуре есть следующий код.

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

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

Конечная сцена

Это макет, который я выбрал. Очень просто, но я думаю, что это выглядит красиво. Теперь у нас есть несколько элементов. Текст вверху можно оставить в покое, пока мы не дойдем до анимации. Текст Restart — это кнопка, поэтому нам нужно ее настроить.

Помните, что для создания кнопки мы щелкаем правой кнопкой мыши в иерархии и создаем кнопку TextMeshPro элемента пользовательского интерфейса. Мы меняем текст в этой кнопке на Restart.

Затем мы создаем новый игровой объект, присоединяя к нему новый скрипт под названием Restart. А в этом скрипте у нас просто есть функция, которая снова загрузит основную сцену, нашу игровую сцену.

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

Наконец, у нас есть элементы счета и рекорда. Я просто создал текстовые элементы TextMeshPro и изменил текст на то, что вы видите на изображении. Я сделал числа независимыми элементами от всего остального, так как мы захотим их изменить, а использование их в качестве собственных текстовых элементов делает это намного проще.

Теперь ты знаешь упражнение. Создайте новый игровой объект и прикрепите к нему новый скрипт. Этот скрипт содержит следующий код.

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

Чтобы узнать, является ли текущий счет новым рекордом, у нас есть сценарий GameManager со следующей функцией внутри.

Это проверит, выше ли текущий счет, чем рекорд, и если да, то установит новый рекорд как текущий балл.

Здесь эта функция вызывается внутри сценария MakePlankFall.

Как видите, вызывается, когда планка падает ниже нашего порога Y, т.е. игра заканчивается, потому что стопка перевернулась.

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

Следующий шаг — перейти к анимации. Обещаю, это будет короче. Вот так.

Анимации

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

Анимации тоже очень простые, так как у нас нет персонажей, которых нужно анимировать или что-то еще, только некоторые переходы между текстом и сценами.

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

Начнем с названия игры.

Это может быть сложно объяснить в письменной форме, поэтому я дам ссылку на отличное видео на YouTube, которое вы можете посмотреть, если запутались: https://www.youtube.com/watch?v=CE9VOZivb3I

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

Щелкните объект, который хотите анимировать, и перейдите на вкладку анимации внизу. Если вкладки нет, просто перейдите в «Окно» -> «Анимация» -> «Анимация» и просто закрепите ее внизу.

Когда вы впервые нажмете на объект, вы увидите, что он дает вам кнопку под названием «Создать». Щелкните здесь и назовите свою анимацию.

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

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

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

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

Вот как у меня выглядит титульный свиток. Довольно просто и отлично работает.

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

Два разных аниматора. Один для дерева, поднимающегося и опускающегося в исходное положение. А второй для дерева, спускающегося вниз и возвращающегося в исходное положение. Итак, для анимации в целом.

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

Создает одну непрерывную анимацию движения дерева вверх вниз, вверх вниз, вверх вниз.

На главном экране все, давайте перейдем к игровой сцене.

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

Переход для начала игрыПереход между игровой сценой и конечной сценой

Для этого я создал новый холст и черный прямоугольник как дочерний элемент этого холста.

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

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

Вы можете увидеть аниматор для этого ниже.

Для перехода между игровой сценой и конечной сценой нам нужен этот код из предыдущего:

И эта функция вызывается в сценарии MakePlankFall здесь:

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

Вот и все, что касается игровой сцены.

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

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

Следующий раздел — музыка!

Музыка

Я просто хотел немного фоновой музыки для игры. Я еще недостаточно опытен, чтобы сделать это самостоятельно, поэтому я нашел на YouTube музыку, не защищенную авторскими правами, и скачал ее в формате mp3, а затем перетащил в Unity.

Чтобы использовать его, я перешел на домашнюю сцену, создал новый игровой объект и добавил компонент под названием Audio Source. В раздел audioclip я перетащил только что импортированный mp3. Таким образом, это будет воспроизводиться при загрузке домашнего экрана, однако в тот момент, когда пользователь запускает игру, музыка остановится, поскольку она загружается только в этой одной сцене.

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

Это предотвратит разрушение игрового объекта при загрузке новой сцены, и музыка продолжит играть. Я также установил флажок Loop под источником звука, чтобы, когда песня закончится, она просто воспроизвелась снова.

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

Используя свой микрофон и Audacity, я ударил кулаком по столу, издав глухой звук. Затем я импортировал этот звук в Unity.

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

Затем я добавил к объекту еще один Box Collider 2d, но сделал этот новый триггером. Это вызовет функцию OnCollisionEnter2D всякий раз, когда что-то касается доски, например, другая доска падает на нее сверху.

Следующий ниже код вызывает воспроизведение звукового эффекта.

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

И это все, что касается музыкального раздела.

Игра в целом почти готова.

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

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

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

Итак, поехали.

Публикация

Чтобы опубликовать игру в Google Play, нам сначала нужно сделать несколько вещей в Unity.

Убедитесь, что у вас установлена ​​платформа Android и все ваши сцены загружаются вверху.

Затем перейдите в «Файл» > «Настройки сборки» > «Настройки проигрывателя» > «Другие настройки» и прокрутите вниз, пока не увидите что-то похожее на изображение ниже.

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

Затем вы выбираете версию. Просто введите какое-нибудь число. То же самое с кодом версии пакета.

Для минимального и целевого уровня API Google Play теперь требует, чтобы ваш целевой API был не ниже 30. Если он еще не установлен, вы можете загрузить его из Android Studio и скопировать и вставить папку в Unity. Здесь немного больше, поэтому, если вы застряли с этим, дайте мне знать, и я постараюсь помочь.

Наконец, убедитесь, что вы отметили ARM64 в разделе «Целевые архитектуры».

Теперь перейдите к Publishing Settings , который находится на той же странице, и нажмите Keystore Manager . Создайте новое хранилище ключей здесь. Вам нужно будет дать ему имя и пароль.

После этого выберите хранилище ключей здесь:

Теперь, если я не пропустил ни одного шага, вы сможете экспортировать игру и принять ее в Google Play.

Для этого вернитесь в настройки сборки и убедитесь, что вы отметили Сборка пакета приложений (Google Play) . Затем нажмите «Сборка» и дайте вашей сборке имя. После сборки он должен иметь расширение .aab .

Сделав это, я зашел в онлайн-консоль Google Play. Вы должны заплатить единовременную плату в размере 25 долларов США за публикацию игр. Но после этого вы можете публиковать столько, сколько хотите, и вам больше никогда не придется платить.

Оказавшись там, я нажал кнопку «Создать приложение» в правом верхнем углу и последовал их инструкциям. Они дадут вам пошаговую инструкцию по всем вопросам.

Вот опубликованное приложение ниже в Google Play Console:

И все! Мы наконец закончили. Я впечатлен, если вы зашли так далеко, и я надеюсь, что вы почерпнули хотя бы одну ценную вещь из этой статьи. Сборка заняла очень много времени, но мне очень понравился этот процесс.

Спасибо за ваше время и удачи в ваших собственных проектах.

Как создать 2D-игру с помощью Python и библиотеки Arcade

Python — отличный язык для тех, кто учится программировать, и идеально подходит для тех, кто хочет «довести дело до конца» и не тратить кучу времени на шаблонный код. Arcade — это библиотека Python для создания 2D-видеоигр, которую легко начать использовать, и она становится очень функциональной по мере приобретения опыта. В этой статье я объясню, как начать использовать Python и Arcade для программирования видеоигр.

Я начал разработку Arcade после обучения студентов использованию библиотеки PyGame. Я преподавал лично с помощью PyGame почти 10 лет и разработал ProgramArcadeGames.com для онлайн-обучения. PyGame великолепен, но в конце концов я почувствовал, что трачу время на исправление ошибок, которые так и не были исправлены.

Я беспокоился об обучении таким вещам, как цикл событий, который больше не был способом, которым мы программируем. У меня был целый раздел, в котором я объяснял, почему координаты y поменялись местами. Поскольку PyGame редко обновлялся и основан на старой библиотеке SDL 1, а не на чем-то более современном, таком как OpenGL, я не питал особых надежд на будущее.

Мне нужна была библиотека, которая была бы проще в использовании, более мощная и использовала бы некоторые новые функции Python 3, такие как декораторы и подсказки типов. Аркада это. И вот как начать.

Установка

Arcade, как и многие другие пакеты, доступен через PyPi, что означает, что вы можете установить Arcade с помощью команды pip (или команды pipenv). Если у вас уже установлен Python, вы, вероятно, можете просто открыть командную строку в Windows и ввести:

 pip установить аркаду
 

Или в MacOS и Linux введите:

 pip3 install arcade
 

Более подробные инструкции по установке можно найти в документации по установке Arcade.

Простой рисунок

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

Автор изображения:

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

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

 импортная аркада
# Установить константы для размера экрана
ШИРИНА_ЭКРАНА = 600
SCREEN_HEIGHT = 600
# Открой окно. Установите заголовок окна и размеры (ширину и высоту)
arcade.open_window(SCREEN_WIDTH, SCREEN_HEIGHT, "Пример рисования")
# Установить белый цвет фона.
# Список именованных цветов см.:
# http://arcade.academy/arcade.color.html
# Цвета также могут быть указаны в формате (красный, зеленый, синий) и
# (красный, зеленый, синий, альфа-канал).
arcade.set_background_color(arcade.color.WHITE)
# Запускаем процесс рендеринга. Это должно быть сделано перед любыми командами рисования.
аркада.start_render()
# Рисуем лицо
х = 300
у = 300
радиус = 200
arcade.draw_circle_filled(x, y, радиус, arcade.color.YELLOW)
# Нарисуйте правый глаз
х = 370
у = 350
радиус = 20
arcade.draw_circle_filled(x, y, радиус, arcade.color.BLACK)
# Рисуем левый глаз
х = 230
у = 350
радиус = 20
arcade. draw_circle_filled(x, y, радиус, arcade.color.BLACK)
# Рисуем улыбку
х = 300
у = 280
ширина = 120
высота = 100
начальный_угол = 190
конечный_угол = 350
arcade.draw_arc_outline(x, y, ширина, высота, arcade.color.BLACK, start_angle, end_angle, 10)
# Завершить рисование и отобразить результат
аркада.finish_render()
# Держите окно открытым, пока пользователь не нажмет кнопку "закрыть"
аркада.run()
 

Использование функций

Конечно, писать код в глобальном контексте — нехорошо. К счастью, улучшить программу с помощью функций несложно. Здесь мы можем увидеть пример рисования сосны в определенном (x, y) месте с помощью функции:

 по определению draw_pine_tree(x, y):
    """ Эта функция рисует сосну в указанном месте. """
    
    # Нарисуйте треугольник в верхней части ствола.
    # Нам нужны три точки x, y для треугольника.
    arcade.draw_triangle_filled(x + 40, y, # Точка 1
                                х, у - 100, # Точка 2
                                х + 80, у - 100, # Точка 3
                                аркадный. цвет.DARK_GREEN)
    # Рисуем ствол
    arcade.draw_lrtb_rectangle_filled(x + 30, x + 50, y - 100, y - 140,
                                      аркадный.цвет.DARK_BROWN)
 

Полный пример см. на чертеже с функциями.

Более опытный программист знает, что современные графические программы сначала загружают информацию о рисовании в графическую карту, а затем просят графическую карту отрисовать ее позже в виде пакета. Arcade также поддерживает это. Рисование 10 000 прямоугольников по отдельности занимает около 0,800 секунды. Рисование их в виде пакета занимает менее 0,001 секунды.

Класс Window

Более крупные программы обычно наследуются от класса Window или используют декораторы. Это позволяет программисту писать код для обработки рисования, обновления и обработки ввода от пользователя. Шаблон для начала Программа на базе Window приведена ниже.

 импортная аркада
ШИРИНА_ЭКРАНА = 800
SCREEN_HEIGHT = 600
класс MyGame(arcade. Window):
    """ Класс основного приложения. """
    def __init__(я, ширина, высота):
        super().__init__(ширина, высота)
        arcade.set_background_color(arcade.color.AMAZON)
    Настройка защиты (самостоятельно):
        # Настройте свою игру здесь
        проходить
    защита on_draw(я):
        """ Рендеринг экрана. """
        аркада.start_render()
        # Ваш код рисования находится здесь
    обновление защиты (я, delta_time):
        """ Вся логика хода, и игровая логика здесь. """
        проходить
деф основной():
    игра = Моя игра(SCREEN_WIDTH, SCREEN_HEIGHT)
    игра.настройка()
    аркада.run()
если __name__ == "__main__":
    основной()
 

Класс Window имеет несколько методов, которые ваши программы могут переопределить, чтобы обеспечить функциональность программы. Вот некоторые из наиболее часто используемых:

• on_draw : Здесь находится весь код для рисования экрана.
• обновление : весь код для перемещения ваших предметов и выполнения игровой логики находится здесь. Это вызывается около 60 раз в секунду.
• on_key_press : Обработка событий при нажатии клавиши, например, придание игроку скорости.
• on_key_release : Обработка отпускания клавиши, здесь вы можете остановить движение игрока.
• on_mouse_motion : вызывается каждый раз, когда мышь движется.
• on_mouse_press : Вызывается при нажатии кнопки мыши.
• set_viewport : Эта функция используется в играх с прокруткой, когда у вас есть мир намного больше, чем то, что можно увидеть на одном экране. Вызов set_viewport позволяет программисту установить, какая часть этого мира в данный момент видна.

Спрайты

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

Создание спрайта

Создать экземпляр класса Arcade Sprite из графики очень просто. Программисту нужно только имя файла изображения, на основе которого будет создан спрайт, и, возможно, число для масштабирования изображения вверх или вниз. Например:

 SPRITE_SCALING_COIN = 0,2
монета = аркада.Sprite("coin_01.png", SPRITE_SCALING_COIN)
 

Этот код создаст спрайт, используя изображение, хранящееся в coin_01.png . Изображение будет уменьшено до 20% от исходной высоты и ширины.

Списки спрайтов

Спрайты обычно организованы в списки. Эти списки облегчают управление спрайтами. Спрайты в списке будут использовать OpenGL для пакетного рисования спрайтов как группы. Приведенный ниже код устанавливает игру с игроком и кучей монет, которые игрок должен собрать. Мы используем два списка, один для игрока и один для монет.

 настройка по умолчанию (само):
    """ Настройте игру и инициализируйте переменные.  """
    # Создаем списки спрайтов
    self.player_list = arcade.SpriteList()
    self.coin_list = arcade.SpriteList()
    # Счет
    самооценка = 0
    # Настраиваем плеер
    # Изображение персонажа из kenney.nl
    self.player_sprite = arcade.Sprite("images/character.png", SPRITE_SCALING_PLAYER)
    self.player_sprite.center_x = 50 # Стартовая позиция
    self.player_sprite.center_y = 50
    self.player_list.append(self.player_sprite)
    # Создаем монеты
    для i в диапазоне (COIN_COUNT):
        # Создаем экземпляр монеты
        # Изображение монеты с сайта kenney.nl
        монета = аркада.Sprite("images/coin_01.png", SPRITE_SCALING_COIN)
        # Разместите монету
        coin.center_x = случайный.randrange(SCREEN_WIDTH)
        coin.center_y = random.randrange(SCREEN_HEIGHT)
        # Добавляем монету в списки
        self.coin_list.append(монета)
 

Мы можем легко нарисовать все монеты в списках монет:

 def on_draw(self):
    """Нарисуй все"""
    аркада.start_render()
    self. coin_list.draw()
    self.player_list.draw()
 

Обнаружение столкновений спрайтов

Функция check_for_collision_with_list позволяет нам увидеть, сталкивается ли спрайт с другим спрайтом в списке. Мы можем использовать это, чтобы увидеть все монеты, с которыми соприкасается спрайт игрока. Используя простой цикл на , мы можем избавиться от монеты из игры и увеличить наш счет.

 обновление по определению (я, дельта_время):
    # Сгенерировать список всех монетных спрайтов, которые столкнулись с игроком.
    Coins_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.coin_list)
    # Прокручиваем каждый сталкивающийся спрайт, удаляем его и добавляем к счету.
    для монеты в opens_hit_list:
        монета.убить()
        самооценка += 1
 

Полный пример см. в collect_coins.py.

Игровая физика

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

Игры сверху вниз

Для простых игр с видом сверху программе Arcade требуется список стен, через которые игрок (или кто-либо еще) не может пройти. Я обычно называю это wall_list . Затем в коде установки класса Window создается физический движок:

 self.physics_engine = arcade.PhysicsEngineSimple(self.player_sprite, self.wall_list)
 

player_sprite получает вектор движения с двумя атрибутами change_x и change_y . Простым примером этого может быть перемещение игрока с помощью клавиатуры. Например, это может быть в пользовательском дочернем элементе класса Window :

 MOVEMENT_SPEED = 5
def on_key_press (я, клавиша, модификаторы):
    """Вызывается всякий раз, когда нажимается клавиша.  """
    если ключ == arcade.key.UP:
        self.player_sprite.change_y = ДВИЖЕНИЕ_СКОРОСТЬ
    ключ elif == arcade.key.DOWN:
        self.player_sprite.change_y = -MOVEMENT_SPEED
    elif key == arcade.key.LEFT:
        self.player_sprite.change_x = -MOVEMENT_SPEED
    ключ elif == arcade.key.RIGHT:
        self.player_sprite.change_x = ДВИЖЕНИЕ_СКОРОСТЬ
def on_key_release (я, ключ, модификаторы):
    """Вызывается, когда пользователь отпускает клавишу. """
    если клавиша == arcade.key.UP или клавиша == arcade.key.DOWN:
        self.player_sprite.change_y = 0
    elif key == arcade.key.LEFT или key == arcade.key.RIGHT:
        self.player_sprite.change_x = 0
 

Хотя этот код устанавливает скорость игрока, он не перемещает игрока. В методе update класса Window вызов physics_engine.update() будет перемещать игрока, но не сквозь стены.

 обновление по определению (я, дельта_время):
    """Движение и игровая логика"""
     self. physics_engine.update()
 

Полный пример см. в sprite_move_walls.py.

Платформеры

Перейти на платформер с видом сбоку довольно просто. Программисту просто нужно переключить физический движок на PhysicsEnginePlatformer и добавьте гравитационную постоянную.

 self.physics_engine = аркада.PhysicsEnginePlatformer(self.player_sprite,
                                                     self.wall_list,
                                                     gravity_constant=ГРАВИТАЦИЯ)
 

Вы можете использовать такую ​​программу, как Tiled, чтобы укладывать плитки/блоки, из которых состоит ваш уровень.

Пример см. в файле sprite_tiled_map.py.

Для полной 2D-физики вы можете интегрировать библиотеку PyMunk.

Учиться на примере

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