Как сделать слайдер pygame
Добавил пользователь Morpheus Обновлено: 05.10.2024
Это четвёртая из пяти частей туториала, посвящённого созданию игр с помощью Python 3 и Pygame. В третьей части мы углубились в сердце Breakout и узнали, как обрабатывать события, познакомились с основным классом Breakout и увидели, как перемещать разные игровые объекты.
В этой части мы узнаем, как распознавать коллизии и что случается, когда мяч ударяется об разные объекты: ракетку, кирпичи, стены, потолок и пол. Наконец, мы рассмотрим важную тему пользовательского интерфейса и в частности то, как создать меню из собственных кнопок.
Распознавание коллизий
В играх объекты сталкиваются друг с другом, и Breakout не является исключением. В основном с объектами сталкивается мяч. В методе handle_ball_collisions() есть встроенная функция под названием intersect() , которая используется для проверки того, ударился ли мяч об объект, и того, где он столкнулся с объектом.Она возвращает 'left', 'right', 'top', 'bottom' или None, если мяч не столкнулся с объектом.
Столкновение мяча с ракеткой
Когда мяч стукается об ракетку, он отскакивает. Если он ударяется о верхнюю часть ракетки, то отражается обратно вверх, но сохраняет тот же компонент горизонтальной скорости.
Но если он ударяется о боковую часть ракетки, то отскакивает в противоположную сторону (влево или вправо) и продолжает движение вниз, пока не столкнётся с полом. В коде используется функция intersect().
Столкновение с полом
Когда ракетка пропускает мяч на пути вниз (или мяч ударяется об ракетку сбоку), то мяч продолжает падать и затем ударяется об пол. В этот момент игрок теряет жизнь и мяч создаётся заново, чтобы игра могла продолжаться. Игра завершается, когда у игрока заканчиваются жизни.
Столкновение с потолком и стенами
Когда мяч ударяется об стены или потолок, он просто отскакивает от них.
Столкновение с кирпичами
Когда мяч ударяется об кирпич, это является основным событием игры Breakout — кирпич исчезает, игрок получает очко, мяч отражается назад и происходят ещё несколько событий (звуковой эффект, а иногда и спецэффект), которые я рассмотрю позже.
Чтобы определить, что мяч ударился об кирпич, код проверят, пересекается ли какой-нибудь из кирпичей с мячом:
Программирование игрового меню
В большинстве игр есть какой-нибудь UI. В Breakout есть простое меню с двумя кнопками, 'PLAY' и 'QUIT'. Меню отображается в начале игры и пропадает, когда игрок нажимает на 'PLAY'. Давайте посмотрим, как реализуются кнопки и меню, а также как они интегрируются в игру.
Создание кнопок
В Pygame нет встроенной библиотеки UI. Есть сторонние расширения, но для меню я решил создать свои кнопки. Кнопка — это игровой объект, имеющий три состояния: нормальное, выделенное и нажатое. Нормальное состояние — это когда мышь не находится над кнопкой, а выделенное состояние — когда мышь находится над кнопкой, но левая кнопка мыши ещё не нажата. Нажатое состояние — это когда мышь находится над кнопкой и игрок нажал на левую кнопку мыши.
Кнопка реализуется как прямоугольник с фоновым цветом и текст, отображаемый поверх него. Также кнопка получает функцию on_click (по умолчанию являющуюся пустой лямбда-функцией), которая вызывается при нажатии кнопки.
Кнопка обрабатывает собственные события мыши и изменяет своё внутреннее состояние на основании этих событий. Когда кнопка находится в нажатом состоянии и получает событие MOUSEBUTTONUP , это означает, что игрок нажал на кнопку, и вызывается функция on_click() .
Свойство back_color , используемое для отрисовки фонового прямоугольника, всегда возвращает цвет, соответствующий текущему состоянию кнопки, чтобы игроку было ясно, что кнопка активна:
Создание меню
Функция create_menu() создаёт меню с двумя кнопками с текстом 'PLAY' и 'QUIT'. Она имеет две встроенные функции, on_play() и on_quit() , которые она передаёт соответствующей кнопке. Каждая кнопка добавляется в список objects (для отрисовки), а также в поле menu_buttons .
При нажатии кнопки PLAY вызывается функция on_play(), удаляющая кнопки из списка objects , чтобы они больше не отрисовывались. Кроме того, значения булевых полей, которые запускают начало игры — is_game_running и start_level — становятся равными True.
При нажатии кнопки QUIT is_game_running принимает значение False (фактически ставя игру на паузу), а game_over присваивается значение True, что приводит к срабатыванию последовательности завершения игры.
Отображение и сокрытие игрового меню
Отображение и сокрытие меню выполняются неявным образом. Когда кнопки находятся в списке objects , меню видимо; когда они удаляются, оно скрывается. Всё очень просто.
Можно создать встроенное меню с собственной поверхностью, которое рендерит свои подкомпоненты (кнопки и другие объекты), а затем просто добавлять/удалять эти компоненты меню, но для такого простого меню это не требуется.
Подводим итог
В этой части мы рассмотрели распознавание коллизий и то, что происходит, когда мяч сталкивается с разными объектами: ракеткой, кирпичами, стенами, полом и потолком. Также мы создали меню с собственными кнопками, которое можно скрывать и отображать по команде.
В последней части серии мы рассмотрим завершение игры, отслеживание очков и жизней, звуковые эффекты и музыку.
Затем мы разработаем сложную систему спецэффектов, добавляющих в игру немного специй. Наконец, мы обсудим дальнейшее развитие и возможные улучшения.
pygame - это библиотека модулей для языка Python, созданная для разработки 2D игр.
Для того чтобы установить pygame на свой компьютер необходимо открыть командную строку или терминал и написать команду
pip3 install pygame
После установки необходимо создать новый файл и импортировать модуль pygame и написать шаблон игры
Пользователь может взаимодействовать с нашей игрой. Каждое действие пользователя - это некоторое событие , которое мы можем обработать . Выражение pygame.event.get() - это список событий, произошедших в нашей игре.
Цикл for просто перебирает необработанные события. Каждое событие он присваивает переменной event (можно написать любую другую).
Поговорим о цикле while , основном цикле игры . Как часто он выполняется? Очень и очень часто, это зависит от мощности компьютера. Для обновления экрана в играх часто используют 60 кадров в секунду.
Ограничим количество выполнений цикла.
import pygame
from sys import exit
display = pygame.display. set_mode ( ( 800 , 600 ) )
Методу tick() передается желаемое количество кадров в секунду. Задержку он вычисляет сам. На каждой итерации основного цикла игры секунда делится на 60 и на вычисленную величину выполняется задержка.
В библиотеке pygame существует множество функций для рисования различных фигур.
Функция polygon() рисует произвольную фигуру. Она принимает 3 обязательных параметра (поверхность, цвет и кортеж координат) и 1 необязательный (толщину линий).
import pygame
from sys import exit
display = pygame.display. set_mode ( ( 800 , 600 ) )
FPS = 60
clock = pg.time. Clock ()
while True :
f or event in pygame.event. get ():
if event.type == pygame.QUIT:
pygame. quit ()
exit ()
display - наша поверхность
(255, 0, 0) - красный цвет , почитайте про rgb
( (0, 0), (100, 0), (100, 100), (0, 100) ) - координаты вершин квадрата. Возьмите листочек и нарисуйте его координатах (замените сотню на единицу).
Давайте нарисуем треугольник
import pygame
from sys import exit
display = pygame.display. set_mode ( ( 800 , 600 ) )
(0, 0, 255) - синий цвет
((100, 100), (200, 200), (100, 200)) - координаты вершин нашего треугольник.
Самостоятельно нарисуйте пятиугольник (вам помогут карандаш и лист бумаги)
Рисование окружностей
Чтобы нарисовать окружность нужно вызвать метод circle из модуля draw. Команда выглядит так: pygame.draw.circle(display, color, position, radius).
display - поверхность, на которой рисуем
color - цвет, записанный в кортеже из трех чисел. (еще раз про rgb)
position - координаты точки центра окружности ( кортеж из двух чисел (x, y) )
radius - радиус окружности в пикселях
import pygame
from sys import exit
display = pygame.display. set_mode ( ( 800 , 600 ) )
FPS = 60
clock = pg.time. Clock ()
while True :
f or event in pygame.event. get ():
if event.type == pygame.QUIT:
pygame. quit ()
exit ()
display - наша поверхнотсть для рисования
(255, 255, 0) - желтый цвет
(400, 200) - координаты точки центра (в нашем случае 400 пикселей от верхнего левого угла по горизонтали и 200 пикселей по вертикали)
100 - радиус нашей окружности в пикселях
Объявления переменных для цветов
Для нашего с вами удобства давайте объявим несколько переменных, в которые сохраним используемые нами цвета
import pygame
from sys import exit
WHITE = ( 255 , 255 , 255 )
BLACK = ( 0 , 0 , 0 )
PURPLE = ( 156 , 39 , 176 )
INDIGO = ( 63 , 81 , 181 )
BLUE = ( 33 , 150 , 243 )
GREEN = ( 76 , 175 , 80 )
YELLOW = ( 255 , 235 , 59 )
ORANGE = ( 255 , 152 , 0 )
GREY = ( 158 , 158 , 158 )
display = pygame.display. set_mode ( ( 800 , 600 ) )
FPS = 60
clock = pg.time. Clock ()
while True :
f or event in pygame.event. get ():
if event.type == pygame.QUIT:
pygame. quit ()
exit ()
Рисование прямоугольников
Для отрисовки прямоугольников можно использовать метод rect.
pygame.draw.rect(display, color, (x, y, width, height) )
color - цвет (теперь можно просто написать имя переменную)
(x, y, width, height) - кортеж из четырех значений. Первые два значения - это координаты верхнего левого угла прямоугольника, а два последних - это ширина и высота.
import pygame
from sys import exit
WHITE = ( 255 , 255 , 255 )
BLACK = ( 0 , 0 , 0 )
PURPLE = ( 156 , 39 , 176 )
INDIGO = ( 63 , 81 , 181 )
BLUE = ( 33 , 150 , 243 )
GREEN = ( 76 , 175 , 80 )
YELLOW = ( 255 , 235 , 59 )
ORANGE = ( 255 , 152 , 0 )
GREY = ( 158 , 158 , 158 )
display = pygame.display. set_mode ( ( 800 , 600 ) )
FPS = 60
clock = pg.time. Clock ()
while True :
f or event in pygame.event. get ():
if event.type == pygame.QUIT:
pygame. quit ()
exit ()
Если ваша творческая натура требует большего, то вот ссылка на документацию модулю draw
Там можно найти рисование линий, дуг, эллипсов.
Большой пример ( запусти его у себя на компьтере:
Pygame задает особые правила построения кода. Эти правила не являются строгими. Однако в большинстве случаев, чтобы игра благополучно запустилась, в программе должна быть соблюдена определенная последовательность вызова ключевых команд.
Эти команды (импорт модуля, вызовы функций, цикл) создают своего рода скелет, или каркас, программного кода. Выполнив его, вы получите "пустую" игру. Далее на этот скелет "подвешивается мясо", т. е. объявляются объекты и программируется логика игры.
Первое, что нужно сделать, это импортировать модуль pygame. После этого можно вывести на экран главное графическое окно игры с помощью функции set_mode() модуля display, входящего в состав библиотеки pygame:
Если выполнить этот код, то появится окно размером 600x400 пикселей и сразу закроется (в Linux, в Windows может зависнуть).
Функция set_mode() принимает три аргумента – размер в виде кортежа из двух целых чисел, флаги и глубину цвета. Их можно не указывать. В этом случае окно займет весь экран, цветовая глубина будет соответствовать системной. Обычно указывают только первый аргумент – размер окна.
Флаги предназначены для переключения на аппаратное ускорение, полноэкранный режим, отключения рамки окна и др. Например, команда pygame. display . set_mode ( ( 640 , 560 ) , pygame. RESIZABLE ) делает окно изменяемым в размерах.
Выражение вида pygame.RESIZABLE (вместо RESIZABLE может быть любое другое слово большими буквами) обозначает обращение к той или иной константе, определенной в модуле pygame. Часто можно встретить код, в котором перед константами не пишется имя модуля (вместо, например, pygame.QUIT пишут просто QUIT). В этом случае в начале программы надо импортировать не только pygame, но и содержимое модуля locals через from … import:
Однако в данном курсе мы оставим длинное обращение к встроенным константам, чтобы на этапе обучения не путать определенные в модуле и свои собственные, которые нам также придется создавать.
Функция set_mode() возвращает объект типа Surface (поверхность). В программе может быть множество объектов данного класса, но тот, что возвращает set_mode() особенный. Его называют display surface, что можно перевести как экранная (дисплейная) поверхность. Она главная.
В конечном итоге все отображается на ней с помощью функции pygame.display.update() или родственной pygame.display.flip(), и именно эту поверхность мы видим на экране монитора. Нам пока нечего отображать, мы не создавали никаких объектов. Поэтому было показано черное окно.
Функции update() и flip() модуля display обновляют содержимое окна игры. Это значит, что каждому пикселю заново устанавливается цвет. Представьте, что на зеленом фоне движется красный круг. За один кадр круг смещается на 5 пикселей. От кадра к кадру картинка целого окна изменяется незначительно, но в памяти окно будет перерисовываться полностью. Если частота составляет 60 кадров в секунду (FPS=60), то за секунду в памяти компьютера произойдет 60 обновлений множества значений, соответствующих экранным пикселям, что дает по большей части бессмысленную нагрузку на вычислительные мощности.
Если функции update() не передавать аргументы, то будут обновляться значения всей поверхности окна. Однако можно передать более мелкую прямоугольную область или список таковых. В этом случае обновляться будут только они.
Функция flip() решает проблему иным способом. Она дает выигрыш, если в set_mod() были переданы определенные флаги (аппаратное ускорение + полноэкранный режим – pygame.HWSERFACE|pygame.FULLSCREEN, двойная буферизация – pygame.DOUBLEBUFF, использование OpenGL – pygame.OPENGL). Возможно, все флаги можно комбинировать вместе (через |). При этом, согласно документации, аппаратное ускорение работает только в полноэкранном режиме.
Вернемся к нашим трем строчкам кода. Почему окно сразу закрывается? Очевидно потому, что программа заканчивается после выполнения этих выражений. Ни init(), ни set_mode() не предполагают входа в "режим циклического ожидания событий". В tkinter для этого используется метод mainloop() экземпляра Tk(). В pygame же требуется собственноручно создать бесконечный цикл, заставляющий программу зависнуть. Основная причина в том, что только программист знает, какая часть его кода должна циклически обрабатываться, а какая – нет. Например, код, создающий классы, объекты и функции не "кладут" в цикл.
Итак, создадим в программе бесконечный цикл:
После такого окно уже не закроется, а программа благополучно зависнет насовсем. Многократные клики по крестику не помогут. Только принудительная остановка программы через среду разработки или Ctrl+С, если запускали через терминал.
Как сделать так, чтобы программа закрывалась при клике на крестик окна, а также при нажатии Alt+F4? Pygame должен воспринимать такие действия как определенный тип событий.
Добавим в цикл магии:
При выходе будет генерироваться ошибка, пока забудем про нее. Сейчас достаточно того, что окно успешно закрывается.
Рассмотрим выражение pygame.event.get(). Модуль event библиотеки pygame содержит функцию get(), которая забирает список событий из очереди, в которую записываются все произошедшие события. То, что возвращает get() – это список. Забранные события удаляются из очереди, то есть второй раз они уже забираться не будут, а в очередь продолжают записываться новые события.
Цикл for просто перебирает схваченный на данный момент (в текущей итерации цикла) список событий. Каждое событие он присваивает переменной i или любой другой. Чтобы было понятней, перепишем программу таким образом:
На экране вы увидите примерно такое:
Вверху будет множество пустых квадратных скобок, которые соответствуют пустым спискам events, создаваемым на каждой итерации цикла while. И только когда окно закрывается, генерируются два события. Свойство type второго имеет значение 256, что совпадает со значением константы QUIT.
В pygame событие – это объект класса Event. А если это объект, то у него есть атрибуты (свойства и методы). В данном случае мы отслеживаем только те события, у которых значение свойства type совпадает со значением константы QUIT модуля pygame. Это значение присваивается type тогда, когда происходят события нажатия на крестик или Alt+F4. Когда эти события происходят, то в данном случае мы хотим, чтобы выполнилась функция quit() модуля pygame, которая завершает его работу.
Теперь почему возникает ошибка. Функция pygame.quit() отключает (деинициализирует) pygame, но не завершает работу программы. Таким образом, после выполнения этой функции отключаются модули библиотеки pygame, но выхода из цикла и программы не происходит. Программа продолжает работу и переходит к следующей итерации цикла while (или продолжает выполнять тело данной итерации, если оно еще не закончилось).
В данном случае происходит переход к следующей итерации цикла while. И здесь выполнить функцию get() модуля event оказывается уже невозможным. Возникает исключение и программа завершается. По-сути программу завершает не функция pygame.quit(), а выброшенное, но не обработанное, исключение.
Данную проблему можно решить разными способами. Часто используют функцию exit() модуля sys. В этом случае код выглядит примерно так:
Сначала отключается pygame, потом происходит выход из программы. Такой вариант вероятно следует считать наиболее безопасным завершением. Команда pygame.quit() не обязательна. Если завершается программа, то отключится и pygame.
Другой вариант – не допустить следующей итерации цикла. Для этого потребуется дополнительная переменная:
В этом случае завершится текущая итерация цикла, но новая уже не начнется. Если в основной ветке ниже по течению нет другого кода, программа завершит свою работу.
Нередко код основной ветки программы помещают в функцию, например, main(). Она выполняется, если файл запускается как скрипт, а не импортируется как модуль. В этом случае для завершения программы проще использовать оператор return, который осуществляет выход из функции.
Теперь зададимся вопросом, с какой скоростью крутится цикл while? С большой, зависящей от мощности компьютера. Но в данном случае такая скорость не есть необходимость, она даже вредна, так как бессмысленно расходует ресурсы. Человек дает команды и воспринимает изменения куда медленнее.
Для обновления экрана в динамической игре часто используют 60 кадров в секунду, а в статической, типа пазла, достаточно будет 30-ти. Из этого следует, что циклу незачем работать быстрее.
Поэтому в главном цикле следует выполнять задержку. Делают это либо вызовом функции delay() модуля time библиотеки pygame, либо создают объект часов и устанавливают ему частоту кадров. Первый способ проще, второй – более профессиональный.
Функция delay() принимает количество миллисекунд (1000 мс = 1 с). Если передано значение 20, то за секунду экран обновится 50 раз. Другими словами, частота составит 50 кадров в секунду.
Методу tick() класса Clock передается непосредственно желаемое количество кадров в секунду. Задержку он вычисляет сам. То есть если внутри цикла указано tick(60) – это не значит, что задержка будет 60 миллисекунд или произойдет 60 обновлений экрана за одну итерацию цикла. Это значит, что на каждой итерации цикла секунда делится на 60 и уже на вычисленную величину выполняется задержка.
Нередко частоту кадров выносят в отдельную константоподобную переменную:
В итоге каркас игры на Pygame должен выглядеть примерно так:
Практическая работа
В модуле pygame.display есть функция set_caption(). Ей передается строка, которую она устанавливает в качестве заголовка окна. Сделайте так, чтобы каждую секунду заголовок окна изменялся.
Курс с примерами решений практических работ:
android-приложение, pdf-версия
Порулим баскетбольным мячом прямо с клавиатуры? Легко! Для этого нужно лишь закодить движение объекта — мяча в зависимости от типа нажатой стрелки на клавиатуре! В качестве основы предлагаю взять код с готовой сценой шириной 500px и высотой 300px, центре которой расположено изображение баскетбольного мяча. Кстати, мячик можно скачать по ссылке: баскетбольный мяч.
Исходные данные: сцена с неподвижным изображением
В исходном варианте сцена с мячом выглядит так:
Исходная сцена с мячом
Ниже приведен код, который воспроизводит эту сцену в Pygame:
Наша задача: добавить управление стрелками в Pygame
При этом мяч должен передвигаться в сторону, соответствующую направлению нажатой стрелки на клавиатуре. Если нажаты 2 стрелки, например, вверх и вправо, то объект должен двигаться по диагонали в правую верхнюю часть экрана. Мы реализуем 2 варианта перемещения объекта: в первом случае мяч будет двигаться, пока зажата стрелка. Во втором случае длительность нажатия не будет иметь значения. Даже если пользователь будет долго держать кнопку нажатой, мяч все равно не сдвинется дальше значения, указанного в переменной speed. Так как общий принцип работы у обоих вариантов одинаков, и более того — второй вариант является дополненной версией первого, предлагаю приступать к написанию универсального кода прямо сейчас! А изменения в код для превращения первого варианта во второй внесем в заключительном этапе статьи. Итак. поехали!
1. Объявляем новые переменные
- Нам понадобится переменная speed для определения расстояния, на которое будет смещаться объект при единичном нажатии стрелок: speed = 20
- Кроме того, определим переменные возможных направлений движения мяча (to_left, to_right, to_up, to_down). В этих переменных будем хранить булевы значения: True или False. Если, например, значение переменной go_right станет равно True, это послужит сигналом для смещения мяча вправо. Однако, до запуска игрового цикла присвоим всем этим переменным значение False:
Результат реализации первого пункта — объявлены новые переменные в коде (смотрите подсвеченные строки):
2. Пишем код для обработки событий
Пояснения по коду:
Для начала предлагаю рассмотреть существующий цикл отслеживания событий for event in pygame.event.get(). С помощью выражения pygame.event.get() мы получаем список всех событий, которые совершает пользователь при помощи клавиатуры или мыши. После получения списка событий мы последовательно присваиваем каждый объект события переменной event в цикле for. Это же как раз то, что нам нужно! Ведь мы стремимся отследить нажатие стрелок на клавиатуре. И сделать это довольно просто, зная тип объекта event. Мы просто будем сравнивать event.type с pygame.KEYDOWN и с pygame.KEYUP.
1) Сравниваем event.type с pygame.KEYDOWN
Если какая-либо клавиша на клавиатуре нажата, то есть выполняется условие if event.type == pygame.KEYDOWN, то мы можем с помощью атрибута key события event узнать вид нажатой клавиши. Например, если нажата стрелка влево, и выполняется условие event.key == pygame.K_LEFT, то переменной to_left можно присвоить значение True: to_left = True.
Аналогичным образом проверяем клавиши по оставшимся трем направлениям (вверх, вниз и вправо) и, при необходимости, определяем соответствующие переменные to_up, to_down, to_right как True.
2) Сравниваем event.type с pygame.KEYUP
После этого выясним, были ли отпущены какие-либо клавиши. Если выполняется условие event.type==pygame.KEYUP, это значит, что пользователь перестал нажимать какую-либо из клавиш. Осталось лишь с помощью атрибута key события event узнать вид отпущенной клавиши, и если эта клавиша — одна из отслеживаемых нами стрелок, то присвоить соответствующей переменной to_up, to_down, to_right или to_left значение False.
3. Меняем значения координат
На предыдущем шаге мы выяснили, в какую сторону должен смещаться объект. Теперь мы выйдем из цикла обработки событий и зададим смещение координатам ballX и ballY в зависимости от значений переменных направления to_up, to_down, to_left и to_right. Так как в Pygame точка начала координат располагается в левом верхнем углу поля, то для смещения объекта вверх нужно уменьшить ballY на заданную скорость в переменной speed, а для перемещения мяча вправо — увеличить ballX на speed. Добавленные на этом этапе строки выделены подсветкой:
Итоговый код (вариант 1) — управление стрелками в Pygame (объект движется, пока нажата стрелка)
Небольшое видео управления мячом — мяч реагирует на долгие и короткие нажатия стрелок:
Заключительный этап, или рассматриваем второй вариант.
После изменения значений координат, наш код можно считать завершенным: объект движется в нужном направлении при нажатии стрелок и совершает остановку при возвращении стрелки в неактивное состояние. Работа программы соответствует первому варианту, о котором было написано в начале статьи. Однако, бывают ситуации в которых необходимо игнорировать длительность нажатия клавиши и совершать короткие шажки при каждом нажатии стрелки. Для этого нужно внести небольшие дополнения в итоговый код — после каждого изменения значения координат ballX или ballY мы будем сбрасывать значение соответствующей переменной направления (to_up, to_down, to_left и to_right) в False. Ниже приведен код для второго варианта передвижения персонажа:
Итоговый код (вариант 2) Управление стрелками в Pygame (один шаг за одно нажатие стрелки)
Небольшое видео управления мячом — мяч двигается в разные стороны короткими шагами:
Читайте также: