Как создать игру на пайтон для начинающих

От начала до победы: как создать свою первую игру на Python с использованием библиотеки Pygame?

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

Шаг 1: Установка необходимых инструментов

Первым шагом в создании игры на Python является установка необходимых инструментов. Вам понадобится установить Python, библиотеку Pygame и интегрированную среду разработки (IDE), такую как PyCharm или Visual Studio Code. Убедитесь, что у вас установлена последняя версия Python и Pygame.

Шаг 2: Создание окна игры

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

import pygame pygame.init() screen = pygame.display.set_mode((800, 600))

В этом примере мы импортируем библиотеку Pygame, инициализируем ее и создаем экран размером 800 на 600 пикселей.

Шаг 3: Добавление спрайтов

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

class Player(pygame.sprite.Sprite): def __init__(self): super().__init__() self.image = pygame.Surface((50, 50)) self.image.fill((255, 255, 255)) self.rect = self.image.get_rect() self.rect.x = 50 self.rect.y = 50

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

Шаг 4: Обработка событий

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

running = True while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False keys = pygame.key.get_pressed() if keys[pygame.K_LEFT]: player.rect.x -= 5 if keys[pygame.K_RIGHT]: player.rect.x += 5 if keys[pygame.K_UP]: player.rect.x += 5 if keys[pygame.K_DOWN]: player.rect.y += 5 screen.fill((0, 0, 0)) all_sprites.draw(screen) pygame.display.flip() pygame.quit()

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

Шаг 5: Добавление коллизий

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

class Enemy(pygame.sprite.Sprite): def init(self): super().init() self.image = pygame.Surface((50, 50)) self.image.fill((255, 0, 0)) self.rect = self.image.get_rect() self.rect.x = 500 self.rect.y = 500 player = Player() enemy = Enemy() all_sprites = pygame.sprite.Group() all_sprites.add(player) all_sprites.add(enemy) while running: for event in pygame.event.get(): if event.type == pygame.QUIT: running = False keys = pygame.key.get_pressed() if keys[pygame.K_LEFT]: player.rect.x -= 5 if keys[pygame.K_RIGHT]: player.rect.x += 5 if keys[pygame.K_UP]: player.rect.y -= 5 if keys[pygame.K_DOWN]: player.rect.y += 5 if pygame.sprite.collide_rect(player, enemy): print(«Collision!») screen.fill((0, 0, 0)) all_sprites.draw(screen) pygame.display.flip() pygame.quit()

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

Шаг 6: Добавление звука и музыки

Для того, чтобы игра звучала более реалистично, мы можем добавить звуковые эффекты и музыку. Для этого мы должны загрузить аудиофайлы и использовать методы play() или stop() для воспроизведения или остановки звуков.

pygame.mixer.init() pygame.mixer.music.load(«music.mp3») pygame.mixer.music.play() sound_effect = pygame.mixer.Sound(«sound_effect.wav») sound_effect.play

В этом примере мы инициализируем модуль pygame.mixer для работы с звуком и загружаем музыкальный файл и звуковой эффект. Мы используем метод play() для воспроизведения музыки и звукового эффекта.

Шаг 7: Добавление меню и интерфейса

Чтобы игрок мог начать игру и управлять ею, нам нужно создать меню и интерфейс пользователя (UI). Для этого мы можем использовать модуль pygame_gui, который предоставляет инструменты для создания пользовательского интерфейса.

import pygame_gui pygame.init() # Создание окна screen_width = 800 screen_height = 600 screen = pygame.display.set_mode((screen_width, screen_height)) # Создание менеджера GUI ui_manager = pygame_gui.UIManager((screen_width, screen_height)) # Создание кнопки «Play» play_button = pygame_gui.elements.UIButton( relative_rect=pygame.Rect((350, 275), (100, 50)), text=’Play’, manager=ui_manager) # Основной цикл игры running = True clock = pygame.time.Clock() while running: time_delta = clock.tick(60) / 1000.0 for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Обработка событий GUI if event.type == pygame.USEREVENT: if event.user_type == pygame_gui.UI_BUTTON_PRESSED: if event.ui_element == play_button: print(«Play button pressed!») # Обработка событий pygame ui_manager.process_events(event) ui_manager.update(time_delta) # Отрисовка GUI ui_manager.draw_ui(screen) pygame.display.update() pygame.quit()

В этом примере мы создаем окно и менеджер GUI, а затем создаем кнопку «Play». Мы также создаем цикл обработки событий, который обрабатывает события GUI и pygame. Мы обновляем менеджер GUI и отрисовываем интерфейс пользователя.

Шаг 8: Добавление сохранения и загрузки

Чтобы игрок мог сохранять свой прогресс в игре и продолжать играть позже, мы можем добавить функции сохранения и загрузки. Для этого мы можем использовать модуль pickle, который позволяет сохранять и загружать объекты Python в файлы.

import pickle class Game: def __init__(self): self.score = 0 self.level = 1 def save(self, filename): with open(filename, «wb») as f: pickle.dump(self, f) @staticmethod def load(filename): with open(filename, «rb») as f: return pickle.load(f) game = Game() game.save(«savegame.pickle») loaded_game = Game.load(«savegame.pickle») print(loaded_game.score) print(loaded_game.level)

В этом примере мы создаем класс Game, который содержит данные о текущем состоянии игры. Мы также добавляем методы save() и load(), которые сохраняют и загружают объект Game в файл с помощью модуля pickle. Мы создаем объект Game, сохраняем его в файл и затем загружаем его из файла и выводим его свойства score и level.

Чтобы добавить сохранение и загрузку в нашу игру, мы можем сохранять объект Game после каждого уровня или после завершения игры. Мы можем также загружать сохраненную игру при запуске игры.

Шаг 9: Добавление искусственного интеллекта

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

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

class Enemy: def __init__(self, x, y): self.x = x self.y = y self.speed = 5 def move_towards_player(self, player_x, player_y): if self.x < player_x: self.x += self.speed elif self.x >player_x: self.x -= self.speed if self.y < player_y: self.y += self.speed elif self.y >player_y: self.y -= self.speed enemy = Enemy(100, 100) # Основной цикл игры running = True clock = pygame.time.Clock() while running: time_delta = clock.tick(60) / 1000.0 for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Искусственный интеллект enemy.move_towards_player(player_x, player_y) # Отрисовка игровых объектов screen.fill((255, 255, 255)) pygame.draw.circle(screen, (255, 0, 0), (enemy.x, enemy.y), 10) pygame.draw.circle(screen, (0, 0, 255), (player_x, player_y), 10) pygame.display.update() pygame.quit()

В этом примере мы создаем класс Enemy, который содержит координаты и скорость противника. Мы также добавляем метод move_towards_player(), который управляет движением противника к игроку.

Мы создаем объект Enemy и добавляем искусственный интеллект в наш основной цикл игры. Мы также отрисовываем игровые объекты и обновляем экран.

Шаг 10: Тестирование и отладка

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

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

import pdb # Основной цикл игры running = True clock = pygame.time.Clock() while running: time_delta = clock.tick(60) / 1000.0 for event in pygame.event.get(): if event.type == pygame.QUIT: running = False # Искусственный интеллект enemy.move_towards_player(player_x, player_y) # Отрисовка игровых объектов screen.fill((255, 255, 255)) pygame.draw.circle(screen, (255, 0, 0), (enemy.x, enemy.y), 10) pygame.draw.circle(screen, (0, 0, 255), (player_x, player_y), 10) pygame.display.update() # Отладка pdb.set_trace() print(«Player x: «, player_x) print(«Player y: «, player_y) print(«Enemy x: «, enemy.x) print(«Enemy y: «, enemy.y) pygame.quit()

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

Шаг 11: Оптимизация и улучшение производительности

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

Некоторые способы оптимизации:

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

Шаг 12: Публикация игры

После того, как игра полностью готова и протестирована, мы можем опубликовать ее на различных платформах, таких как Steam, App Store или Google Play.

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

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

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

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

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

Создание игры на Python

