Pygame display flip что это
Перейти к содержимому

Pygame display flip что это

  • автор:

Обработка ввода и анимации¶

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

Мы с вами уже знакомы с методом получения всех произошедших событий — pygame.event.get() , который возвращает события, произошедшие с последнего обращения.

Помимо событий выхода из приложения pygame.QUIT , есть множество других — например, нажатия клавиш pygame.KEYDOWN или отпускания pygame.KEYUP .

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

import sys import pygame pygame.init() screen = pygame.display.set_mode((640, 480)) rect = pygame.Rect(40, 40, 120, 120) color = (0, 0, 0) while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: color = (255, 255, 255) pygame.draw.rect(screen, color, rect, 0) pygame.display.flip() 

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

При нажатии клавиш

При отпускании клавиш

При нажатии кнопки закрытия программы

При движении мыши

Обработка нажатий клавиш¶

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

  1. pygame.event.get()
  2. pygame.key.get_pressed()

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

keys = pygame.key.get_pressed() if keys[pygame.K_RETURN]: print("Нажата клавиша enter") 

Перемещение объектов¶

Умея получать от пользователя ввод, мы можем реализовать движения наших фигур на экране:

import sys import pygame pygame.init() screen = pygame.display.set_mode((640, 480)) rect = pygame.Rect(40, 40, 120, 120) while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: rect.move_ip(-40, 0) elif event.key == pygame.K_RIGHT: rect.move_ip(40, 0) elif event.key == pygame.K_UP: rect.move_ip(0, -40) elif event.key == pygame.K_DOWN: rect.move_ip(0, 40) pygame.draw.rect(screen, (255, 0, 0), rect, 0) pygame.display.flip() 

Для движения объектов используются методы move() и move_ip() , которыми обладают объекты, созданные с помощью функций из pygame.draw . Первый создаёт новую фигуру такого же типа, находящуюся по заданному смещению, второй непосредственно изменяет положение имеющейся фигуры.

Запустив данный код, вы можете заметить, что при перемещении фигуры от неё остаётся “след”. Это связано с тем, что при перемещении объекта, мы его не перемещаем на экране, а рисуем на новом месте поверх старого кадра.

Чтобы избежать данной проблемы, надо добавить вызов метода fill() у нашего экрана, на котором мы рисуем и передать ему цвет, которым надо закрасить фон. Данное действие надо проводить каждый раз перед отрисовкой кадра:

# здесь могла быть ваша проверка событий screen.fill((0, 0, 0)) pygame.draw.rect(screen, (255, 0, 0), rect, 0) pygame.display.flip() 

Использование спрайтов¶

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

pygame.image. load ( path ) ¶

Функция для загрузки спрайта из картинки. Path — путь до изображения, возвращает объект типа Surface, который можно использовать для рисования.

Для отрисовки спрайта на экране надо вызвать метод blit() у поверхности на которой производится отрисовка и передать объект спрайта вместе с координатами на которых необходимо отрисовать:

screen = pygame.display.set_mode((640, 480)) sprite = pygame.image.load("sprite.png") screen.blit(sprite, (20, 20)) pygame.quit() 

Анимации¶

В pygame анимации создаются при помощи набора спрайтов, которые последовательно отрисовываются:

