Как создать простую игру на python
Перейти к содержимому

Как создать простую игру на python

  • автор:

Как создать простую игру на python

Для тренировки навыков работы на питоне, можно попробовать запустить простую RPG — собственную виртуальную реальность с героями и антуражем.

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

Как написать игру на питоне

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

Шаг 1: Создание классов для персонажей и предметов

Первым шагом является разработка классов для героев и вещей. Реализовывайте классы, которые будут представлять их в вашей игре.

```python class Character: def __init__(self, name, health, damage): self.name = name self.health = health self.damage = damage class Item: def __init__(self, name, description): self.name = name self.description = description ``` 

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

Шаг 2: Создание игрового мира

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

```python class World: def __init__(self, characters, items): self.characters = characters self.items = items ``` 

Шаг 3: Разработка игрового цикла

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

```python def game_loop(world): player = Character("Player", 100, 10) print("Welcome to the game!") while True: # Вывод информации о мире print("Characters:") for character in world.characters: print(f"- ( HP)") print("Items:") for item in world.items: print(f"- : ") # Ввод команды игрока command = input("What do you want to do? ") # Обработка команды игрока if command == "quit": print("Goodbye!") break elif command == "attack": enemy = world.characters[0] enemy.health -= player.damage print(f"You attacked for damage.") if enemy.health <= 0: print(f"died!") world.characters.remove(enemy) else: print("Unknown command.") ``` 

Шаг 4: Создание виртуальной вселенной

Напишите код экземпляра класса World и добавьте в него персонажей и другие позиции.

```python world = World([ Character("Goblin", 50, 5), Character("Troll", 100, 15) ], [ Item("Sword", "A sharp sword."), Item(" Picking", "A healing potion.") ]) 

Шаг 5: Запуск игры

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

```python game_loop(world) ``` 

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

Что еще добавить

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

- Добавление большего количества персонажей и предметов в мир.

- Написание более сложных команд и систем для боевых действий.

- Разработка системы опыта и уровней для персонажей.

- Добавление исследования мира и заданий для игрока.

- Реализация системы сохранения и загрузки.

Удачи с созданием вашей собственной игры на Python!

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

Библиотека Pygame / Часть 1. Введение

Это первая часть серии руководств «Разработка игр с помощью Pygame». Она предназначена для программистов начального и среднего уровней, которые заинтересованы в создании игр и улучшении собственных навыков кодирования на Python.

Код в уроках был написан на Python 3.7 и Pygame 1.9.6

Что такое Pygame?

Pygame — это «игровая библиотека», набор инструментов, помогающих программистам создавать игры. К ним относятся:

  • Графика и анимация
  • Звук (включая музыку)
  • Управление (мышь, клавиатура, геймпад и так далее)

Игровой цикл

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

В каждом кадре происходит масса вещей, но их можно разбить на три категории:

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

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

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

Время

Еще один важный аспект игрового цикла — скорость его работы. Многие наверняка знакомы с термином FPS, который расшифровывается как Frames Per Second (или кадры в секунду). Он указывает на то, сколько раз цикл должен повториться за одну секунду. Это важно, чтобы игра не была слишком медленной или быстрой. Важно и то, чтобы игра не работала с разной скоростью на разных ПК. Если персонажу необходимо 10 секунд на то, чтобы пересечь экран, эти 10 секунд должны быть неизменными для всех компьютеров.

Создание шаблона Pygame

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

В начале программы нужно импортировать необходимые библиотеки и задать базовые переменные настроек игры:

# Pygame шаблон - скелет для нового проекта Pygame import pygame import random WIDTH = 360 # ширина игрового окна HEIGHT = 480 # высота игрового окна FPS = 30 # частота кадров в секунду 

Дальше необходимо открыть окно игры:

# создаем игру и окно pygame.init() pygame.mixer.init() # для звука screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("My Game") clock = pygame.time.Clock() 

pygame.init() — это команда, которая запускает pygame. screen — окно программы, которое создается, когда мы задаем его размер в настройках. Дальше необходимо создать clock , чтобы убедиться, что игра работает с заданной частотой кадров.

Теперь необходимо создать игровой цикл:

# Цикл игры running = True while running: # Ввод процесса (события) # Обновление # Визуализация (сборка) 

Игровой цикл — это цикл while , контролируемый переменной running . Если нужно завершить игру, необходимо всего лишь поменять значение running на False . В результате цикл завершится. Теперь можно заполнить каждый раздел базовым кодом.

Раздел рендеринга (отрисовки)

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

Таблица цветов RGB

Экраны компьютеров сделаны из пикселей, каждый из которых содержит 3 элемента: красный, зеленый и синий. Цвет пикселя определяется тем, как горит каждый из элементов:

Каждый из трех основных цветов может иметь значение от 0 (выключен) до 255 (включен на 100%), так что для каждого элемента есть 256 вариантов.

Узнать общее количество отображаемых компьютером цветов можно, умножив:

>>> 256 * 256 * 256 16,777,216 

Теперь, зная, как работают цвета, можно задать их в начале программ:

# Цвета (R, G, B) BLACK = (0, 0, 0) WHITE = (255, 255, 255) RED = (255, 0, 0) GREEN = (0, 255, 0) BLUE = (0, 0, 255) 

А после этого — заполнить весь экран.

 # Рендеринг screen.fill(BLACK) 

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

Представьте, что у вас есть двусторонняя доска, которую можно поворачивать, показывая то одну, то вторую сторону. Одна будет дисплеем (то, что видит игрок), а вторая — оставаться скрытой, ее сможет «видеть» только компьютер. С каждым кадром рендеринг будет происходить на задней части доски. Когда отрисовка завершается, доска поворачивается и ее содержимое демонстрируется игроку.

А это значит, что процесс отрисовки происходит один раз за кадр, а не при добавлении каждого элемента.

В pygame это происходит автоматически. Нужно всего лишь сказать доске, чтобы она перевернулась, когда отрисовка завершена. Эта команда называется flip() :

 # Рендеринг screen.fill(BLACK) # после отрисовки всего, переворачиваем экран pygame.display.flip() 

Главное — сделать так, чтобы функция flip() была в конце. Если попытаться отрисовать что-то после поворота, это содержимое не отобразится на экране.

Раздел ввода (событий)

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

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

 for event in pygame.event.get(): # проверить закрытие окна if event.type == pygame.QUIT: running = False 

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

Контроль FPS

Пока что нечего поместить в раздел Update (обновление), но нужно убедиться, что настройка FPS контролирует скорость игры. Это можно сделать следующим образом:

while running: # держим цикл на правильной скорости clock.tick(FPS) 

Команда tick() просит pygame определить, сколько занимает цикл, а затем сделать паузу, чтобы цикл (целый кадр) длился нужно время. Если задать значение FPS 30, это значит, что длина одного кадра — 1/30, то есть 0,03 секунды. Если цикл кода (обновление, рендеринг и прочее) занимает 0,01 секунды, тогда pygame сделает паузу на 0,02 секунды.

Итог

Наконец, нужно убедиться, что когда игровой цикл завершается, окно игры закрывается. Для этого нужно поместить функцию pygame.quit() в конце кода. Финальный шаблон pygame будет выглядеть вот так:

# Pygame шаблон - скелет для нового проекта Pygame import pygame import random WIDTH = 360 HEIGHT = 480 FPS = 30 # Задаем цвета WHITE = (255, 255, 255) BLACK = (0, 0, 0) RED = (255, 0, 0) GREEN = (0, 255, 0) BLUE = (0, 0, 255) # Создаем игру и окно pygame.init() pygame.mixer.init() screen = pygame.display.set_mode((WIDTH, HEIGHT)) pygame.display.set_caption("My Game") clock = pygame.time.Clock() # Цикл игры running = True while running: # Держим цикл на правильной скорости clock.tick(FPS) # Ввод процесса (события) for event in pygame.event.get(): # check for closing window if event.type == pygame.QUIT: running = False # Обновление # Рендеринг screen.fill(BLACK) # После отрисовки всего, переворачиваем экран pygame.display.flip() pygame.quit() 

Ура! У вас есть рабочий шаблон Pygame. Сохраните его в файле с понятным названием, например, pygame_template.py , чтобы можно было использовать его каждый раз при создании нового проекта pygame.

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

Как создать простую игру «Змейка» на Python и Pygame

Как создать простую игру «Змейка» на Python и Pygame

Игра «Змейка» существует уже почти 50 лет. За это время программисты успели разработать множество модификаций для разных платформ. В этой статье подробно разбираем процесс создания игры на Python с помощью библиотеки Pygame.

Освойте профессию
«Python-разработчик»

История

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

Интерфейс игры Blockade-змейка в 1976

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

Python-разработчик
Освойте Python, самый популярный язык программирования
3 383 ₽/мес 6 150 ₽/мес

dffsdd (3)

Инструменты

Разрабатывать игру будем на Python с помощью открытого набора модулей Pygame, который построен на мультимедийной библиотеке Simple DirectMedia Layer (SDL). Pygame содержит в себе все необходимые модули для разработки игр на Python, включая работу с графикой, воспроизведение звука, управление с клавиатуры, взаимодействие с вибрацией и акселерометром. Готовые игры можно собирать под разные платформы, включая мобильный Android. Код Pygame открыт и опубликован на GitHub, поэтому более опытные разработчики могут присоединиться к развитию проекта. Из дополнительных инструментов понадобится редактор кода на Python. Чаще всего разработчики выбирают бесплатный редактор Visual Studio Code от Microsoft или полноценную среду разработки Pycharm от JetBrains. Visual Studio Code — полностью бесплатный редактор кода, доступный для Windows, macOS и Linux. Специальную версию VS Code можно запускать в браузере. Вначале компания позиционировала редактор в качестве инструмента для веб-разработки. После релиза магазина расширений появилась возможность адаптировать VS Code практически под любые современные технологии. Редактор поддерживает подсветку синтаксиса, запуск кода и отладку. Скачать установочный файл можно на официальном сайте проекта. PyCharm — полноценная среда разработки на языке Python. Включает в себя все необходимые инструменты для создания, отладки и тестирования приложений. Возможности среды можно расширять плагинами. Если с помощью VS Code можно писать код на нескольких языках, то в PyCharm есть полноценная поддержка только Python, а для других языков JetBrains выпускает отдельные среды. PyCharm доступна на Windows, macOS и Linux. Пользователи могут выбрать между бесплатным и ограниченным выпуском Community Edition или полноценным Professional с ежемесячной подпиской. Для проекта «Змейки» хватит бесплатной версии.

Установка библиотек

Установка Python 3

Сперва надо убедиться, что на компьютере установлен язык программирования Python 3. Для этого в терминале следует ввести команду python3 —version. В случае успеха система выведет номер установленной версии. Если в терминале появится ошибка или сообщение о том, что команда python3 не найдена, то Python надо будет установить. Для macOS и Linux это можно сделать с помощью одной команды в том же окне терминала.

macOS

На macOS установить Python можно из репозитория Homebrew. Сам Homebrew можно установить по инструкции с официального сайта. После этого в терминале следует ввести команду brew install python3 и дождаться завершения операции. В конце можно еще раз ввести python3 —version и убедиться, что установка прошла успешно.

Linux

В Linux установка Python производится с помощью команды sudo apt install python3. Этого хватит для автоматического скачивания актуальной версии.

Windows

В Windows язык программирования Python доступен в фирменном магазине приложений Microsoft Store. Для установки надо перейти по ссылке на страницу пакета и нажать кнопку «Получить», а затем — «Установить». Для корректной работы следует перезагрузить компьютер. Библиотека Pygame устанавливается из репозитория PyPI с помощью пакетного менеджера Pip. Он загружается вместе с Python, поэтому для установки Pygame достаточно выполнить в терминале команду pip install pygame. Если Python и Pygame уже установлены, то следует скачать редактор кода. Можно выбрать любой удобный из предложенных выше, перейти на его официальный сайт и пройти процесс установки.

Станьте разработчиком на Python и решайте самые разные задачи: от написания кода до автоматизации процессов

Дизайн

Цвета для дизайна «Змейки»

В больших студиях над играми работает множество отделов: сценаристы, режиссеры, дизайнеры, программисты, художники, тестировщики и другие высококвалифицированные специалисты. Мы разрабатываем проект в одиночку, поэтому задачи целой студии ложатся на наши плечи. Перед тем как начинать писать код, надо определиться с дизайном нашей «Змейки». Сейчас есть огромное количество вариантов этой классической игры, но мы повторим тот, который был популярен на заре зарождения жанра. Экраны тогда были монохромными, и разработчики не могли использовать обилие цветов. Мы тоже возьмем ограниченную палитру в зеленых оттенках, которая хорошо знакома по игровой консоли Game Boy от Nintendo. Всего в проекте будем использовать четыре цвета. Их коды в форматах RGB и Hex указаны на изображении.

Правила

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

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

Разработка

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

Шаг 1 — создаем новый проект и импортируем библиотеки

Для начал необходимо создать новый проект в редакторе кода. Будем рассматривать все на примере PyCharm, но все операции в таком же порядке можно проделать и в VS Code.

Для начала запускаем среду разработки и выбираем пункт меню File → New Project. В открывшемся меню указываем имя проекта и задаем директорию хранения файлов. В нашем случае проект называется snake, а все файлы хранятся в стандартной папке. Остальные пункты меню можно оставить по умолчанию.

Создание проекта игры в Python

В созданном проекте переходим к файлу main.py: если в проекте его нет, то создаем. В самом начале файла импортируем все необходимые для работы библиотеки:

  • Pygame — для доступа к основным модулям Pygame;
  • Randrange — для выбора случайного числа из заданного диапазона.
# Импортируем библиотеки import pygame as pg from random import randrange

Шаг 2 — задаем константы и инициализируем объекты

Некоторые переменные будут постоянными во всем проекте — константами. К ним будут относиться размер окна в пикселях и частота кадров (frame per second, FPS). Зададим их сразу после импорта библиотек. Важно отметить, что среди разработчиков Python константы принято писать заглавными буквами, а если в названии содержится больше одного слова, то отделять их следует символом нижнего подчеркивания. К примеру, некоторые названия констант могут выглядеть как HEIGHT или MAIN_COLOR .

В проекте «Змейки» на Python будут следующие константы:

  • WINDOW — размер окна, равный 1000 пикселей;
  • FPS — частота кадров, равная 60 кадрам в секунду.
# Константы WINDOW = 1000 FPS = 60

Теперь можно проинициализировать объекты игры. Сперва создадим объект экрана с помощью вызова функции set_mode модуля display . Функция set_mode принимает три аргумента: размер окна, флаги дополнительных параметров и глубину цвета. Последние два аргумента можно опустить и задать позже. В нашем случае создадим окно размером 1000×1000 пикселей. У нас уже есть константа размера окна, поэтому просто умножим ее на два: [WINDOW] * 2 . Также сразу же инициализируем объект, который поможет нам задать частоту обновления экрана.

# Инициализация объектов gameScreen = pg.display.set_mode([WINDOW] * 2) clock = pg.time.Clock()

Шаг 3 — создаем окно игры

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

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

# Главный цикл игры while True: # Частота обновления экрана clock.tick(FPS)

Теперь мы хотим получать события и обрабатывать их. Создадим для этого цикл for . В нем будем отслеживать действия пользователя и реагировать на них. Сразу же пропишем обнаружение закрытия окна с помощью условия if event.type == pg.QUIT — если объект Pygame закрывается, то мы закрываем игровое окно.

После этого воспользуемся функцией fill() и закрасим ранее созданный экран самым светлым цветом из палитры. Это позволит поверх разместить более темную змейку и объекты, которые она будет собирать. Цвет укажем в RGB-формате. В конце добавим функцию обновления экрана flip() .

# Цикл обработки событий for event in pg.event.get(): if event.type == pg.QUIT: exit() gameScreen.fill((155, 188, 15)) pg.display.flip()

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

Окно для игры «Змейка» на Python

Шаг 4 — создаем змейку

Наша змейка должна как-то передвигаться по игровому полю, для этого ей понадобятся координаты. В коде уже есть константа WINDOW S, обозначающая размер одной стороны окна; значит теперь мы сможем задать константу TILE_SIZE для размера стороны одной плитки сетки и после задать сразу всю сетку. Далее с помощью кортежа поместим в константу RANGE разметку всего поля. Так мы сможем задавать змейке координаты для передвижения и спауна объектов.

Координаты и размеры шага для игры «Змейка» на Python

TILE_SIZE = 50 RANGE = (TILE_SIZE // 2, WINDOW - TILE_SIZE // 2, TILE_SIZE)

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

Обозначим лямбда-функцию get_random_position() и с помощью константы RANGE получим координаты X и Y. Префиксная запись символа звездочки (*) перед RANGE означает, что мы хотим передать в функцию randrange() все элементы кортежа. Мы не знаем, сколько их там хранится, можем заранее посчитать и сохранить количество в отдельную переменную, а можем просто воспользоваться префиксной записью перед константой и доверить это дело Python.

# Функция для определения координат (X:Y) случайной позиции на игровом поле get_random_position = lambda: [randrange(*RANGE), randrange(*RANGE)]

Убедимся, что get_random_position() каждый раз дает нам случайные координаты. Вызовем функцию и посмотрим на вывод:

> [825, 175] > [925, 925] > [725, 825] > [25, 175] > [325, 625]

Теперь у нас есть все необходимое для того, чтобы задать параметры змейки и нарисовать ее на экране. Для начала создадим переменную snake, в которой определим голову змеи с помощью экземпляра класса Rect() , который в Pygame отвечает за обозначение прямоугольных областей. В качестве параметров в конструктор класса следует передать координаты X и Y, высоту и ширину. Сразу после зададим случайную позицию головы змеи на сетке игрового поля с помощью функции get_random_position() .

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

# Параметры змейки snake = pg.rect.Rect([0, 0, TILE_SIZE - 2, TILE_SIZE - 2]) snake.center = get_random_position() length = 1 segments = [snake.copy()]

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

[pg.draw.rect(gameScreen, (120, 149, 12), segment) for segment in segments]

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

Варианты появления змейки в случайном месте на игровом поле

Шаг 5 — управляем змейкой

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

  • W — движение вперед;
  • A — движение влево;
  • S — движение назад;
  • D — движение вправо.

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

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

# Обработка нажатий WASD if event.type == pg.KEYDOWN: if event.key == pg.K_w: snake_dir = (0, -TILE_SIZE) if event.key == pg.K_s: snake_dir = (0, TILE_SIZE) if event.key == pg.K_a: snake_dir = (-TILE_SIZE, 0) if event.key == pg.K_d: snake_dir = (TILE_SIZE, 0)

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

# Управляем змейкой snake.move_ip(snake_dir) segments.append(snake.copy()) segments = segments[-length:]

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

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

time = 0 time_step = 110

После этого модифицируем часть кода с управлением:

# Управляем змейкой time_now = pg.time.get_ticks() if time_now - time > time_step: time = time_now snake.move_ip(snake_dir) segments.append(snake.copy()) segments = segments[-length:]

Шаг 6 — добавляем еду для змейки

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

# Параметры объектов еды food = snake.copy() food.center = get_random_position()

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

# Рисуем объект еды pg.draw.rect(gameScreen, (15, 56, 15), food)

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

Варианты появления еды для змейки на игровом поле

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

# Поедание if snake.center == food.center: food.center = get_random_position() length += 1

Шаг 7 — определяем столкновения

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

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

# Столкновение с границами if snake.left < 0 or snake.right >WINDOW or snake.top < 0 or snake.bottom >WINDOW: snake.center, food.center = get_random_position(), get_random_position() length, snake_dir = 1, (0, 0) segments = [snake.copy()]

Также змейка может столкнуться со своим телом. В этом случае игра тоже должна завершиться. Для этого создадим переменную snake_collision, в которой будем определять, пересекается ли хоть один прямоугольник тела змеи с ее головой. Воспользуемся готовой функцией collidelist() класса Rect из Pygame. А после добавим переменную в условие проверки столкновения с границами:

# Столкновение с границами и телом змейки snake_collision = pg.Rect.collidelist(snake, segments[:-1]) != -1 if snake.left < 0 or snake.right >WINDOW or snake.top < 0 or snake.bottom >WINDOW or snake_collision: snake.center, food.center = get_random_position(), get_random_position() length, snake_dir = 1, (0, 0) segments = [snake.copy()]

В итоге у нас получилась классическая игра «Змейка» на Python и Pygame. Мы научились рисовать объекты на экране, менять их параметры, управлять ими с помощью клавиатуры и обрабатывать события в игровом цикле.

Весь код игры с комментариями занимает всего 78 строк:

# Импортируем библиотеки import pygame as pg from random import randrange # Константы WINDOW = 1000 FPS = 60 TILE_SIZE = 50 RANGE = (TILE_SIZE // 2, WINDOW - TILE_SIZE // 2, TILE_SIZE) # Функция для определения координат (X:Y) случайной позиции на игровом поле get_random_position = lambda: [randrange(*RANGE), randrange(*RANGE)] # Параметры змейки snake = pg.rect.Rect([0, 0, TILE_SIZE - 2, TILE_SIZE - 2]) snake.center = get_random_position() length = 1 segments = [snake.copy()] snake_dir = (0, 0) # Параметры времени и задержки time = 0 time_step = 110 # Параметры объектов еды food = snake.copy() food.center = get_random_position() # Инициализация объектов gameScreen = pg.display.set_mode([WINDOW] * 2) clock = pg.time.Clock() # Главный цикл игры while True: # Частота обновления экрана clock.tick(FPS) # Цикл обработки событий for event in pg.event.get(): if event.type == pg.QUIT: exit() # Обработка нажатий WASD if event.type == pg.KEYDOWN: if event.key == pg.K_w: snake_dir = (0, -TILE_SIZE) if event.key == pg.K_s: snake_dir = (0, TILE_SIZE) if event.key == pg.K_a: snake_dir = (-TILE_SIZE, 0) if event.key == pg.K_d: snake_dir = (TILE_SIZE, 0) gameScreen.fill((155, 188, 15)) # Столкновение с границами и телом змейки snake_collision = pg.Rect.collidelist(snake, segments[:-1]) != -1 if snake.left < 0 or snake.right >WINDOW or snake.top < 0 or snake.bottom >WINDOW or snake_collision: snake.center, food.center = get_random_position(), get_random_position() length, snake_dir = 1, (0, 0) segments = [snake.copy()] # Поедание if snake.center == food.center: food.center = get_random_position() length += 1 # Рисуем объект еды pg.draw.rect(gameScreen, (15, 56, 15), food) # Рисуем змейку [pg.draw.rect(gameScreen, (120, 149, 12), segment) for segment in segments] # Управляем змейкой time_now = pg.time.get_ticks() if time_now - time > time_step: time = time_now snake.move_ip(snake_dir) segments.append(snake.copy()) segments = segments[-length:] pg.display.flip()

Что дальше

Игру «Змейка» на Python можно продолжать улучшать и модифицировать. К примеру, в проект можно добавить следующее:

  • В игре не хватает главного меню, меню проигрыша и отображения счета. Все это можно добавить с помощью модуля pygame.font , предназначенного для работы с текстом и шрифтами. Содержимое переменной length , в которой храним длину змейки, можно выводить в углу игрового поля и обнулять при проигрыше.
  • Наша «Змейка» получилась безмолвной, и ее надо оживить звуками. Сделать это можно с помощью модуля pygame.mixer , добавив фоновую музыку, звуковые эффекты при поворотах, поедании объектов и столкновении. Так игра будет более живой и увлекательной.
  • В старых играх, а особенно в аркадных автоматах, была возможность сохранять лучшие результаты, чтобы всегда можно было понять, кого из игроков можно считать абсолютным чемпионом. В нашу «Змейку» тоже можно добавить таблицу рекордов. Для этого надо разобраться с принципами хранения данных и сортировки. К примеру, в меню можно добавить отдельное всплывающее окно с пятью лучшими результатами и имена игроков.
  • Обычная змейка довольно быстро надоедает, поэтому можно добавить несколько новых режимов. К примеру, змейка может менять направление движения каждый раз, когда съедает блок еды. А еще ей можно увеличивать скорость или добавить жизни, дающие право на ошибку.
  • Одному играть тоже скучно, поэтому можно сделать игровое поле больше и добавить на него сразу двух змеек. Управление первой настроить на клавиши WASD, а второй — на стрелки. Тогда за одним компьютером в игру смогут играть сразу два пользователя. Только важно сделать змеек разных цветов, иначе игроки будут путаться.

Python-разработчик

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

Создание 2D платформера на Python

Создание 2D платформера на Python

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

Для реализации игр на Питон мы можем выбрать одну из нескольких библиотек. Можно работать с: Kivy, Tkinter, PyQt или же с любой другой библиотекой, что обеспечивает построение графического интерфейса через Python. Таких библиотек много, но мы возьмем библиотеку PyGame , которая даже своим названием говорит о её предназначении.

PyGame появился в 2000 году. С тех пор на его основе было сделано много интересных проектов . К сожалению, PyGame не универсален и разработка на нём ведется лишь под Андроид устройства.

Настройка проекта

Перед использованием PyGame его нужно установить через терминал. Прописываем команду:

pip install pygame

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

import pygame pygame.init() win = pygame.display.set_mode((500, 500)) # размеры X и Y pygame.display.set_caption("Название игры") while(True): pass

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

import pygame pygame.init() win = pygame.display.set_mode((500, 500)) # размеры X и Y pygame.display.set_caption("Название игры") run = True while(run): for event in pygame.event.get(): if event.type == pygame.QUIT: run = False pygame.quit()

Создание платформера

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

import pygame # Переменные для установки ширины и высоты окна SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 # Подключение фото для заднего фона # Здесь лишь создание переменной, вывод заднего фона ниже в коде bg = pygame.image.load('bg.jpg') # Класс, описывающий поведение главного игрока class Player(pygame.sprite.Sprite): # Изначально игрок смотрит вправо, поэтому эта переменная True right = True # Методы def __init__(self): # Стандартный конструктор класса # Нужно ещё вызывать конструктор родительского класса super().__init__() # Создаем изображение для игрока # Изображение находится в этой же папке проекта self.image = pygame.image.load('idle.png') # Установите ссылку на изображение прямоугольника self.rect = self.image.get_rect() # Задаем вектор скорости игрока self.change_x = 0 self.change_y = 0 def update(self): # В этой функции мы передвигаем игрока # Сперва устанавливаем для него гравитацию self.calc_grav() # Передвигаем его на право/лево # change_x будет меняться позже при нажатии на стрелочки клавиатуры self.rect.x += self.change_x # Следим ударяем ли мы какой-то другой объект, платформы, например block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) # Перебираем все возможные объекты, с которыми могли бы столкнуться for block in block_hit_list: # Если мы идем направо, # устанавливает нашу правую сторону на левой стороне предмета, которого мы ударили if self.change_x > 0: self.rect.right = block.rect.left elif self.change_x < 0: # В противном случае, если мы движемся влево, то делаем наоборот self.rect.left = block.rect.right # Передвигаемся вверх/вниз self.rect.y += self.change_y # То же самое, вот только уже для вверх/вниз block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) for block in block_hit_list: # Устанавливаем нашу позицию на основе верхней / нижней части объекта, на который мы попали if self.change_y >0: self.rect.bottom = block.rect.top elif self.change_y < 0: self.rect.top = block.rect.bottom # Останавливаем вертикальное движение self.change_y = 0 def calc_grav(self): # Здесь мы вычисляем как быстро объект будет # падать на землю под действием гравитации if self.change_y == 0: self.change_y = 1 else: self.change_y += .95 # Если уже на земле, то ставим позицию Y как 0 if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0: self.change_y = 0 self.rect.y = SCREEN_HEIGHT - self.rect.height def jump(self): # Обработка прыжка # Нам нужно проверять здесь, контактируем ли мы с чем-либо # или другими словами, не находимся ли мы в полете. # Для этого опускаемся на 10 единиц, проверем соприкосновение и далее поднимаемся обратно self.rect.y += 10 platform_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) self.rect.y -= 10 # Если все в порядке, прыгаем вверх if len(platform_hit_list) > 0 or self.rect.bottom >= SCREEN_HEIGHT: self.change_y = -16 # Передвижение игрока def go_left(self): # Сами функции будут вызваны позже из основного цикла self.change_x = -9 # Двигаем игрока по Х if(self.right): # Проверяем куда он смотрит и если что, то переворачиваем его self.flip() self.right = False def go_right(self): # то же самое, но вправо self.change_x = 9 if (not self.right): self.flip() self.right = True def stop(self): # вызываем этот метод, когда не нажимаем на клавиши self.change_x = 0 def flip(self): # переворот игрока (зеркальное отражение) self.image = pygame.transform.flip(self.image, True, False) # Класс для описания платформы class Platform(pygame.sprite.Sprite): def __init__(self, width, height): # Конструктор платформ super().__init__() # Также указываем фото платформы self.image = pygame.image.load('platform.png') # Установите ссылку на изображение прямоугольника self.rect = self.image.get_rect() # Класс для расстановки платформ на сцене class Level(object): def __init__(self, player): # Создаем группу спрайтов (поместим платформы различные сюда) self.platform_list = pygame.sprite.Group() # Ссылка на основного игрока self.player = player # Чтобы все рисовалось, то нужно обновлять экран # При вызове этого метода обновление будет происходить def update(self): self.platform_list.update() # Метод для рисования объектов на сцене def draw(self, screen): # Рисуем задний фон screen.blit(bg, (0, 0)) # Рисуем все платформы из группы спрайтов self.platform_list.draw(screen) # Класс, что описывает где будут находится все платформы # на определенном уровне игры class Level_01(Level): def __init__(self, player): # Вызываем родительский конструктор Level.__init__(self, player) # Массив с данными про платформы. Данные в таком формате: # ширина, высота, x и y позиция level = [ [210, 32, 500, 500], [210, 32, 200, 400], [210, 32, 600, 300], ] # Перебираем массив и добавляем каждую платформу в группу спрайтов - platform_list for platform in level: block = Platform(platform[0], platform[1]) block.rect.x = platform[2] block.rect.y = platform[3] block.player = self.player self.platform_list.add(block) # Основная функция прогарммы def main(): # Инициализация pygame.init() # Установка высоты и ширины size = [SCREEN_WIDTH, SCREEN_HEIGHT] screen = pygame.display.set_mode(size) # Название игры pygame.display.set_caption("Платформер") # Создаем игрока player = Player() # Создаем все уровни level_list = [] level_list.append(Level_01(player)) # Устанавливаем текущий уровень current_level_no = 0 current_level = level_list[current_level_no] active_sprite_list = pygame.sprite.Group() player.level = current_level player.rect.x = 340 player.rect.y = SCREEN_HEIGHT - player.rect.height active_sprite_list.add(player) # Цикл будет до тех пор, пока пользователь не нажмет кнопку закрытия done = False # Используется для управления скоростью обновления экрана clock = pygame.time.Clock() # Основной цикл программы while not done: # Отслеживание действий for event in pygame.event.get(): if event.type == pygame.QUIT: # Если закрыл программу, то останавливаем цикл done = True # Если нажали на стрелки клавиатуры, то двигаем объект if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: player.go_left() if event.key == pygame.K_RIGHT: player.go_right() if event.key == pygame.K_UP: player.jump() if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT and player.change_x < 0: player.stop() if event.key == pygame.K_RIGHT and player.change_x > 0: player.stop() # Обновляем игрока active_sprite_list.update() # Обновляем объекты на сцене current_level.update() # Если игрок приблизится к правой стороне, то дальше его не двигаем if player.rect.right > SCREEN_WIDTH: player.rect.right = SCREEN_WIDTH # Если игрок приблизится к левой стороне, то дальше его не двигаем if player.rect.left < 0: player.rect.left = 0 # Рисуем объекты на окне current_level.draw(screen) active_sprite_list.draw(screen) # Устанавливаем количество фреймов clock.tick(30) # Обновляем экран после рисования объектов pygame.display.flip() # Корректное закртытие программы pygame.quit()

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

(фото на задний фон)

Добавить комментарий

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