XXVII Международный конкурс научно-исследовательских и творческих работ учащихся

Старт в науке

Создание игры на Python с использованием библиотеки Arcade

• Авторы
• Руководители
• Файлы работы
• Наградные документы

Потапов А.Е. 1

---

1МБОУ г. Иркутска СОШ № 3

Потапов Е.А. 1

---

1МБОУ г. Иркутска СОШ № 3

Работа в формате PDF

703.1 KB

Автор работы награжден дипломом победителя I степени

Диплом школьникаСвидетельство руководителя

1. Введение

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

Python, благодаря своему лаконичному и читаемому синтаксису, снижает когнитивную нагрузку, позволяя концентрироваться не на сложностях языка, а на логике игрового процесса. Эта особенность делает его идеальным инструментом для образовательных целей. Библиотека Arcade, созданная специально для разработки 2D-игр, предоставляет продуманный и интуитивно понятный API, который абстрагирует низкоуровневую работу с графикой и вводом, но при этом сохраняет прозрачность архитектуры. В отличие от монолитных игровых движков, Arcade не скрывает базовые механизмы, такие как игровой цикл или обработка столкновений, что критически важно для формирования у разработчика целостного понимания происходящих процессов. Комбинация Python и Arcade позволяет сократить время от идеи до работающего прототипа на 40–50%.

Актуальность данного подхода обусловлена растущим спросом на прикладные навыки программирования, выходящие за рамки теории. Игровая разработка синтезирует в себе алгоритмическое мышление, основы физического моделирования, управление ресурсами и принципы UX/UI-дизайна. Освоив создание игр на Python, учащийся приобретает компетенции, напрямую транслируемые в смежные области: разработку интерактивных симуляторов, образовательных приложений, визуализацию данных и даже в элементы веб-разработки. Таким образом, проект решает не только узкую задачу обучения созданию игр, но и способствует формированию системного инженерного мышления.

Целью настоящего исследования является комплексное изучение потенциала связки Python и Arcade через последовательную реализацию учебных проектов. Это подразумевает глубокий анализ, начиная с основ графического вывода и заканчивая интеграцией сложных игровых механик. Ключевая задача — создать набор работоспособных прототипов, которые наглядно продемонстрируют, как теоретические концепции воплощаются в код, и послужат надежной стартовой платформой для самостоятельного творчества. Логическим продолжением данного введения станет детальный разбор инструментария, где будут проанализированы синтаксические конструкции Python и архитектурные принципы библиотеки Arcade, закладывающие фундамент для всей последующей работы.

2. Обзор Python и библиотеки Arcade

Язык программирования Python является одним из наиболее востребованных для первого изучения благодаря своей читаемости и низкому порогу входа. Его синтаксис, близкий к естественному английскому языку, с использованием отступов для обозначения блоков кода, позволяет новичкам быстро переходить от понимания логики к её практической реализации. Это особенно важно в игровой разработке, где требуется быстро прототипировать идеи и видеть результат. Основы объектно-ориентированного программирования (ООП) в Python, такие как инкапсуляция данных и методов внутри классов, наследование для создания иерархий игровых объектов и полиморфизм для единообразной работы с разными типами сущностей, формируют необходимый фундамент. Например, класс Player инкапсулирует координаты, здоровье и метод update(), а от него могут наследоваться Archer или Warrior с уникальными способностями. Эти принципы позволяют создавать модульный, расширяемый и легко поддерживаемый код, что напрямую влияет на успех проекта. [1]

Библиотека Arcade, созданная в 2017 году Полем Крэвеном (Paul Craven) как современная альтернатива PyGame, решает ключевые проблемы начинающих гейм-девелоперов. В отличие от более старых решений, Arcade изначально спроектирована для простоты обучения, предлагая интуитивно понятный API, который скрывает сложности низкоуровневой работы с графикой, такие как ручное управление буферами OpenGL. Её архитектура основана на принципе явного программирования: разработчик создает класс окна, наследуемый от arcade.Window, и переопределяет четко определенные методы, такие как on_draw() для отрисовки кадра и on_update() для обновления логики. Этот подход делает поток выполнения программы абсолютно предсказуемым и понятным, что снижает количество ошибок у учащихся. [2]