animation_set = [pygame.image.load(f"ri>.png") for i in range(1, 6)] window = pygame.display.set_mode((640, 480)) clock = pygame.time.Clock() i = 0 while True: for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() window.fill((0,0,0)) window.blit(animation_set[i // 12], (100, 20)) i += 1 if i == 60: i = 0 pygame.display.flip() clock.tick(60) 

Создаём список спрайтов, каждый из которых будет отдельным кадром анимации:

animation_set = [pygame.image.load(f"ri>.png") for i in range(1, 6)] 

Создаём часы, для ограничения количества кадров в секунду:

clock = pygame.time.Clock() 

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

i = 0 

Выбор анимации в зависимости от номера кадра и его отрисовка:

window.blit(animation_set[i // 12], (100, 20)) 

Изменение переменной, помогающей выбрать нужный кадр:

i += 1 if i == 60: i = 0 

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

clock.tick(60) 

Задания¶

  1. Написать программу, которая будет писать в консоль названия нажатых клавиш. Реализовать поддержку enter, space, w, a, s, d, esc.
  2. С помощью циклов, используя квадрат 10х10 пикселей и его след, нарисовать рамку 100х100 пикселей.
  3. Написать программу, в которой по нажатию клавиш будет двигаться квадрат размером 20х20 пикселей. Учесть, что квадрат не должен выходить за границы экрана.
  4. Доработать программу, чтобы квадрат при каждом движении менял свой цвет на случайный.
  5. Реализовать анимацию движения персонажа. При движении влево или вправо должны показываться соответствующие анимации. Кадры для них взять из архива animations.zip

© Copyright Revision d00c0df4 .

Built with Sphinx using a theme provided by Read the Docs.
Read the Docs v: latest

Versions latest Downloads html On Read the Docs Project Home Builds Free document hosting provided by Read the Docs.

Каркас игры на Pygame

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

Эти команды (импорт модуля, вызовы функций, цикл) создают своего рода скелет, или каркас, программного кода. Выполнив его, вы получите «пустую» игру. Далее на этот скелет «подвешивается мясо», т. е. объявляются объекты и программируется логика игры.

Первое, что нужно сделать, это импортировать модуль pygame . После этого можно вывести на экран главное графическое окно игры с помощью функции set_mode модуля display , входящего в состав библиотеки pygame:

import pygame pygame.display.set_mode((600, 400))

Если выполнить этот код, то появится окно размером 600×400 пикселей и сразу закроется (в Linux, в Windows может зависнуть).

Функция set_mode принимает несколько аргументов – размер в виде кортежа или списка из двух целых чисел, флаги, глубину цвета и др. Их можно не указывать. В этом случае окно займет весь экран, цветовая глубина будет соответствовать системной. Обычно указывают только первый аргумент – размер окна.

Флаги предназначены для переключения на аппаратное ускорение, полноэкранный режим, отключения рамки окна и др. Например, команда pygame.display.set_mode((640, 560), pygame.RESIZABLE) делает окно изменяемым в размерах.

Выражение вида pygame.RESIZABLE (вместо RESIZABLE может быть любое другое слово большими буквами) обозначает обращение к той или иной константе, определенной в модуле pygame . Часто можно встретить код, в котором перед константами не пишется имя модуля (вместо, например, pygame.QUIT пишут просто QUIT ). В этом случае в начале программы надо импортировать не только pygame , но и содержимое модуля locals через from … import :

import pygame from pygame.locals 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.display.set_mode(flags=pygame.FULLSCREEN | pygame.OPENGL | pygame.DOUBLEBUF)

Вернемся к нашим двум строчкам кода, где мы импортируем pygame создаем главное окно размером 600×400 пикселей. Почему окно сразу закрывается? Очевидно потому, что программа заканчивается после выполнения этих выражений. Ни импорт библиотеки, ни вызов set_mode() не предполагают входа в «режим циклического ожидания событий». В tkinter для этого используется метод mainloop() экземпляра Tk() . В pygame же требуется собственноручно создать бесконечный цикл, заставляющий программу зависнуть. Основная причина в том, что только программист знает, какая часть его кода должна циклически обрабатываться, а какая – нет. Например, код, создающий классы, объекты и функции не помещают в цикл.

Итак, создадим в программе бесконечный цикл:

# Осторожно! Эта программа зависнет. import pygame as pg pg.display.set_mode((600, 400)) while 1: pass 

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

Как сделать так, чтобы программа закрывалась при клике на крестик окна, а также при нажатии Alt + F4 ? Pygame должен воспринимать такие действия как определенный тип событий.

Добавим в цикл магии:

# Окно закроется, но с ошибкой. import pygame as pg pg.display.set_mode((600, 400)) while 1: for i in pg.event.get(): if i.type == pg.QUIT: pg.quit()

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

Рассмотрим выражение pygame.event.get() . Модуль event библиотеки pygame содержит функцию get , которая забирает список событий из очереди, в которую записываются все произошедшие события. То, что возвращает get() – это список. Забранные события удаляются из очереди, то есть второй раз они уже забираться не будут, а в очередь продолжают записываться новые события.

Цикл for просто перебирает схваченный на данный момент (в текущей итерации цикла) список событий. Каждое событие он присваивает переменной i или любой другой. Чтобы было понятней, перепишем программу таким образом:

# Окно закроется, но с ошибкой. import pygame as pg pg.display.set_mode((600, 400)) while 1: events = pg.event.get() print(events) for i in events: if i.type == pg.QUIT: print(pg.QUIT) print(i) print(i.type) pg.quit()

На экране вы увидите примерно такое:

… [] [)>, )>] 256 )> 256 Traceback (most recent call last): File "ex3_event2.py", line 7, in events = pg.event.get() pygame.error: video system not initialized

Вверху будет множество пустых квадратных скобок, которые соответствуют пустым спискам 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 . В этом случае код выглядит примерно так:

import pygame as pg import sys pg.display.set_mode((600, 400)) while 1: for i in pg.event.get(): if i.type == pg.QUIT: pg.quit() sys.exit()

Сначала отключается pygame , потом происходит выход из программы. Такой вариант вероятно следует считать наиболее безопасным завершением. Команда pygame.quit() не обязательна. Если завершается программа, то отключится и pygame .

Другой вариант – не допустить следующей итерации цикла. Для этого потребуется дополнительная переменная:

import pygame as pg pg.display.set_mode((600, 400)) play = True while play: for i in pg.event.get(): if i.type == pg.QUIT: play = False

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

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

import pygame as pg def main(): pg.display.set_mode((600, 400)) while True: for i in pg.event.get(): if i.type == pg.QUIT: return if __name__ == "__main__": main()

Теперь зададимся вопросом, с какой скоростью крутится цикл while ? С большой, зависящей от мощности компьютера. Но в данном случае такая скорость не есть необходимость, она даже вредна, так как бессмысленно расходует ресурсы. Человек дает команды и воспринимает изменения куда медленнее.

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

Поэтому в главном цикле следует выполнять задержку. Делают это либо вызовом функции delay() модуля time библиотеки pygame, либо создают объект часов и устанавливают ему частоту кадров. Первый способ проще, второй – более профессиональный.

. while 1: for i in pg.event.get(): if i.type == pg.QUIT: sys.exit() pg.time.delay(20)

Функция delay() принимает количество миллисекунд (1000 мс = 1 с). Если передано значение 20, то за секунду экран обновится 50 раз. Другими словами, частота составит 50 кадров в секунду.

import pygame as pg import sys pg.display.set_mode((600, 400)) clock = pg.time.Clock() while 1: for i in pg.event.get(): if i.type == pg.QUIT: sys.exit() clock.tick(60)

Методу tick() класса Clock передается непосредственно желаемое количество кадров в секунду. Задержку он вычисляет сам. То есть если внутри цикла указано tick(60) – это не значит, что задержка будет 60 миллисекунд или произойдет 60 обновлений экрана за одну итерацию цикла. Это значит, что на каждой итерации цикла секунда делится на 60 и уже на вычисленную величину выполняется задержка.

Нередко частоту кадров выносят в отдельную константоподобную переменную:

. FPS = 60 . clock = pg.time.Clock() while 1: . clock.tick(FPS)

В начало цикла или конец вставлять задержку зависит от контекста. Если до цикла происходит отображение каких-либо объектов на экране, то скорее всего надо вставлять в начало цикла. Если первое появление объектов на экране происходит внутри цикла, то в конец.

В итоге каркас игры на Pygame должен выглядеть примерно так:

# здесь подключаются модули import pygame import sys # здесь определяются константы, # классы и функции FPS = 60 # здесь происходит инициация, # создание объектов pygame.init() pygame.display.set_mode((600, 400)) clock = pygame.time.Clock() # если надо до цикла отобразить # какие-то объекты, обновляем экран pygame.display.update() # главный цикл while True: # задержка clock.tick(FPS) # цикл обработки событий for i in pygame.event.get(): if i.type == pygame.QUIT: sys.exit() # -------- # изменение объектов # -------- # обновление экрана pygame.display.update()

Функция pygame.init() необходима для инициации всех модулей библиотеки pygame. Для инициации только функций модуля pygame.display следует вызывать pygame.display.init() . Однако функция pygame.display.set_mod() , помимо того что создает главную поверхность, также выполняет инициацию модуля display . Поэтому если set_mod() вызывается до вызова других объектов этого модуля, то вызов init() не является обязательным.

Практическая работа

В модуле pygame.display есть функция set_caption() . Ей передается строка, которую она устанавливает в качестве заголовка окна. Сделайте так, чтобы каждую секунду заголовок окна изменялся.

Курс с примерами решений практических работ:
pdf-версия

X Скрыть Наверх

Pygame. Введение в разработку игр на Python

Pygame/Pygame.display()

pygame.display() — модуль, использующийся для управления окном игры и экраном.

Описание [ ]

Модуль pygame.display() используется для управления окном игры и экраном.

Методы [ ]

  • pygame.display.init() — инициализирует модуль Pygame;
  • pygame.display.quit() — деинициализирует модуль Pygame;
  • pygame.display.get_init() — возвращает True, если модуль Pygame был инициализирован
  • pygame.display.set_mode((x,y),flag) — задает размеры и параметры окна
  • pygame.display.update() — обновляет окно

Материалы сообщества доступны в соответствии с условиями лицензии CC-BY-SA, если не указано иное.

Дополнительные главы

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

Основной цикл

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

import sys import pygame # Инициализация pygame pygame.init() # Размер окна screen = pygame.display.set_mode((300, 300)) # Заголовок окна pygame.display.set_caption('Blue Circle') while True: # Задаем цвет фона screen.fill((255, 255, 224)) # Рисуем круг pygame.draw.circle(screen, (50, 50, 200), (150, 150), 75) # Обновляем экран pygame.display.flip() for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() 

Функция pygame.draw.circle принимает следующие аргументы:

  • surface — объект типа Surface — поверхность, на которой будет отрисован круг. В данном случае это основное окно программы.
  • color — кортеж из трех целых чисел или объект типа Color — цвет фигуры в представлении RGB.
  • center — кортеж из двух целых чисел — координаты центра круга в пикселях. Координаты отсчитываются от левого верхнего угла.
  • radius — радиус круга в пикселях.
  • width — ширина кольца в пикселях — необязательный параметр. Если параметр задан, то будет нарисовано кольцо, а не круг.

Функция pygame.draw.circle возвращает объект Rect — прямоугольник, содержащий нарисованный объект. Это нам еще пригодится, когда мы будем организовывать взаимодействие с кругом.

pygame1

Вывод текста

За работу с текстом в pygame отвечает модуль font. Перед его использованием необходимо выполнить инициализацию

pygame.font.init() 

Функция pygame.font.SysFont создает объект типа Font , который может отрисовывать текст:

font = pygame.font.SysFont(name=font, size=20) surf = font.render( 'Click on the circle', antialias=True, color=(0, 0, 0)) screen.blit(surf, (70, 260)) 

Функция render создает объект типа Surface с отрисованным текстом. Параметр antialias управляет сглаживанием текста.

Метод Surface.blit отрисовывает одну поверхность на другой. Мы ей воспользовались чтобы отрисовать поверхность с текстом в основном окне. В результате получаем следующее:

pygame2

Обработка событий

Сделаем так, чтобы круг менял цвет при нажатии на него мышкой:

def get_color(): idx = 0 colors = [ (50, 50, 200), (50, 200, 50), (200, 50, 50) ] while True: yield colors[idx % len(colors)] idx += 1 colors = get_color() color = next(colors) while True: # . circ_rect = pygame.draw.circle(screen, color, (150, 150), 75) for event in pygame.event.get(): # . if event.type == pygame.MOUSEBUTTONDOWN: if circ_rect.collidepoint(event.pos): color = next(colors) 

Атрибут pos возвращает координаты нажатия курсора, метод Rect.collidepoint возвращает True , если координаты лежат внутри прямоугольника.

Графические примитивы и маски

Модуль pygame.draw содержит инструменты для отрисовки различных графических примитивов:

  • pygame.draw.polygon(surface, color, pointlist, width)
  • pygame.draw.line(surface, color, start_point, end_point, width)
  • pygame.draw.lines(surface, color, closed, pointlist, width)
  • pygame.draw.circle(surface, color, center_point, radius, width)
  • pygame.draw.ellipse(surface, color, bounding_rectangle, width)
  • pygame.draw.rect(surface, color, rectangle_tuple, width)

В текущем виде программа реагирует на нажатие мышки внутри квадрата, описанного вокруг круга. Для проверки попадания координаты внутрь круга можно использовать инструменты модуля pygame.mask :

while True: # . circ_surf = pygame.Surface((150, 150), pygame.SRCALPHA, 32)\ .convert_alpha() circ_rect = pygame.draw.circle(circ_surf, color, (75, 75), 75) screen.blit(circ_surf, (75, 75)) circ_mask = pygame.mask.from_surface(circ_surf) for event in pygame.event.get(): # . if event.type == pygame.MOUSEBUTTONDOWN: rpos = (event.pos[0] - 75, event.pos[1] - 75) if circ_rect.collidepoint(rpos) and\ circ_mask.get_at(rpos): color = next(colors) 

Сначала мы создали прозрачную поверхность, на которой нарисовали круг. Затем на основе этой поверхности создали битовую маску, соответствующую пикселям поверхности. Маска выделяет все непрозрачные пиксели поверхности. При проверке попадания координаты внутрь круга используется метод mask.get_at , возвращающий значение маски в заданной позиции. Поскольку круг нарисован на поверхности circ_surf , а не в главной поверхности, то проверка положения выполняется в локальных координатах на поверхности circ_surf .

Работа с растровыми файлами

Модуль pygame.image позволяет открывать изображение из файла и сохранять поверхности (объекты типа Surface ) в файл. Поместим логотип pygame в наше окно:

logo_surf = pygame.image.load('figs/logo_lofi.png') screen.blit(logo_surf, (60, 10)) 

В результате получаем:

pygame_logo

Чтобы сохранить содержимое поверхности в файл, нужно вызвать

pygame.image.save(screen, 'screen.png') 

Частота обновления

Наш учебный пример не содержит двигающихся объектов, поэтому нет никакой разницы, с какой частотой выполняется основной цикл. Ситуация меняется, если в программе есть анимация. В этом случае скорость движения прямо зависит от скорости работы цикла. Модуль pygame.time содержит инструменты для работы со временем. Например, класс pygame.time.Clock позволяет ограничить количество обновлений в секунду:

frames_per_second = 30 clock = pygame.time.Clock() while True: # . clock.tick(frames_per_second) 

Другой вариант — функция pygame.time.wait , которая выполняет задержку на определенное количество миллисекунд. Заметим, что использовать задержку имеет смысл даже в нашем примере. Действительно, достаточно малая задержка не будет видна пользователю, но позволит значительно уменьшить нагрузку на процессор. Полный код нашего примера выглядит так:

import sys import pygame # Инициализация pygame pygame.init() pygame.font.init() # Размер окна screen = pygame.display.set_mode((300, 300)) # Заголовок окна pygame.display.set_caption("Blue Circle") font = pygame.font.SysFont(name='arial', size=20) def get_color(): idx = 0 colors = [ (50, 50, 200), (50, 200, 50), (200, 50, 50) ] while True: yield colors[idx % len(colors)] idx += 1 text = 'Click on the circle' colors = get_color() color = next(colors) logo_surf = pygame.image.load('figs/logo_lofi.png') delay = 100 while True: # Задаем цвет фона screen.fill((255, 255, 224)) # Рисуем круг circ_surf = pygame.Surface((150, 150), pygame.SRCALPHA, 32)\ .convert_alpha() circ_rect = pygame.draw.circle(circ_surf, color, (75, 75), 75) screen.blit(circ_surf, (75, 75)) circ_mask = pygame.mask.from_surface(circ_surf) # Рисуем текст font_surf = font.render(text, True, (0, 0, 0)) screen.blit(font_surf, (70, 260)) # Рисуем лого pygame screen.blit(logo_surf, (60, 10)) # Обновляем экран pygame.display.flip() for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() elif event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: pygame.quit() sys.exit() elif event.type == pygame.MOUSEBUTTONDOWN: rpos = (event.pos[0] - 75, event.pos[1] - 75) if circ_rect.collidepoint(rpos) and\ circ_mask.get_at(rpos): color = next(colors) pygame.time.wait(delay) 

Резюме

В этом разделе мы обсудили основные инструменты библиотеки pygame.

Источники

  • Документация pygame
  • PyGame: A Primer on Game Programming in Python
  • Python pygame – The Full Tutorial
  • Game loop
  • Game Loop pattern
  • dr0id pygame tutorials

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

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