Игра на Pygame с нуля / Урок #1 – Разработка игр на Python для начинающих

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

Видеоурок

Полезные ссылки:

Видео на тему работы компьютера ;
Курс по языку Python ;
Официальный сайт Python ;
Программа PyCharm ;
Установка PyGame .

Информация про Pygame

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

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

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

Как делают игры?

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

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

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

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

Это и есть базовое описании процесса отображения игр компьютером.

На что способен Pygame?

Pygame позволяет строить игры разного жанра с разным набором функций. Главное что делает библиотека – позволяет вам отобразить изображение на экране вашего ПК. Отобразив какое-либо изображение вы можете начать двигать его по координатам и вот вы уже получите эффект движения в игре. Или же вы можете начать динамично менять изображения друг за другом и вы получите эффект анимации.

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

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

Примеры игр

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

Такие проекты не могут похвастаться графикой и функциями как в играх класса ААА, но несмотря на это они могут быть интересны с точки зрения своего функционала и действий в игре. Одной из таковых игр является Historical Wargame Simulator. Это игра в жанре стратегии, где у вас набор из множества функций и действий. Смотря на эту игру даже сложно осознать что она создана только за счет языка Python.

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

Приведем пример нескольких:

игра TRUNKMAN с реально крутой графикой и интересной задумкой;
игра Necrostation выполненная в духе классических олд скульных игр с кучей анимацией;
игра Gleamshroom, где вам предстоит играть за гриб. В игре нужно преодолевать разные препятствия и в конце добраться до конечной точки;
игра Planyt – классический платформер со множеством анимаций, красивым дизайном и интересной задумкой;
игра Explon’t, которая смахивает на жанр платформера. В ней также много графики, красивый дизайн, интересный функционал и насыщенная картинка.

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

План курса

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

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

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

Дополнительные курсы

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

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

Задание к уроку

Библиотека PyGame

На что способна библиотека PyGame? Какие функции она предоставляет и что вы можете получить при её использовании?

Посмотреть ответ

Библиотека PyGame дает возможность вам создавать игры как под ПК, так и под Андроид.

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

Большое задание по курсу

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

Можно Ли Делать Игры На Python?

Python нашёл себе место почти во всех сферах IT. Разработка веб-сайтов, управление станками ЧПУ, desktop, мобильные приложения, а уж про искусственный интеллект, машинное обучение и анализ данных я вообще молчу. Сейчас Python лучший друг хоть школьнику, хоть сотруднику научно-исследовательской лаборатории. А что на счёт игр? Компьютерные игры — это огромная доля IT рынка, которая уже набрала и продолжает набирать обороты. Игры то делать можно на питоне? Сегодня мы расставим все точки над i. Меня зовут Макс, я один из авторов YouTube канала PyLounge, а вы читаете статью в которой я расскажу можно ли создавать игры на Python и какую нишу занял Python в сфере gamedev.

Для удобства разделим все игры на несколько категорий:

AAA-проекты по типу Assassin’s Creed и Call of Duty, которые разрабатывают е крупные студии;
любительские инди-игры;
мобильные игры.

В таком порядке и будем разбираться.

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

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

Крупные компании зачастую используют Unity, Unreal Engine 4, CryEngine, Source или пишут собственные движки (Anvil, Fox, REDengine) обычно на С++. Хотя и существуют специальные игровые движки, написанные на Python, но о них чуть дальше.

Перемещение по меню, переходы между локациями, управление персонажем, движение камеры, смена музыки, диалоги, система квестов, ИИ — всё это и многое другое приходится программировать на каком-то языке, который поддерживает тот или иной движок.

Unreal Engine 4 используют С++, Blueprint и некоторое подобие JavaScript, основой для Unity является C# (была попытка ввести язык Boo, это по сути типизованный Python, но идея провалилась). Из более менее крупных, ходовых движков Python как основу использует пожалуй только Godot (точнее он использует GDScript, по сути видоизменённый Python с небольшими фишками).

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

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

В первую очередь скриптовый язык Python позволяет отделить игровую логику, от всего остального (графики, физики, ввода/вывода, сетевого взаимодействия). Скрипты на Python могут применяться для написания взаимодействия персонажей, запуска сцен, диалогов, взаимодействие NPC с триггерами (например, ходьба где-то, остановка, чтобы поговорить с другим NPC, а затем продолжить бежать куда-то), статистика противника (здоровье, скорость, точность), а также обработки различных событий.

Игровая логика обычно не содержит сложных вычислений и скорость языка отходит на второй план. Это и ляжет на плечи Python. Действительно сложные или требующие высокой производительности части (какой-нибудь условный поиск пути) можно унести в движок.

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

Скрипты Python можно использовать, даже если игра написана на другом языке. Python использовался в Battlefiled, Sims, Civilization, World of Tanks, Vampire: The Masquerade: Bloodlines и ещё много где.

Кроме того, Python часто используют для написания тестов, что тоже важно. Получается, что Python не такой уж редкий гость в крупном геймдеве, однако используется он далеко не как основной язык и конкуренцию ему составляет(-ли,-вят) Lua\JS\TypeScript (возможно) и т.д. С крупными многобюджетными играми на этом всё.

Когда же речь идёт о чём-то более простом, о создании не навороченных 2D и 3D игр Python выступает во всей красе. Для создания хобби-проектов, инди и мобильные игр под Android Питон предоставляет несколько хороших и относительно популярных инструментов.

Pygame – это библиотека модулей для языка Python, созданная для разработки 2D игр. Также Pygame можно называть своего рода фреймворком для создания игр. Он имеет хорошее сообщество, открытый исходный код, кроссплатформенность, качественную документацию, множеством примеров игр, а ещё он довольно простотой для изучения.

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

Panda3D — игровой движок, включающий графику, звук, ввод-вывод, обнаружение столкновений и другие функции, относящиеся к созданию 3D игр. Основным языком программирования, предназначенном для работы с SDK Panda3D, является Python, однако ядро движка написано на C++. Panda3D использовался даже для крупных коммерческих игр (Toontown Online, Pirates of the Caribbean Online). Он также включает работу с графикой, звуком, сетью, устройствами ввода (мышь, клавиатура, джойстик и т.п.), физикой на базе ODE и многими другими вещами, требующимися при разработке игры. Основным графическим API для «панды» является OpenGL, так же возможно использование и DirectX. Движок достаточно простой в изучении и при должной сноровке, с помощью него вполне реально сделать что-то простое, но интересное.

Отдельно стоит отметить движок RenPy . Это именно то, на что действительно стоит обратить своё внимание.

RenPy — это бесплатный, написанный на Python, свободный игровой движок для создания визуальных новелл (графических квестов с диалоговой системой) в 2D-графике. Поддерживает платформы Windows, Linux, Android, iOS. Именно на этом движке созданы такие известные игры как Бесконечное Лето и Корона из Листьев.

Everlasting Summer

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

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

По данным из Wiki cвыше 1200 игр используют движок RenPy. И это действительно тот инструмент, который поможет вам реально и без особых проблем воплотить ваши игровые идеи в жизнь, пусть и в формате визуальной новеллы. Достаточно только наличие базовых знаний Python, идеи и хорошего художника. Дерзайте, возможно именно ваша игра покорит интернет, как это было в случае БЛ.

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

P.S. Также есть видеоверсия данной статьи на YouTube.

Пишем игру на Python

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

Логика игры

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

Алгоритм

Чтобы реализовать такую логику игры, нужно предусмотреть такие сценарии поведения:

игра начинается;
шарик начинает двигаться;
если нажаты стрелки влево или вправо — двигаем платформу;
если шарик коснулся стенок, потолка или платформы — делаем отскок;
если шарик коснулся платформы — увеличиваем счёт на единицу;
если шарик упал на пол — выводим сообщение и заканчиваем игру.

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

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

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

По коням, пишем на Python

Для этого проекта вам потребуется установить и запустить среду Python. Как это сделать — читайте в нашей статье.

Начало программы