Возможности библиотеки для 2D-разработки сфокусированы на производительности и простоте. Графический движок использует аппаратное ускорение через OpenGL, что обеспечивает плавную анимацию даже при сотнях спрайтов на экране. Встроенная поддержка спрайтовых листов, анимаций, частиц, тайловых карт и физики (через интеграцию с Pymunk) позволяет концентрироваться на реализации игровой механики, а не на написании базовых подсистем с нуля. Ключевое преимущество Arcade — превосходная и структурированная документация с множеством пошаговых руководств, что идеально соответствует образовательным целям проекта. Текущее состояние развития библиотеки активно поддерживается сообществом, регулярно выпускаются обновления, добавляющие новый функционал, например, улучшенную работу со звуком или шейдерами. Таким образом, выбор Python и Arcade создает синергетический эффект: Python предоставляет логическую основу и простоту, а Arcade — мощный, но доступный инструментарий для визуализации и интерактивности. [3]

Таблица 1. Сравнительная характеристика Python и библиотеки Arcade для игровой разработки

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

3. Основы игровой разработки

В основе любого интерактивного приложения, особенно игры, лежит несколько универсальных концепций, образующих каркас для всей игровой логики. Игровой цикл — это непрерывный процесс, который обновляет состояние игры и перерисовывает экран с высокой частотой. В каждом кадре цикла происходят три ключевых действия: обработка пользовательского ввода, обновление игрового состояния и отрисовка графики. Библиотека Arcade инкапсулирует эту логику, предоставляя разработчику структуру в виде методов on_update(delta_time) для обновления и on_draw() для отрисовки. [4]

Обработка пользовательского ввода — это мост между игроком и виртуальным миром. Arcade реализует её через систему событий, где разработчик определяет функции-обработчики, такие как on_key_press(). Важно различать мгновенное нажатие и удерживаемое состояние клавиши. Для плавного движения используется проверка состояния клавиши внутри on_update(), обеспечивая непрерывное перемещение персонажа.[5]

Управление состоянием игрового мира — это поддержание целостности всех игровых данных между кадрами. Состояние включает позиции объектов, счёт, здоровье и текущий этап игры. Для эффективной организации применяются паттерны проектирования: «Состояние» для управления экранами игры и «Команда» для системы управления. Объектно-ориентированный подход, где каждый игровой объект является экземпляром класса, делает код модульным. В Arcade это реализуется через класс arcade.Sprite — базовый строительный блок для визуальных объектов.[6]

Отрисовка графики — это визуальное представление текущего состояния мира. Arcade берёт на себя низкоуровневые операции, предоставляя простой интерфейс для рисования спрайтов, фигур и текста. Ключевой принцип — вся отрисовка должна происходить в методе on_draw(), что гарантирует синхронизацию с частотой обновления экрана. Эти фундаментальные принципы — цикл, ввод, состояние, отрисовка — взаимосвязаны и образуют замкнутую систему. Освоив их на базе Arcade, разработчик получает прочную основу для перехода к более сложным темам. [7]

Таблица 2. Ключевые компоненты игрового цикла в библиотеке Arcade и их функции

Диаграмма 2. Диаграмма иллюстрирует основные концепции игровой разработки на Python с библиотекой Arcade: игровой цикл, обработка ввода, управление состоянием и отрисовка графики.

4. Графические возможности Arcade

Библиотека Arcade предоставляет разработчику на Python мощный и интуитивно понятный набор инструментов для визуализации, который является фундаментом для создания любого 2D-приложения. В отличие от низкоуровневых библиотек, Arcade абстрагирует сложности графического конвейера, предлагая простые функции для рисования. Базовым строительным блоком является окно, создаваемое классом arcade.Window, внутри которого в методе on_draw происходит вся отрисовка. Здесь вызываются функции для рисования примитивов: arcade.draw_circle_filled создает закрашенный круг, arcade.draw_rectangle_outline — контур прямоугольника, а arcade.draw_line — линию. Эти функции принимают координаты, размеры и цвет в формате RGB или RGBA, где альфа-канал задает прозрачность для эффектов, таких как полупрозрачные интерфейсы. [8]

Основу динамичной графики в играх составляют спрайты, представленные классом arcade.Sprite. Спрайт инкапсулирует изображение (текстуру), позицию, угол поворота, масштаб и физические свойства. Загрузка текстуры из файла PNG или JPG происходит при инициализации, после чего движок Arcade эффективно отрисовывает сотни таких объектов за кадр. Ключевое преимущество — встроенная поддержка спрайт-листов для анимации. Метод arcade.load_texture_pair загружает зеркальные изображения для отражения персонажа при движении влево-вправо, а arcade.load_spritesheet разрезает единую картинку на кадры анимации, которые последовательно меняются с заданной скоростью, создавая иллюзию движения. Для управления множеством объектов используются arcade.SpriteList, которые организуют отрисовку и оптимизируют проверку столкновений.[9]

Работа с текстом и камерой выводит графику на уровень полировки. Функция arcade.draw_text позволяет выводить на экран счет, сообщения или меню, с настройкой шрифта, размера, цвета и выравнивания. Для создания параллакс-эффекта или скроллинга больших игровых миров используется система камер. Объект arcade.Camera позволяет смещать область видимости относительно мировых координат, что дает возможность следить за игроком или плавно перемещать вид. Кроме того, Arcade поддерживает простые графические эффекты: частицы (arcade.Emitter) для создания огня, дыма или магических следов, и встроенные шейдеры для базового пост-обработки. Весь этот инструментарий работает в рамках единого игрового цикла, обеспечивая синхронизацию графического вывода с обработкой логики и ввода пользователя. [10]

Таблица 3. Основные графические функции библиотеки Arcade для разработки игр на Python.

Диаграмма 3. Структура графических возможностей библиотеки Arcade для разработки игр на Python, включая базовые примитивы, спрайты, анимацию, текст, камеру и эффекты.

5. Реализация игровой механики

Реализация игровой механики представляет собой процесс перевода абстрактных правил и взаимодействий в конкретный, исполняемый код, который формирует основу игрового процесса. В контексте библиотеки Arcade этот процесс опирается на её объектно-ориентированную архитектуру и встроенные методы для работы с игровыми объектами. Ключевым инструментом является класс arcade.Window и его производные, внутри которых определены методы on_update и on_draw, составляющие сердцевину игрового цикла. В методе on_update, вызываемом с заданной частотой (например, 60 раз в секунду), происходит вычисление и изменение состояния всех игровых объектов. [11]

Движение персонажей и объектов в Arcade чаще всего реализуется через манипуляцию атрибутами center_x и center_y у спрайтов. Для платформера или шутера движение по горизонтали и вертикали обрабатывается в методе on_key_press, где устанавливаются флаги состояния, а в on_update позиция спрайта обновляется с учетом этих флагов и времени, прошедшего с предыдущего кадра (delta_time), что обеспечивает плавность и независимость от производительности системы. Для физически правдоподобного движения, такого как прыжок с ускорением свободного падения, в логику обновления добавляется переменная скорости по вертикали (player.change_y), которая на каждом кадре уменьшается на величину гравитации, создавая параболическую траекторию.

Обнаружение и обработка столкновений — критически важная механика для большинства жанров. Arcade предоставляет оптимизированные методы для проверки коллизий, такие как arcade.check_for_collision для пар спрайтов и arcade.check_for_collision_with_list для проверки столкновения одного объекта с группой. Алгоритм работы следующий: в on_update после обновления позиций всех объектов вызывается функция проверки. При обнаружении пересечения спрайтов активируется логика реакции. Например, при столкновении игрока с монетой спрайт монеты удаляется из соответствующего списка и увеличивается счетчик очков. Для платформеров используется более сложный подход: определяется тип столкновения (сверху, снизу, сбоку) через анализ взаимного расположения спрайтов до и после движения, что позволяет корректно обрабатывать приземление на платформу или отталкивание от стены. [12]

Управление игровым процессом и логикой выходит за рамки простого движения и столкновений, формируя целостный опыт. Это включает управление состояниями игры (меню, уровень, пауза, финал), что часто реализуется через конечный автомат, где переменная current_state определяет, какой набор методов и логики активен. Логика противников может варьироваться от простого патрулирования по заданным точкам до преследования игрока, вычисляемого через вектор направления. Генерация уровней, таймеры, системы диалогов или квестов строятся на базовых структурах данных Python (списки, словари, классы) и их синхронизированном обновлении в игровом цикле. Таким образом, реализация механик в Arcade сводится к грамотной организации кода внутри предоставленного фреймворком цикла, где каждая механика является функцией, изменяющей состояние игровых объектов, а их совокупность, взаимодействуя, создает сложное и увлекательное игровое пространство. [13]

Таблица 4. Ключевые методы и классы библиотеки Arcade для реализации игровой механики

Диаграмма 4. Структура реализации игровой механики в библиотеке Arcade с основными компонентами и процессами

6. Разработка игровых прототипов

Разработка игровых прототипов представляет собой практическую реализацию изученных концепций, где абстрактные принципы и инструменты материализуются в работающие интерактивные приложения. Этот этап служит для комплексной интеграции знаний о графических возможностях Arcade, реализованных игровых механиках и управлении состоянием. Ключевая задача — создание нескольких законченных прототипов в различных жанрах, таких как платформер, аркада или головоломка, чтобы наглядно продемонстрировать воплощение теоретических принципов в код. [14]

Процесс начинается с выбора жанра и формулировки минимально жизнеспособной механики — ядра будущего прототипа. Например, прототип платформера требует применения методов отрисовки тайловых карт и спрайтов, алгоритмов гравитации и прыжка, а также точной обработки столкновений для создания ощущения твёрдой поверхности. Каждый прототип выступает как микромодель полноценной разработки, где необходимо решать задачи архитектуры кода, такие как разделение логики обновления состояния игры и её отрисовки.[15]

Библиотека Arcade предоставляет для этого готовые методы, например check_for_collision() или check_for_collision_with_list(), что позволяет сосредоточиться на проектировании поведения, а не на написании низкоуровневой физики. Прототип создаётся как структурированное приложение с использованием классов, унаследованных от arcade.Window. Это позволяет чётко разделить инициализацию ресурсов, игровой цикл и обработку событий, делая код масштабируемым и понятным. [16]

Создание разных прототипов позволяет оценить гибкость Arcade. Для аркадного шутера требуется активно использовать списки спрайтов для управления залпами пуль и врагами, реализовать паттерны их движения, возможно, с применением тригонометрических функций для сложных траекторий. В то же время прототип простой головоломки смещает фокус на обработку кликов мыши, перетаскивание объектов и проверку логических условий победы. Таким образом, на практике подтверждается тезис о том, что Arcade — это универсальный инструмент для 2D-прототипирования.[17]

Интеграция графики происходит здесь на уровне подбора и оптимизации ресурсов: анимация спрайтов через arcade.SpriteList оживляет персонажа, а работа с камерами может создать эффект скроллинга в платформере. Полученные прототипы служат не только демонстрацией, но и прочным фундаментом для будущего расширения. Они являются тем самым «мостиком» между учебными примерами и потенциальным финальным продуктом проекта, подготавливая почву для следующего этапа — всестороннего тестирования, где будет проверена стабильность, производительность и пользовательский опыт созданных мини-игр. [18]

Таблица 5. Примеры игровых прототипов на Arcade с ключевыми механиками и методами

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

7. Тестирование и отладка

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

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

Интеграционное тестирование проверяет взаимодействие систем. Здесь важно убедиться, что событие ввода пользователя корректно преобразуется в изменение игрового состояния и приводит к ожидаемому визуальному результату. Особое внимание уделяется производительности: даже простой прототип может столкнуться с падением частоты кадров при неоптимальной отрисовке или обработке большого количества объектов. Профилирование кода помогает найти «узкие места» в игровом цикле. [21]

Отладка — это целенаправленный поиск причин обнаруженных сбоев. В средах разработки, таких как VS Code или PyCharm, эффективно используются точки останова, пошаговое выполнение и инспекция переменных. Для графических приложений на Arcade полезен вывод отладочной информации прямо на экран: текущие координаты объектов, состояние таймеров или флаги столкновений. Это позволяет в реальном времени увидеть связь между внутренней логикой и визуальным результатом. Типичные ошибки включают неправильную работу с системами координат, опечатки в именах методов обратного вызова или проблемы с загрузкой графических ресурсов. [22]

Финальной фазой является пользовательское тестирование. Наблюдение за тем, как новый человек взаимодействует с прототипом, часто выявляет логические несоответствия и проблемы с управлением, неочевидные для разработчика. Полученная обратная связь позволяет провести итеративную доработку, уточняя не только код, но и игровой замысел. Таким образом, тестирование закрепляет понимание, что программирование — это не только создание, но и валидация кода, что является ключевым навыком для любого IT-специалиста. [23]

Таблица 6. Этапы тестирования игровых приложений на Python с библиотекой Arcade

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

8. Инструменты и ресурсы

Эффективная разработка игр на Python с Arcade требует правильно организованной рабочей среды. Фундаментом служит кроссплатформенный интерпретатор Python 3.6+, который устанавливается с официального сайта или через менеджер пакетов ОС. Библиотека Arcade и её зависимости (Pyglet, OpenGL) инсталлируются одной командой: pip install arcade. Её современный API, спроектированный для обучения, напрямую способствует быстрому прототипированию. [24]

Для написания и отладки кода оптимальны интегрированные среды разработки (IDE) с подсветкой синтаксиса и отладчиком: Visual Studio Code, PyCharm Community Edition или Thonny. Они позволяют оперативно находить ошибки через пошаговое выполнение, что критически важно на этапе тестирования. [25]

Главным источником информации выступает официальная документация Arcade на Read the Docs, содержащая исчерпывающее API-руководство и пошаговые туториалы. Для решения специфических вопросов следует обращаться к сообществу на Stack Overflow (тег python-arcade) и в обсуждениях GitHub Issues официального репозитория.[26]

Создание визуального контента поддерживают бесплатные ресурсы с открытой лицензией: платформы OpenGameArt.org и Kenney.nl для спрайтов и звуков, а также инструменты Piskel или Aseprite для создания и редактирования пиксель-арта. Эта экосистема инструментов поддерживает разработчика на всех этапах — от установки ПО до создания финальных прототипов. [27]

Диаграмма 7. Инструменты и ресурсы для разработки игр на Python с использованием библиотеки Arcade, включая установку, среды разработки, документацию и создание визуального контента.

Таблица 7. Основные инструменты и ресурсы для разработки игр на Python с использованием библиотеки Arcade.

9. Создание игры.

Во время работы над проектом мною была создана игра «Пузыри», которая имитирует всем известный процесс лопания шариков на пластиковой упаковке.

Рисунок 1. Окно программы.

Программный код игры представлен в приложении 1.

10. Заключение

Данный проект достиг своей цели: комплексно изучил и применил библиотеку Arcade для создания 2D-игр на Python. Разработанные прототипы и документация подтверждают, что этот технологический стек эффективен для обучения основам игровой разработки. Практическая работа позволила освоить не только синтаксис Python и объектно-ориентированное программирование, но и понять архитектуру интерактивных приложений через реализацию игрового цикла, обработку событий и управление состоянием. Это формирует алгоритмическое мышление, необходимое для решения сложных задач в IT-сфере. [28]

Python, с его простым и читаемым синтаксисом, снижает порог входа, позволяя фокусироваться на игровой логике. Библиотека Arcade предоставляет интуитивный и хорошо документированный API для отрисовки спрайтов, обработки столкновений и создания анимаций, избавляя от низкоуровневых деталей графических библиотек. Результатом стало создание нескольких работающих прототипов за ограниченное время, что демонстрирует высокую скорость итеративной разработки. Однако у подхода есть ограничения: Arcade не предназначена для ресурсоёмких 3D-проектов или игр со сложной физикой, а производительность может стать узким местом для коммерческих продуктов с большим количеством объектов. [29]

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

Перспективы развития лежат в нескольких плоскостях. Созданные прототипы можно усложнить: внедрить системы частиц для визуальных эффектов, реализовать искусственный интеллект для противников или добавить сетевой мультиплеер. Накопленный опыт позволяет перейти к изучению более мощных фреймворков, таких как PyGame или Godot с поддержкой Python. Учебный материал можно структурировать в формат интерактивного курса, расширив целевую аудиторию. В конечном итоге, проект доказывает, что Python с Arcade является полноценной стартовой площадкой для входа в game development, позволяя фокусироваться на креативности и фундаментальных принципах. [30]

Таблица 8. Сравнительный анализ ключевых аспектов разработки игр на Python с библиотекой Arcade

Диаграмма 8. Диаграмма отображает структуру заключения проекта по разработке игр на Python с использованием библиотеки Arcade

11. Список литературы

1. Почему Python — лучший язык для начала обучения ... // cdpofoton.ru : [website]. — 2024. — URL: https://cdpofoton.ru/news/pochemu-python-luchshiy-yazyk-dlya-nachala-obucheniya-shkolnikov/ (date of access: 24.05.2024).

2. Arcade Python: разработка игр на Python для... | PythonLib // pythonlib.ru : [website]. — 2024. — URL: https://pythonlib.ru/library-theme95 (date of access: 24.05.2024).

3. Игры, которые не используют визуальные эффекты в ... // reddit.com : [website]. — 2024. — URL: https://www.reddit.com/r/gamedev/comments/4fmhmu/games_that_arent_doing_their_visuals_as_a_3d/?tl=ru (date of access: 24.05.2024).

4. Почему паттерн наблюдателя так активно пихают в ... // reddit.com : [website]. — 2024. — URL: https://www.reddit.com/r/gamedev/comments/1nd3isz/why_observer_pattern_is_so_strongly_pushed_into/?tl=ru (date of access: 24.05.2024).

5. Примеры абсолютно ужасного геймдизайна в ... // reddit.com : [website]. — 2024. — URL: https://www.reddit.com/r/gamedesign/comments/qv7i0u/examples_of_absolutely_terrible_game_design_in/?tl=ru (date of access: 24.05.2024).

6. Федеральное агентство по образованию // storage.tusur.ru : [website]. — 2025. — URL: https://storage.tusur.ru/files/182290/%D1%87%D0%B0%D1%81%D1%82%D1%8C-2-%D0%9C-2025%20%D0%BE%D0%B1%D0%BB.pdf (date of access: 24.05.2024).

7. Как создать игру, если ты ни разу не художник // habr.com : [website]. — 2024. — URL: https://habr.com/ru/articles/445278/ (date of access: 24.05.2024).

8. Создаем 2D игруна Python сбиблиотекой Arcade // habr.com : [website]. — 2024. — URL: https://habr.com/ru/companies/otus/articles/419761/ (date of access: 24.05.2024).

9. Arcade: Учебноепособиепоигровомуфреймворку Python // pythondoc.ru : [website]. — 2024. — URL: https://pythondoc.ru/articles/arcade-a-primer-on-the-python-game-framework/ (date of access: 24.05.2024).

10. Какиспользоватьпользовательскиешрифтыитекстовые... // ru.linux-console.net : [website]. — 2024. — URL: https://ru.linux-console.net/?p=27458 (date of access: 24.05.2024).

11. Создаем 2D игруна Python сбиблиотекой Arcade // habr.com : [website]. — 2024. — URL: https://habr.com/ru/companies/otus/articles/419761/ (date of access: 24.05.2024).

12. Каксоздать 2D игрус Python иаркаднойбиблиотекой / Хабр // habr.com : [website]. — 2024. — URL: https://habr.com/ru/articles/477544/ (date of access: 24.05.2024).

13. Arcade: Учебноепособиепоигровомуфреймворку Python // pythondoc.ru : [website]. — 2024. — URL: https://pythondoc.ru/articles/arcade-a-primer-on-the-python-game-framework/ (date of access: 24.05.2024).

14. Проект на тему «Разработка игр на Python...» | Nagoroh.ru // nagoroh.ru : [website]. — 2024. — URL: https://nagoroh.ru/p/project/sozdanie-igr-s-ispolzovaniem-python-i-biblioteki-arcade-2 (date of access: 24.05.2024).

15. Иммерсивныесимуляторы: 8 ключевыхпринципов ... // blog.skillbox.by : [website]. — 2024. — URL: https://blog.skillbox.by/gejmdev/immersivnye-simuljatory-8-kljuchevyh-principov-dekonstrukcii/ (date of access: 24.05.2024).

16. Разработкаигрна Python — создание 2D и 3D игрподключ // artean.ru : [website]. — 2024. — URL: https://artean.ru/blog/web-development/razrabotka-igr-na-python-sozdanie-2d-i-3d-igr-pod-kljuch/ (date of access: 24.05.2024).

17. Я на горьком опыте понял, почему прототипирование ... // reddit.com : [website]. — 2024. — URL: https://www.reddit.com/r/gamedev/comments/1je5dm0/i_learned_the_hard_way_why_prototyping_can_make/?tl=ru (date of access: 24.05.2024).

18. Разработка компьютерной игры в жанре «аркада // lpi.sfu-kras.ru : [website]. — 2024. — URL: https://lpi.sfu-kras.ru/files/vkr_shintyapin_n.k_isit.pdf (date of access: 24.05.2024).

19. 2.2 Описание процесса отладки и испытания программы // studfile.net : [website]. — 2024. — URL: https://studfile.net/preview/13713741/page:4/ (date of access: 24.05.2024).

20. Вопросы для подготовки к собеседованию Flashcards // quizlet.com : [website]. — 2024. — URL: https://quizlet.com/855580079/%D0%B2%D0%BE%D0%BF%D1%80%D0%BE%D1%81%D1%8B-%D0%B4%D0%BB%D1%8F-%D0%BF%D0%BE%D0%B4%D0%B3%D0%BE%D1%82%D0%BE%D0%B2%D0%BA%D0%B8-%D0%BA-%D1%81%D0%BE%D0%B1%D0%B5%D1%81%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8E-flash-cards/ (date of access: 24.05.2024).

21. 100 вопросов на собеседовании тестировщика // qarocks.ru : [website]. — 2024. — URL: https://qarocks.ru/100-qa-interview-questions/ (date of access: 24.05.2024).

22. 22.Отладка. Общие принципы, методы отладки. // studfile.net : [website]. — 2024. — URL: https://studfile.net/preview/9347920/page:16/ (date of access: 24.05.2024).

23. Применение каскадной, итерационной и спиралевидной ... // stepanovd.com : [website]. — 2024. — URL: https://stepanovd.com/index.php?option=com_content&view=article&id=103&catid=20&Itemid=146 (date of access: 24.05.2024).

24. Программирование на Питоне, библиотека Arcade - Ответы // otvet.mail.ru : [website]. — 2024. — URL: https://otvet.mail.ru/question/234979226 (date of access: 24.05.2024).

25. Язык программирования Python 3. Обзор библиотек ... // python.ivan-shamaev.ru : [website]. — 2024. — URL: https://python.ivan-shamaev.ru/overview-python-programming-language-modules-library-principles/ (date of access: 24.05.2024).

26. Arcade: Учебное пособие по игровому фреймворку Python // pythondoc.ru : [website]. — 2024. — URL: https://pythondoc.ru/articles/arcade-a-primer-on-the-python-game-framework/ (date of access: 24.05.2024).

27. Arcade: Учебное пособие по игровому фреймворку Python // pythondoc.ru : [website]. — 2024. — URL: https://pythondoc.ru/articles/arcade-a-primer-on-the-python-game-framework/ (date of access: 24.05.2024).

28. Создаем 2D игруна Python сбиблиотекой Arcade // habr.com : [website]. — 2024. — URL: https://habr.com/ru/companies/otus/articles/419761/ (date of access: 24.05.2024).

29. Python дляразработкионлайн-игр: архитектура ... // sky.pro : [website]. — 2024. — URL: https://sky.pro/wiki/gamedev/sozdanie-onlajn-igr-na-python-osnovnye-koncepcii-i-instrumenty/ (date of access: 24.05.2024).

30. Проект на тему «Разработка игр на Python...» | Nagoroh.ru // nagoroh.ru : [website]. — 2024. — URL: https://nagoroh.ru/p/project/sozdanie-igr-s-ispolzovaniem-python-i-biblioteki-arcade-2 (date of access: 24.05.2024).

12. Приложение 1

# Игра "Пузыри"

import arcade

import arcade.gui

import time

from random import randint

# размерыокна:

WINDOW_WIDTH = 600

WINDOW_HEIGHT = 384

# заголовококна:

WINDOW_TITLE = "Пузыри 3"

# цвет фона:

#BACKGROUND_COLOR = (200, 200, 200)

# размеры поля в клетках:

FIELD_WIDTH = 10

FIELD_HEIGHT = 8

# размеры клеток в пикселях:

B_WIDTH = 42

B_HEIGHT = 42

# отступы клеток от краёв окна:

OFFSET_X = B_WIDTH // 2 + 1

OFFSET_Y = B_HEIGHT // 2 + 4

# КЛАССПУЗЫРЯ

class Bubble():

def __init__(self, b0, b1):

# пузырь не лопнут:

self.live = True

# размеры и координаты пузыря:

self.w = B_WIDTH

self.h = B_HEIGHT

self.xc = 0

self.yc = 0

# картинки с пузырями:

self.b0 = b0

self.b1 = b1

# РИСУЕМПУЗЫРЬ

def draw(self):

if self.live:

self.b1.draw_scaled(self.xc, self.yc)

else:

self.b0.draw_scaled(self.xc, self.yc)

# проверяем, находится ли заданная точка

# на пузыре:

def over(self, px, py):

x = self.xc - OFFSET_X

y = self.yc - OFFSET_Y

return (x <= px <= x + self.w) and (y <= py <= y + self.h)

# КЛАССИГРЫ

class Game(arcade.Window):

# КОНСТРУКТОР:

def __init__(self, width, height, title):

super().__init__(width, height, title, center_window=True)

# стартовое время:

self.start_time = 0.0

# текущеевремя:

self.current_time = 0.0

# рекордноевремя:

self.record_time = 1000_000.0

self.isRecord = False

self.setup()

# ПОДГОТОВКА

def setup(self):

# цветфонаокна:

#arcade.set_background_color(BACKGROUND_COLOR)

# загружаемфоновуюкартинку:

self.back = arcade.load_texture("images/back.png")

# загружаемкартинкиспузырями:

b0 = arcade.load_texture("images/b0.png")

b1 = arcade.load_texture("images/b1.png")

# загружвемзвук:

self.buljk = arcade.load_sound("sounds/buljk.wav")

# массивигровогополя:

self.bubble = [[Bubble(b0, b1) for row in range(FIELD_HEIGHT)] for col in range(FIELD_WIDTH)]

# создаём игровое поле:

self.createField()

# элементы управления:

self.uimanager = arcade.gui.UIManager()

self.uimanager.enable()

self.box = arcade.gui.UIBoxLayout()

# кнопка:

self.button = arcade.gui.UITextureButton(texture=arcade.load_texture('images/button_a.png'),

texture_hovered=arcade.load_texture('images/button_b.png'),

texture_pressed=arcade.load_texture('images/button_c.png'))

# функция, которая вызывается при нажатии на кнопку:

self.button.on_click = self.on_buttonclick

self.uimanager.add(arcade.gui.UIAnchorWidget(align_x=-90, child=self.box))

# начинаем игру:

self.newGame()

# НАЧИНАЕМ НОВУЮ ИГРУ

def newGame(self, b=False):

self.lopnuli = 0

self.isGameOver = False

self.isRecord = False

for row in range(FIELD_HEIGHT):

for col in range(FIELD_WIDTH):

self.bubble[col][row].live = True

if b:

self.box.remove(self.button)

# СОЗДАЁМИГРОВОЕПОЛЕ

def createField(self):

for row in range(FIELD_HEIGHT):

for col in range(FIELD_WIDTH):

x = col * B_WIDTH + OFFSET_X

y = row * B_HEIGHT + B_HEIGHT + OFFSET_Y

self.bubble[col][row].xc = x

self.bubble[col][row].yc = y

# РИСУЕМПУЗЫРИ

def drawBubbles(self):

for row in range(FIELD_HEIGHT):

for col in range(FIELD_WIDTH):

b = self.bubble[col][row]

b.draw()

# ОБНОВЛЯЕМСЦЕНУ

def on_draw(self):

self.clear()

xc = WINDOW_WIDTH / 2

yc = WINDOW_HEIGHT / 2

self.back.draw_scaled(xc, yc)

self.drawBubbles()

self.drawInfo()

if self.isGameOver:

self.uimanager.draw()

# ОБНОВЛЯЕМИНФОРМАЦИЮ

def drawInfo(self):

# толщина линий:

h = 38

# красная полоса -->

# начало линии:

x_start = 5

# длина линии:

len = WINDOW_WIDTH-x_start*2

# конецлинии:

x_end = len + x_start

# отступ линии от нижнего края:

y = 23

arcade.draw_line(x_start, y, x_end, y,

arcade.color.RED, h)

# зелёнаяполоса -->

len *= self.lopnuli / (FIELD_WIDTH * FIELD_HEIGHT)

x_end = len + x_start

arcade.draw_line(x_start, y, x_end, y,

arcade.color.DARK_GREEN, h)

if not self.isRecord:

# печатаемсообщение:

message = f"Лопнули: {self.lopnuli}"

arcade.draw_text(message, WINDOW_WIDTH/2, 14,

arcade.color.YELLOW,

anchor_x="center",

font_size=20, bold=True)

else:

message = f"НОВЫЙРЕКОРД: {self.record_time}!"

arcade.draw_text(message, WINDOW_WIDTH/2, 14,

arcade.color.YELLOW,

anchor_x="center",

font_size=20, bold=True)

# печатаемтекущеевремя:

if (self.lopnuli > 0):

color = arcade.color.DARK_GREEN

if not self.isGameOver:

self.current_time = round(time.perf_counter() - self.start_time, 2)

message = f"{self.current_time}"

if self.current_time > self.record_time:

color = arcade.color.RED

arcade.draw_text(message, WINDOW_WIDTH - 120, WINDOW_HEIGHT - 160,

color,

font_size=20, bold=True)

# печатаем рекордное время:

if self.record_time < 1000_000.0:

message = f"{self.record_time}"

arcade.draw_text(message, WINDOW_WIDTH - 120, WINDOW_HEIGHT - 310,

color = arcade.color.BROWN,

font_size=20, bold=True)

# НАЖИМАЕМКНОПКУМЫШКИ

def on_mouse_press(self, x, y, button, modifiers):

# игра уже закончена:

if self.isGameOver:

return

# ищемнажатыйпузырь:

for row in range(FIELD_HEIGHT):

for col in range(FIELD_WIDTH):

# нашлиионживой:

if self.bubble[col][row].over(x, y) and \

self.bubble[col][row].live:

# звук:

arcade.play_sound(self.buljk)

# лопаемпузырь:

self.lopnuli += 1

self.bubble[col][row].live = False

# начинаем отсчёт времени:

if (self.lopnuli == 1):

self.start_time = time.perf_counter()

# проверяем, не закончилась ли игра:

self.testGameOver()

return

# НАЖИМАЕМКНОПКУ

def on_buttonclick(self, event):

#print("Button is clicked")

self.newGame(True)

# ПРОВЕРЯЕМ, НЕ ЗАКОНЧИЛАСЬ ЛИ ИГРА

def testGameOver(self):

# всепузырилопнули:

if (self.lopnuli == FIELD_HEIGHT * FIELD_WIDTH):

#if (self.lopnuli == 2): #FIELD_HEIGHT * FIELD_WIDTH):

self.current_time = round(time.perf_counter() - self.start_time, 2)

if self.current_time < self.record_time:

self.record_time = self.current_time

self.isRecord = True

# игразакончена:

self.isGameOver = True

self.box.add(self.button)

# ГЛАВНАЯ ФУНКЦИЯ

def main():

# создаём экземпляр игры:

game = Game(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE)

# запускаем программу:

arcade.run()

# закрываем программу:

arcade.close_window()

if __name__ == "__main__":

main()