Узнайте, как создать свою первую игру на Python с использованием библиотеки Pygame и стать успешным разработчиком! ????????

Python — один из самых популярных языков программирования, который благодаря своей простоте и универсальности стал основой для множества проектов. Сегодня мы рассмотрим создание игры на Python с использованием библиотеки Pygame. ????

Что такое Pygame?

Pygame — это набор модулей, предназначенных для написания видеоигр на Python. Он предоставляет возможности для работы с графикой, звуком и управлением, что делает его отличным инструментом для создания простых и средних игр. ????️

Установка Pygame

Для начала установим библиотеку Pygame. Откройте терминал и выполните следующую команду:

pip install pygame

Теперь Pygame установлен, и мы можем начать создавать нашу игру!

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

Сначала импортируем библиотеку Pygame и инициализируем ее:

import pygame
pygame.init()

Затем создадим окно игры с заданными размерами:

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

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

Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Получить программу

Создание объектов и управление игровым процессом

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

1. Создадим классы для игрока и кругов:

class Player(pygame.sprite.Sprite):
# Код для создания и управления игроком

class Circle(pygame.sprite.Sprite):
# Код для создания движущихся кругов

1. Реализуем в классах методы для отрисовки и обновления состояний объектов:

class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
# Код для создания игрока
def update(self):
# Код для обновления состояния игрока

class Circle(pygame.sprite.Sprite):
def __init__(self, x, y, speed):
# Код для создания круга
def update(self):
# Код для обновления состояния круга

1. Создадим группы спрайтов для удобства управления и отрисовки объектов:

player_group = pygame.sprite.Group()
circle_group = pygame.sprite.Group()

1. Реализуем основной игровой цикл, в котором будут происходить обновление состояний объектов и их отрисовка на экране:

running = True
while running:
# Обработка событий
# Обновление состояний объектов
# Отрисовка объектов на экране

После того, как ваша игра будет готова, не забудьте освободить ресурсы и закрыть окно Pygame:

pygame.quit()

Теперь вы знаете основы создания игр на Python с использованием библиотеки Pygame! ???? Этот навык может стать отличным началом для карьеры в сфере Python-разработки. Если вы хотите продолжить развиваться в этом направлении, рекомендую обратиться к хорошей онлайн школе, которая учит специалистов в сфере «Python-разработка».

Python-разработчик: новая работа через 9 месяцев

Получится, даже если у вас нет опыта в IT

Получить программу Приятного обучения и успешного создания игр!

Пишем игру на python под андроид

Python — это отличный язык программирования для создания игр, и его легко использовать для разработки мобильных игр на Android. В этом руководстве мы рассмотрим, как создать простую игру на Python под Android, используя фреймворк Kivvy.

Прежде всего, установите Kivy на свой компьютер:

pip install kivy

После установки вы можете создать новый проект Kivy, используя следующий код:

from kivy.app import Appfrom kivy.uix.label import Labelclass MyApp(App): def build(self): return Label(text=»Hello, world!»)

MyApp().run()

Этот код создает простое приложение Kivy, которое выводит метку «Hello, world!» Как только вы запустите этот код на своем устройстве Android, вы увидите это сообщение на экране.

https://www.youtube.com/watch?v=jZL0Hh1Dc-M\u0026list=PLDyJYA6aTY1mLtXrGH55paZHFjpqHdDol

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

from kivy.app import Appfrom kivy.uix.image import Imageclass MyApp(App): def build(self): return Image(source='image.png')

MyApp().run()

Этот код создает приложение Kivy, которое выводит изображение из файла «image.png», расположенного в папке проекта.

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

from kivy.app import Appfrom kivy.uix.image import Imagefrom kivy.clock import Clockimport randomclass MyApp(App): def build(self): self.img = Image(source='image.png') self.score = 0 Clock.schedule_interval(self.update, 1.0) return self.img def on_touch_down(self, touch): if self.img.collide_point(*touch.pos): self.score += 1 return super().on_touch_down(touch) def update(self, dt): x = random.randint(0, self.width — self.img.width) y = random.randint(0, self.height — self.img.height) self.img.pos = (x, y) self.img.source = 'image.png' self.root_window.title = «Score: {}».format(self.score)

MyApp().run()

Этот код создает приложение Kivy, которое выводит изображение из файла «image.png» и перемещает его в случайное место на экране каждую секунду. Игрок должен нажать на изображение, чтобы набрать очки. Количество очков отображается в заголовке окна.

The Division Resurgence — Первый взгляд на региональную бетку (android)

• Как создать Android игру за 10 минут на языке Python!
• Можно Ли Делать ИГРЫ на Python?
• Как сделать игру на Python под Android? (PyGame)
• СДЕЛАЛ ПОЛНОЦЕННУЮ ИГРУ В 12 ЛЕТ
• Как я написала игру на Python с нуля
• Создаем свое ANDROID приложение на PYTHON
• Простой бот для Android на Python в 13 строк — Управление андройдом с помощью питона
• Как создать игру для мобильного телефона #1 — [Делаем Тетрис на Python + Kivy]
• ТОП-3 СПОСОБА Программировать Python на Андроиде!

BLGPG-75E71965CE24-23-10-13-22

Новые материалы:

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

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

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

Что такое Pygame?

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

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

Игровой цикл

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

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

1. Обработка ввода (события)

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

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

https://www.youtube.com/watch?v=TcRRWuQXNfU\u0026list=PLDyJYA6aTY1mLtXrGH55paZHFjpqHdDol

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

Время

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

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

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

Создание шаблона 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. В результате цикл завершится. Теперь можно заполнить каждый раздел базовым кодом.

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

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

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

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

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

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

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 будет выглядеть вот так:

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(): if event.type == pygame.QUIT: running = False screen.fill(BLACK) pygame.display.flip() pygame.quit()

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

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

Часть 2. Работа со спрайтами

Как сделать игру тетрис на Python — IT для детей на DTF

Показываем и рассказываем, как написать тетрис на Python с помощью модуля Pygame.

{«id»:1666309,»gtm»:null}

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

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

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

В конце инструкции — ссылка на тематический видеоурок: просмотр закрепит знания.

Сразу напомним: модуль Pygame изначально не встроен в Python. Если он не установлен, проще это сделать в консоли командой pip install pygame.

Первым делом импортируем нужные библиотеки: pygame, random, copy. Copy понадобится, чтобы разобраться с одной особенностью хранения в Python.

После чего активируем модули Pygame и зададим 2 параметра сетки — I_max и J_max. Сетка строится по такому принципу: число ячеек равно числу точек -1. Можете убедиться в этом, посчитав на рисунке или нарисовав сами:

Задав число точек I_max и J_max 11 и 21, получим 11 и 20 ячеек соответственно.

Зададим 2 переменные с параметрами экрана 300 на 600. После сделаем экран, туда запишем переменные, а также создадим класс Clock(). Он понадобится для работы со временем — с частотой обновления экрана.

Сосчитаем шаг по x и по y для сетки — ширину и высоту ячейки. Делим на I_max -1, J_max -1: область необходимо разделить на число ячеек, а оно как раз на 1 меньше числа точек. Создаем переменную для частоты обновления кадров.

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

Кроме 1, заполним списки сущностями прямоугольников — rect, а также цветом для каждого из них. В координатах прямоугольников пишем координаты, где они должны находиться. Это можно сосчитать, умножив номер точки на шаг — ширину или высоту ячейки.

Пора запустить бесконечный цикл, заполнить экран для его обновления и нарисовать сетку. Для этого снова пройдемся по элементам сетки и нарисуем каждый квадратик. Третий элемент списка — 2: это цвет. Второй — 1: сущность прямоугольника, созданного ранее. Тип заполнения — 0: когда стоит 1, у прямоугольника нарисована граница шириной 1. Если бы поставили 0, он бы заполнился полностью.

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

Тетрис — игра про детали. Потому рекомендуем посмотреть на 7 оригинальных фигур тетриса:

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

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

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

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

Для создания движения будем брать рандомно выбранную деталь det_choice и менять координаты у 4 прямоугольников на шаг dx и dy.

Для примера напишем 1*dx и посмотрим, что будет. Деталь быстро улетела вправо. Если поменяем на -1 — быстро улетит влево. Будем менять данные параметры с 0 на 1 и -1 при взаимодействии с клавишами стрелки вправо или стрелки влево. Создадим event нажатия на клавишу: если нажата стрелка влево, меняем переменную delta_x на -1. Для правой стрелки аналогично, только +1.

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

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

Добавим вариант ускорения передвижения по y, если хотим резко уронить деталь и не ждать ее медленного падения. Чтобы зажимать клавишу, а не нажимать по кнопке много раз, используем функцию get_pressed(). Если ключ, который нажмет человек, совпадает с pygame.K_DOWN, т.е. стрелкой вниз, число обновлений сразу зададим равным 31.

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

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

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

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

Основные механики готовы, осталось только внедрить пару вещей из оригинальной игры: поворот деталей и снос заполненного ряда.

Начнем с поворота. Его сделаем по стандартной математической формуле поворота на 90 градусов в декартовой системе координат — относительно центра в (0,0). Центр записан в третьей ячейке, поэтому обозначаем как центр второй индекс det_choice[2].

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

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

Если число заполненных ячеек равно числу ячеек в целом, запускаем еще 2 цикла. Сначала ячейки верхнего ряда делаем незакрашенными, а после все ячейки рядов смещаем на ряд вниз, начиная с заполненного.

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

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

Как сделать игру Тетрис на Python. Python создание игр с нуля

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

• Ребятам 10–14 лет подойдет курс изучения языка Пайтон. Проштудировав азы разработки, подросток напишет квест или викторину, запустит чат-бота для мессенджера или игру с функцией стрельбы, бонусами и подсчетом очков.
• Любителям Майнкрафта 9–13 лет понравится курс по кодингу на Python в Minecraft. Ребенок применит знания в любимой вселенной, написав внутриигровые программы или придумав персонажа с искусственным интеллектом.

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

• import pygame
• import random
• import copy
• pygame.init()
• I_max = 11
• J_max = 21
• screen_x = 300
• screen_y = 600

screen = pygame.display.set_mode((screen_x, screen_y))

clock = pygame.time.Clock()

pygame.display.set_caption(«Tetris Pixel Game»)

1. dx = screen_x/(I_max — 1)
2. dy = screen_y/(J_max — 1)
3. fps = 60
4. grid = []
5. for i in range(0, I_max):
6. grid.append([])
7. for j in range(0, J_max):
8. grid[i].append([1])
9. for i in range(0, I_max):
10. for j in range(0, J_max):

grid[i][j].append(pygame.Rect(i*dx, j*dy, dx, dy))

grid[i][j].append(pygame.Color(«Gray»))

• details = [
• [[-2, 0], [-1, 0], [0, 0], [1, 0]],
• [[-1, 1], [-1, 0], [0, 0], [1, 0]],
• [[1, 1], [-1, 0], [0, 0], [1, 0]],
• [[-1, 1], [0, 1], [0, 0], [-1, 0]],
• [[1, 0], [1, 1], [0, 0], [-1, 0]],
• [[0, 1], [-1, 0], [0, 0], [1, 0]],
• [[-1, 1], [0, 1], [0, 0], [1, 0]],
• ]
• det = [[],[],[],[],[],[],[]]
• for i in range(0, len(details)):
• for j in range(0, 4):

det[i].append(pygame.Rect(details[i][j][0]*dx + dx*(I_max//2), details[i][j][1]*dy, dx, dy))

detail = pygame.Rect(0, 0, dx, dy)

det_choice = copy.deepcopy(random.choice(det))

1. count = 0
2. game = True
3. rotate = False
4. while game:
5. delta_x = 0
6. delta_y = 1

for event in pygame.event.get():

if event.type == pygame.QUIT:

exit()

if event.type == pygame.KEYDOWN:

if event.key == pygame.K_LEFT:

delta_x = -1

elif event.key == pygame.K_RIGHT:

delta_x = 1

elif event.key == pygame.K_UP:

rotate = True

key = pygame.key.get_pressed()

if key[pygame.K_DOWN]:

count = 31 * fps

screen.fill(pygame.Color(«Black»))

for i in range(0, I_max):

for j in range(0, J_max):

pygame.draw.rect(screen, grid[i][j][2], grid[i][j][1], grid[i][j][0])

#границы

for i in range(4):

if ((det_choice[i].x + delta_x * dx < 0) or (det_choice[i].x + delta_x * dx >= screen_x)):

delta_x = 0

if ((det_choice[i].y + dy >= screen_y) or (grid[int(det_choice[i].x//dx)][int(det_choice[i].y//dy) + 1][0] == 0)):

• delta_y = 0
• for i in range(4):
• x = int(det_choice[i].x // dx)
• y = int(det_choice[i].y // dy)
• grid[x][y][0] = 0 #закрашиваем квадратик
• grid[x][y][2] = pygame.Color(«White»)
• detail.x = 0
• detail.y = 0

det_choice = copy.deepcopy(random.choice(det))

1. #передвижение по x
2. for i in range(4):
3. det_choice[i].x += delta_x*dx
4. count += fps
5. #передвижение по y
6. if count > 30 * fps:
7. for i in range(4):
8. det_choice[i].y += delta_y*dy
9. count = 0
10. for i in range(4):

detail.x = det_choice[i].x

detail.y = det_choice[i].y

pygame.draw.rect(screen, pygame.Color(«White»), detail)

• C = det_choice[2] #центр СК
• if rotate == True:
• for i in range(4):

x = det_choice[i].y — C.y

y = det_choice[i].x — C.x

det_choice[i].x = C.x — x

det_choice[i].y = C.y + y

1. rotate = False
2. for j in range(J_max — 1, -1, -1): #цикл по рядам снизу вверх
3. count_cells = 0
4. for i in range(0, I_max): #цикл по столбцам справа налево
5. if grid[i][j][0] == 0:
6. count_cells += 1
7. elif grid[i][j][0] == 1:
8. break
9. if count_cells == (I_max — 1):
10. for l in range(0, I_max):
11. grid[l][0][0] = 1 #все ячейки первого ряда
12. for k in range(j, -1, -1):
13. for l in range(0, I_max):
14. grid[l][k][0] = grid[l][k-1][0]

pygame.display.flip()

clock.tick(fps)

Как писать игры на Python с Pygame

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

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

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

Для начала работы с библиотекой необходимо добавить ее в локальную среду разработки. На Python Pygame-установкавыполняется через pip:

python -m pip install -U pygame —user

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

python -m pygame.examples.aliens

Должна запуститься игра, в которой нужно уничтожать летающие тарелки инопланетян.

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

Игровой цикл

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

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

while True:      # Code

      pygame.display.update()

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

Выход из игрового цикла

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

while True:    pygame.display.update()    for event in pygame.event.get():        if event.type == QUIT:            pygame.quit()

            sys.exit()

Мы вызываем pygame.quit() и sys.exit(), чтобы закрыть окно Pygame и завершить скрипт Python соответственно. Простое использование sys.exit() может привести к зависанию IDE.

Игровые события

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

Вы можете узнать, какие события произошли, вызвав функцию pygame.event.get(). Она возвращает список объектов pygame.event.Event. Для краткости будем называть это объектами событий.

Одним из многих атрибутов (или свойств), которыми обладают объекты событий, является тип — type. Атрибут type сообщает, какое событие представляет объект.

В примере выше использован event.type == QUIT. Он помогает определить, должна игра быть закрыта или нет. Пока пользователь не закроет игру (говоря языком Pygame, не вызовет событие ‘QUIT’), она будет работать в бесконечном цикле.

Игровой экран

Для игры нужно создать окно фиксированного размера, внутри которого будут происходить все события. Ширина и высота этого окна в пикселях передаются в функцию pygame set mode в виде кортежа.

DISPLAYSURF = pygame.display.set_mode((300,300))

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

Кадровая частота

Если не задать ограничение на частоту кадров, компьютер будет выполнять игровой цикл столько раз, сколько может в течение секунды. Чтобы ограничить его, используйте метод ‘tick(fps)’, где fps — целое число. Метод ‘tick(fps)’ принадлежит классу ‘pygame.time.Clock’ и должен использоваться с объектом этого класса.

FPS = pygame.time.Clock()FPS.tick(60)

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

Цвета

Pygame использует систему цветов RGB (Red, Green, Blue). Значения для каждого цвета находятся в диапазоне от 0 до 255, всего 256 значений. Сочетание этих трех цветов используется для создания всех цветов, которые вы видите на компьютерах или на любом устройстве с экраном.

Чтобы использовать цвета в Pygame, создают объекты Color, используя значения RGB. Значения RGB должны быть в формате кортежа с тремя значениями для каждого основного цвета.

BLACK = pygame.Color(0, 0, 0)WHITE = pygame.Color(255, 255, 255)GREY = pygame.Color(128, 128, 128)

RED = pygame.Color(255, 0, 0)

В работе с цветами есть одна особенность. Например, если вы нарисуете квадрат и зададите ему зеленый цвет, то по умолчанию зелеными станут только границы. Для полной заливки объектов используйте метод ‘fill’. Это сделает квадрат полностью зеленым.

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

Теперь пришло время заняться самым интересным — разработать первую игру.

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

# Импортируем библиотекиimport pygame, sysfrom pygame.locals import *import random # Инициализируем Pygamepygame.init() # Ограничиваем количество кадров в секундуFPS = 60FramePerSec = pygame.time.Clock() # Задаем цветWHITE = (255, 255, 255) # Задаем размеры игрового экранаSCREEN_WIDTH = 400SCREEN_HEIGHT = 600  # Отрисовываем экран и заливаем его белым цветомDISPLAYSURF = pygame.display.set_mode((SCREEN_WIDTH,SCREEN_HEIGHT)))DISPLAYSURF.fill(WHITE)pygame.display.set_caption(«Game») # Определяем класс игрокаclass Player(pygame.sprite.Sprite):    def __init__(self):        super().__init__()         self.image = pygame.image.load(«Player.png»)        self.rect = self.image.get_rect()        self.rect.center = (160, 520)      def update(self):        pressed_keys = pygame.key.get_pressed()                    if self.rect.left > 0:              if pressed_keys[K_LEFT]:                  self.rect.move_ip(-5, 0)        if self.rect.right < SCREEN_WIDTH:                      if pressed_keys[K_RIGHT]:                  self.rect.move_ip(5, 0)      def draw(self, surface):        surface.blit(self.image, self.rect)      # Определяем класс врагаclass Enemy(pygame.sprite.Sprite):      def __init__(self):        super().__init__()         self.image = pygame.image.load("Enemy.png")        self.rect = self.image.get_rect()        self.rect.center=(random.randint(40,SCREEN_WIDTH-40),0)        def move(self):        self.rect.move_ip(0,10)        if (self.rect.bottom > 600):            self.rect.top = 0            self.rect.center = (random.randint(30, 370), 0)        def draw(self, surface):        surface.blit(self.image, self.rect)           # Создаем персонажейP1 = Player()E1 = Enemy() # Определяем игровой циклwhile True:         for event in pygame.event.get():                      if event.type == QUIT:            pygame.quit()            sys.exit()    P1.update()    E1.move()          DISPLAYSURF.fill(WHITE)    P1.draw(DISPLAYSURF)    E1.draw(DISPLAYSURF)              pygame.display.update()

    FramePerSec.tick(FPS)

Теперь давайте разбирать, какие Pygame Python-команды здесь используются.

Инициализация игры

Создание игры на Python с Pygame начинается с импорта библиотеки. Откройте файл в любой IDE или редакторе кода и добавьте две строки:

import pygamefrom pygame.locals import *

Первой строкой вы импортировали модуль Pygame Python 3.Второй строкой вы импортировали все переменные из pygame.locals. 

Можно обойтись без второго импорта. Но он заметно сокращает количество кода. Например, событие выхода из игры без импорта переменных из pygame.locals придется записывать так: ‘pygame.locals.QUIT’. С импортом же синтаксис гораздо короче — для добавления события достаточно написать ‘QUIT’. 

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

import random

В начале файла должна быть ещё одна важная строка:

pygame.init()

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

Определение персонажей

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

Сначала определим класс игрока:

class Player(pygame.sprite.Sprite):    def __init__(self):        super().__init__()         self.image = pygame.image.load(«Player.png»)        self.rect = self.image.get_rect()

        self.rect.center = (160, 520)

Функция image.load() принимает на вход файл изображения. Чтобы определить границы спрайта игрока, достаточно вызвать функцию get_rect().

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

Последняя строка self.rect.center определяет начальную позицию персонажа на игровом поле.

def update(self):    pressed_keys = pygame.key.get_pressed()      if self.rect.left > 0:          if pressed_keys[K_LEFT]:              self.rect.move_ip(-5, 0)    if self.rect.left > 0:                 if pressed_keys[K_RIGHT]:

              self.rect.move_ip(5, 0)

Метод update управляет движением игрока. При его вызове выполняется проверка, нажаты ли клавиши.  

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

Метод move_ip() принимает два параметра. Первый параметр — это расстояние в пикселях, на которое необходимо переместить объект по горизонтали. Второй параметр — расстояние, на которое необходимо переместить объект по вертикали.

Операторы if self.rect.left > 0 и if self.rect.left > 0 гарантируют, что игрок не выйдет за пределы игрового поля.

def draw(self, surface):    surface.blit(self.image, self.rect)     

Функция blit() принимает параметры. Первый — объект для отрисовки, а второй — его спрайт. Поскольку вы используете изображение, то передаете self.image в качестве объекта для отрисовки. 

Класс врага устроен очень похоже. Единственное отличие — использование генератора случайных чисел:

self.rect.center=(random.randint(40,SCREEN_WIDTH-40),0)

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

Игровой цикл

И самая важная часть — игровой цикл:

while True:         for event in pygame.event.get():                      if event.type == QUIT:            pygame.quit()            sys.exit()    P1.update()    E1.move()          DISPLAYSURF.fill(WHITE)    P1.draw(DISPLAYSURF)    E1.draw(DISPLAYSURF)     pygame.display.update()

    FramePerSec.tick(FPS)

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

Сначала вызываются функции update для классов Enemy и Player. Далее цикл обновляет экран с помощью DISPLAY.fill(WHITE). Наконец, вызывается функция draw для отрисовки объектов на экране.

Наконец, команда pygame.display.update() обновляет экран, выводя все изменения, которые произошли до этого момента. Функция tick() гарантирует, что количество кадров в секунду при этом не превышает установленного ранее значения FPS.

Заключение

Игра готова. Она пока не настолько хороша, чтобы арендовать сервер для хостинга на timeweb.cloud и ждать наплыва игроков. Но это ваша первая игра на Питон —и теперь вы знаете, как сделать ее лучше. Например, как добавить персонажу движение вверх и вниз или изменить логику появления препятствий.

Возможностей для совершенствования проекта очень много. Например, можно сделать двумерную игру трехмерной, используяPygame raycast. Да, на Pygame не получится разработать клона Cyberpunk 2077, но свою версию Wolfenstein 3D сделать реально. 

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