Чтобы у нас появилась графика в игре, используем библиотеку Tkinter. Она входит в набор стандартных библиотек Python и позволяет рисовать простейшие объекты — линии, прямоугольники, круги и красить их в разные цвета. Такой простой Paint, только для Python.

Чтобы создать окно, где будет видна графика, используют класс Tk(). Он просто делает окно, но без содержимого. Чтобы появилось содержимое, создают холст — видимую часть окна. Именно на нём мы будем рисовать нашу игру. За холст отвечает класс Canvas(), поэтому нам нужно будет создать свой объект из этого класса и дальше уже работать с этим объектом.

Если мы принудительно не ограничим скорость платформы, то она будет перемещаться мгновенно, ведь компьютер считает очень быстро и моментально передвинет её к другому краю. Поэтому мы будем искусственно ограничивать время движения, а для этого нам понадобится модуль Time — он тоже стандартный.

Последнее, что нам глобально нужно, — задавать случайным образом начальное положение шарика и платформы, чтобы было интереснее играть. За это отвечает модуль Random — он помогает генерировать случайные числа и перемешивать данные.

Запишем всё это в виде кода на Python:

# подключаем графическую библиотеку from tkinter import * # подключаем модули, которые отвечают за время и случайные числа import time import random # создаём новый объект — окно с игровым полем. В нашем случае переменная окна называется tk, и мы его сделали из класса Tk() — он есть в графической библиотеке tk = Tk() # делаем заголовок окна — Games с помощью свойства объекта title tk.title('Game') # запрещаем менять размеры окна, для этого используем свойство resizable tk.resizable(0, 0) # помещаем наше игровое окно выше остальных окон на компьютере, чтобы другие окна не могли его заслонить tk.wm_attributes('-topmost', 1) # создаём новый холст — 400 на 500 пикселей, где и будем рисовать игру canvas = Canvas(tk, width=500, height=400, highlightthickness=0) # говорим холсту, что у каждого видимого элемента будут свои отдельные координаты canvas.pack() # обновляем окно с холстом tk.update()

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

Любишь Python? Зарабатывай на нём!

Шарик

Сначала проговорим словами, что нам нужно от шарика. Он должен уметь:

задавать своё начальное положение и направление движение;
понимать, когда он коснулся платформы;
рисовать сам себя и понимать, когда нужно отрисовать себя в новом положении (например, после отскока от стены).

Этого достаточно, чтобы шарик жил своей жизнью и умел взаимодействовать с окружающей средой. При этом нужно не забыть о том, что каждый класс должен содержать конструктор — код, который отвечает за создание нового объекта. Без этого сделать шарик не получится. Запишем это на Python:

# Описываем класс Ball, который будет отвечать за шарик class Ball: # конструктор — он вызывается в момент создания нового объекта на основе этого класса def __init__(self, canvas, paddle, score, color): # задаём параметры объекта, которые нам передают в скобках в момент создания self.canvas = canvas self.paddle = paddle self.score = score # цвет нужен был для того, чтобы мы им закрасили весь шарик # здесь появляется новое свойство id, в котором хранится внутреннее название шарика # а ещё командой create_oval мы создаём круг радиусом 15 пикселей и закрашиваем нужным цветом self.id = canvas.create_oval(10,10, 25, 25, fill=color) # помещаем шарик в точку с координатами 245,100 self.canvas.move(self.id, 245, 100) # задаём список возможных направлений для старта starts = [-2, -1, 1, 2] # перемешиваем его random.shuffle(starts) # выбираем первый из перемешанного — это будет вектор движения шарика self.x = starts[0] # в самом начале он всегда падает вниз, поэтому уменьшаем значение по оси y self.y = -2 # шарик узнаёт свою высоту и ширину self.canvas_height = self.canvas.winfo_height() self.canvas_width = self.canvas.winfo_width() # свойство, которое отвечает за то, достиг шарик дна или нет. Пока не достиг, значение будет False self.hit_bottom = False # обрабатываем касание платформы, для этого получаем 4 координаты шарика в переменной pos (левая верхняя и правая нижняя точки) def hit_paddle(self, pos): # получаем кординаты платформы через объект paddle (платформа) paddle_pos = self.canvas.coords(self.paddle.id) # если координаты касания совпадают с координатами платформы if pos[2] >= paddle_pos[0] and pos[0] = paddle_pos[1] and pos[3] = self.canvas_height: # помечаем это в отдельной переменной self.hit_bottom = True # выводим сообщение и количество очков canvas.create_text(250, 120, text='Вы проиграли', font=('Courier', 30), fill='red') # если было касание платформы if self.hit_paddle(pos) == True: # отправляем шарик наверх self.y = -2 # если коснулись левой стенки if pos[0] = self.canvas_width: # движемся влево self.x = -2

Платформа

Сделаем то же самое для платформы — сначала опишем её поведение словами, а потом переведём в код. Итак, вот что должна уметь платформа:

двигаться влево или вправо в зависимости от нажатой стрелки;
понимать, когда игра началась и можно двигаться.

А вот как это будет в виде кода:

# Описываем класс Paddle, который отвечает за платформы class Paddle: # конструктор def __init__(self, canvas, color): # canvas означает, что платформа будет нарисована на нашем изначальном холсте self.canvas = canvas # создаём прямоугольную платформу 10 на 100 пикселей, закрашиваем выбранным цветом и получаем её внутреннее имя self.id = canvas.create_rectangle(0, 0, 100, 10, fill=color) # задаём список возможных стартовых положений платформы start_1 = [40, 60, 90, 120, 150, 180, 200] # перемешиваем их random.shuffle(start_1) # выбираем первое из перемешанных self.starting_point_x = start_1[0] # перемещаем платформу в стартовое положение self.canvas.move(self.id, self.starting_point_x, 300) # пока платформа никуда не движется, поэтому изменений по оси х нет self.x = 0 # платформа узнаёт свою ширину self.canvas_width = self.canvas.winfo_width() # задаём обработчик нажатий # если нажата стрелка вправо — выполняется метод turn_right() self.canvas.bind_all('', self.turn_right) # если стрелка влево — turn_left() self.canvas.bind_all('', self.turn_left) # пока игра не началась, поэтому ждём self.started = False # как только игрок нажмёт Enter — всё стартует self.canvas.bind_all('', self.start_game) # движемся вправо def turn_right(self, event): # будем смещаться правее на 2 пикселя по оси х self.x = 2 # движемся влево def turn_left(self, event): # будем смещаться левее на 2 пикселя по оси х self.x = -2 # игра начинается def start_game(self, event): # меняем значение переменной, которая отвечает за старт self.started = True # метод, который отвечает за движение платформы def draw(self): # сдвигаем нашу платформу на заданное количество пикселей self.canvas.move(self.id, self.x, 0) # получаем координаты холста pos = self.canvas.coords(self.id) # если мы упёрлись в левую границу if pos[0] = self.canvas_width: # останавливаемся self.x = 0

Счёт

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

От счёта нам нужно только одно (кроме конструктора) — чтобы он правильно реагировал на касание платформы, увеличивал число очков и выводил их на экран:

# Описываем класс Score, который отвечает за отображение счетов class Score: # конструктор def __init__(self, canvas, color): # в самом начале счёт равен нулю self.score = 0 # будем использовать наш холст self.canvas = canvas # создаём надпись, которая показывает текущий счёт, делаем его нужно цвета и запоминаем внутреннее имя этой надписи self.id = canvas.create_text(450, 10, text=self.score, font=('Courier', 15), fill=color) # обрабатываем касание платформы def hit(self): # увеличиваем счёт на единицу self.score += 1 # пишем новое значение счёта self.canvas.itemconfig(self.id, text=self.score)

Игра

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

Смысл игры в том, чтобы не уронить шарик. Пока этого не произошло — всё движется, но как только шарик упал — нужно показать сообщение о конце игры и остановить программу.

Посмотрите, как лаконично выглядит код непосредственно самой игры:

# создаём объект — зелёный счёт score = Score(canvas, 'green') # создаём объект — белую платформу paddle = Paddle(canvas, 'White') # создаём объект — красный шарик ball = Ball(canvas, paddle, score, 'red') # пока шарик не коснулся дна while not ball.hit_bottom: # если игра началась и платформа может двигаться if paddle.started == True: # двигаем шарик ball.draw() # двигаем платформу paddle.draw() # обновляем наше игровое поле, чтобы всё, что нужно, закончило рисоваться tk.update_idletasks() # обновляем игровое поле, и смотрим за тем, чтобы всё, что должно было быть сделано — было сделано tk.update() # замираем на одну сотую секунды, чтобы движение элементов выглядело плавно time.sleep(0.01) # если программа дошла досюда, значит, шарик коснулся дна. Ждём 3 секунды, пока игрок прочитает финальную надпись, и завершаем игру time.sleep(3)

ПОЛНЫЙ КОД ПРОГРАММЫ

# подключаем графическую библиотеку from tkinter import * # подключаем модули, которые отвечают за время и случайные числа import time import random # создаём новый объект — окно с игровым полем. В нашем случае переменная окна называется tk, и мы его сделали из класса Tk() — он есть в графической библиотеке tk = Tk() # делаем заголовок окна — Games с помощью свойства объекта title tk.title('Game') # запрещаем менять размеры окна, для этого используем свойство resizable tk.resizable(0, 0) # помещаем наше игровое окно выше остальных окон на компьютере, чтобы другие окна не могли его заслонить. Попробуйте :) tk.wm_attributes('-topmost', 1) # создаём новый холст — 400 на 500 пикселей, где и будем рисовать игру canvas = Canvas(tk, width=500, height=400, highlightthickness=0) # говорим холсту, что у каждого видимого элемента будут свои отдельные координаты canvas.pack() # обновляем окно с холстом tk.update() # Описываем класс Ball, который будет отвечать за шарик class Ball: # конструктор — он вызывается в момент создания нового объекта на основе этого класса def __init__(self, canvas, paddle, score, color): # задаём параметры объекта, которые нам передают в скобках в момент создания self.canvas = canvas self.paddle = paddle self.score = score # цвет нужен был для того, чтобы мы им закрасили весь шарик # здесь появляется новое свойство id, в котором хранится внутреннее название шарика # а ещё командой create_oval мы создаём круг радиусом 15 пикселей и закрашиваем нужным цветом self.id = canvas.create_oval(10,10, 25, 25, fill=color) # помещаем шарик в точку с координатами 245,100 self.canvas.move(self.id, 245, 100) # задаём список возможных направлений для старта starts = [-2, -1, 1, 2] # перемешиваем его random.shuffle(starts) # выбираем первый из перемешанного — это будет вектор движения шарика self.x = starts[0] # в самом начале он всегда падает вниз, поэтому уменьшаем значение по оси y self.y = -2 # шарик узнаёт свою высоту и ширину self.canvas_height = self.canvas.winfo_height() self.canvas_width = self.canvas.winfo_width() # свойство, которое отвечает за то, достиг шарик дна или нет. Пока не достиг, значение будет False self.hit_bottom = False # обрабатываем касание платформы, для этого получаем 4 координаты шарика в переменной pos (левая верхняя и правая нижняя точки) def hit_paddle(self, pos): # получаем кординаты платформы через объект paddle (платформа) paddle_pos = self.canvas.coords(self.paddle.id) # если координаты касания совпадают с координатами платформы if pos[2] >= paddle_pos[0] and pos[0] = paddle_pos[1] and pos[3] = self.canvas_height: # помечаем это в отдельной переменной self.hit_bottom = True # выводим сообщение и количество очков canvas.create_text(250, 120, text='Вы проиграли', font=('Courier', 30), fill='red') # если было касание платформы if self.hit_paddle(pos) == True: # отправляем шарик наверх self.y = -2 # если коснулись левой стенки if pos[0] = self.canvas_width: # движемся влево self.x = -2 # Описываем класс Paddle, который отвечает за платформы class Paddle: # конструктор def __init__(self, canvas, color): # canvas означает, что платформа будет нарисована на нашем изначальном холсте self.canvas = canvas # создаём прямоугольную платформу 10 на 100 пикселей, закрашиваем выбранным цветом и получаем её внутреннее имя self.id = canvas.create_rectangle(0, 0, 100, 10, fill=color) # задаём список возможных стартовых положений платформы start_1 = [40, 60, 90, 120, 150, 180, 200] # перемешиваем их random.shuffle(start_1) # выбираем первое из перемешанных self.starting_point_x = start_1[0] # перемещаем платформу в стартовое положение self.canvas.move(self.id, self.starting_point_x, 300) # пока платформа никуда не движется, поэтому изменений по оси х нет self.x = 0 # платформа узнаёт свою ширину self.canvas_width = self.canvas.winfo_width() # задаём обработчик нажатий # если нажата стрелка вправо — выполняется метод turn_right() self.canvas.bind_all('', self.turn_right) # если стрелка влево — turn_left() self.canvas.bind_all('', self.turn_left) # пока платформа не двигается, поэтому ждём self.started = False # как только игрок нажмёт Enter — всё стартует self.canvas.bind_all('', self.start_game) # движемся вправо def turn_right(self, event): # будем смещаться правее на 2 пикселя по оси х self.x = 2 # движемся влево def turn_left(self, event): # будем смещаться левее на 2 пикселя по оси х self.x = -2 # игра начинается def start_game(self, event): # меняем значение переменной, которая отвечает за старт движения платформы self.started = True # метод, который отвечает за движение платформы def draw(self): # сдвигаем нашу платформу на заданное количество пикселей self.canvas.move(self.id, self.x, 0) # получаем координаты холста pos = self.canvas.coords(self.id) # если мы упёрлись в левую границу if pos[0] = self.canvas_width: # останавливаемся self.x = 0 # Описываем класс Score, который отвечает за отображение счетов class Score: # конструктор def __init__(self, canvas, color): # в самом начале счёт равен нулю self.score = 0 # будем использовать наш холст self.canvas = canvas # создаём надпись, которая показывает текущий счёт, делаем его нужно цвета и запоминаем внутреннее имя этой надписи self.id = canvas.create_text(450, 10, text=self.score, font=('Courier', 15), fill=color) # обрабатываем касание платформы def hit(self): # увеличиваем счёт на единицу self.score += 1 # пишем новое значение счёта self.canvas.itemconfig(self.id, text=self.score) # создаём объект — зелёный счёт score = Score(canvas, 'green') # создаём объект — белую платформу paddle = Paddle(canvas, 'White') # создаём объект — красный шарик ball = Ball(canvas, paddle, score, 'red') # пока шарик не коснулся дна while not ball.hit_bottom: # если игра началась и платформа может двигаться if paddle.started == True: # двигаем шарик ball.draw() # двигаем платформу paddle.draw() # обновляем наше игровое поле, чтобы всё, что нужно, закончило рисоваться tk.update_idletasks() # обновляем игровое поле и смотрим за тем, чтобы всё, что должно было быть сделано — было сделано tk.update() # замираем на одну сотую секунды, чтобы движение элементов выглядело плавно time.sleep(0.01) # если программа дошла досюда, значит, шарик коснулся дна. Ждём 3 секунды, пока игрок прочитает финальную надпись, и завершаем игру time.sleep(3)

Выводы

Это одна из самых простых игр, где уже можно ощутить всю мощь объектно-ориентированного программирования. Смотрите сами:

мы сделали класс «шарик», который уже при создании получает нужные размеры и цвет;
внутри этого класса мы прописываем логику поведения;
эта логика умеет взаимодействовать с другими сущностями в коде, используя значения их каких-то свойств, например, координат и размеров площадки;
для площадки мы также сделали новый класс со своей логикой — в ней уже есть всё, что нам нужно от площадки;
когда есть классы, то на их основе мы можем создавать любое количество объектов, которые будут уметь делать то же самое, что и основной класс;
благодаря ООП мы можем разделить внутренние значения с внешними параметрами, которые доступны извне.

А вот что ещё можно почитать по ООП: