Pygame документация на русском: Как писать игры на Python с Pygame. Введение ~ PythonRu

Содержание

Как писать игры на Python с Pygame. Введение ~ PythonRu

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

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

Что такое Pygame?

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

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

Игровой цикл

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

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

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

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

  1. Обновление игры

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

  1. Рендеринг (прорисовка)

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

Время

Подписывайтесь на телеграм каналы

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

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

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

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

Каждый из трех основных цветов может иметь значение от 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. Работа со спрайтами

Библиотека PyGame

Основные модули пакета Pygame

Модуль Назначение
pygame.cdrom Доступ к CD-приводам и управление ими
pygame.cursors Загружает изображения курсора
pygame.display Доступ к дисплею
pygame.draw Рисует фигуры, линии и точки
pygame.event Управление внешними событиями
pygame.font Использует системные шрифты
pygame.image Загружает и сохраняет изображение
pygame.joystick Использует джойстики и аналогичные устройства
pygame.key Считывает нажатия клавиш с клавиатуры
pygame.mixer Загружает и воспроизводит мелодии
pygame.mouse Управляет мышью
pygame.movie Воспроизведение видеофайлов
pygame.music Работает с музыкой и потоковым аудио
pygame.overlay
Доступ к расширенным видеоизображениям
pygame Содержит функции Pygame высокого уровня
pygame.rect Управляет прямоугольными областями
pygame.sndarray Манипулирует звуковыми данными
pygame.sprite Управление движущимися изображениями
pygame.surface Управляет изображениями и экраном
pygame.surfarray Манипулирует данными пикселей изображения
pygame.time модуль pygame для управления временем и частотой кадров
pygame.transform Изменение размера и перемещение изображений

Окно PyGame

Подключение библиотеки PyGame

import pygame

Инициализация PyGame

pygame.init()

Окно игры: размер, позиция

gameScreen = pygame.display.set_mode((400, 300))

модуль os — позиция окна

import os

x = 100

y = 100

os.environ[‘Sp_VIDEO_WINDOW_POS’] = «%d,%d» % (x,y)

параметры окна

size = [500, 500]

screen = pygame.display.set_mode(size)

pygame.display.set_caption(«Test drawings»)

gameScreen.fill((0,0,255))

pygame.display.flip()

Цикл игры, выход из игры

Цикл игры

runGame = True # флаг выходв из цикла игры

while runGame:

Отслеживание события: «закрыть окно»

for event in pygame.event.get():

if event.type == pygame.QUIT: runGame = False

Выход из игры: pygame.quit()

Рисование базовых элементов

pygame.draw

модуль pygame для рисования фигур

pygame.draw.rect нарисовать прямоугольную форму
pygame.draw.polygon фигуру с любым количеством сторон
pygame.draw.circle круг вокруг точки
pygame.draw.ellipse нарисовать круглую форму внутри прямоугольника
pygame.draw.arc нарисовать секцию эллипса
pygame.draw.line нарисовать сегмент прямой линии
pygame.draw.lines для рисования нескольких смежных отрезков
pygame.draw.aaline рисовать тонкую линию
pygame.draw.aalines нарисовать связанную последовательность сглаженных линий

rect(Surface, color, Rect, wiph=0) -> Rect
polygon(Surface, color, pointlist, wiph=0) -> Rect
circle(Surface, color, pos, radius, wiph=0) -> Rect
ellipse(Surface, color, Rect, wiph=0) -> Rect
arc(Surface, color, Rect, start_angle, stop_angle, wiph=1) -> Rect
line(Surface, color, start_pos, end_pos, wiph=1) -> Rect
lines(Surface, color, closed, pointlist, wiph=1) -> Rect
aaline(Surface, color, startpos, endpos, blend=1) -> Rect
aalines(Surface, color, closed, pointlist, blend=1) -> Rect

Загрузка изображения

Модуль pygame.image позволяет загрузить изображерие из файла и возвращает объект типа Surface.

pygame.image.load(«путь к файлу» )

загрузить новое изображение из файла

load(filename) -> Surface

Загрузить изображение (путь к файлу для Windows)

myImage = pygame.image.load(‘images\\bg1.jpg’)

определить место размещения

myRect = (0,0,600,400)

выгрузить объект Surface, который содержит загруженное из файла изображение (myImage), в описанное место на экране (myRect)

screen.blit(myImage,myRect)

Объект Rect

pygame.Rect

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

Rect(left, top, wiph, height) -> Rect

Rect((left, top), (wiph, height)) -> Rect

Rect(object) -> Rect

Методы работы с Rect

pygame.Rect.copy Возвращает новый прямоугольник, имеющий ту же позицию и размер, что и оригинал.
pygame.Rect.move Возвращает новый прямоугольник, перемещаемый данным смещением. Аргументы x и y могут быть любым целочисленным значением, положительным или отрицательным.
pygame.Rect.move_ip То же, что и метод Rect.move (), но работает на месте.
pygame.Rect.inflate увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.inflate_ip увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.clamp перемещает прямоугольник внутри другого
pygame.Rect.clamp_ip перемещает прямоугольник внутри другого, на месте
pygame.Rect.clip обрезает прямоугольник внутри другого
pygame.Rect.union соединяет два прямоугольника в один
pygame.Rect.union_ip соединяет два прямоугольника в один, на месте
pygame.Rect.unionall объединение многих прямоугольников
pygame.Rect.unionall_ip объединение многих прямоугольников, на месте
pygame.Rect.fit изменить размер и переместить прямоугольник учмиывая соотношение сторон
pygame.Rect.normalize корректировать отрицательные размеры
pygame.Rect.contains проверить, находится ли один прямоугольник внутри другого
pygame.Rect.collidepoint проверить, находится ли точка внутри прямоугольника
pygame.Rect.colliderect тест, пересекаются ли два прямоугольника
pygame.Rect.collidelist проверить, пересекается ли хоть один прямоугольник в списке
pygame.Rect.collidelistall пересекаются ли все прямоугольники в списке
pygame.Rect.collidedict проверить, если один прямоугольник в словаре пересекается
pygame.Rect.collidedictall пересекаются ли все прямоугольники в словаре

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

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

Функция get в модуле pygame.event возвращает последнее событие, ожидающее в очереди и удаляет его из очереди.

Объект event

Модуль pygame.event

модуль для обработки очереди событий

pygame.event.pump Если вы не используете другие функции событий в своей игре, вы должны вызвать pygame.event.pump (), чтобы позволить pygame обрабатывать внутренние действия
pygame.event.get получает события из очереди
pygame.event.poll получить одно событие из очереди
pygame.event.wait ждёт одиночного события из очереди
pygame.event.peek проверить, ждут ли очереди события определённого типа
pygame.event.clear удалить все события из очереди
pygame.event.event_name возвращает имя для типа события. Строка находится в стиле WordCap
pygame.event.set_blocked проверяет, какие события не разрешены в очереди
pygame.event.set_allowed проверяет, какие события разрешены в очереди
pygame.event.get_blocked проверить, заблокирован ли тип события из очереди
pygame.event.set_grab проверяет совместное использование устройств ввода с другими приложениями
pygame.event.get_grab проверить, работает ли программа на устройствах ввода данных
pygame.event.post поместить новое событие в очередь
pygame.event.Event создать новый объект события
pygame.event.EventType Объект Python, представляющий событие SDL. Экземпляры пользовательских событий создаются с вызовом функции Event. Тип EventType не может быть напрямую вызван. Экземпляры EventType поддерживают назначение и удаление атрибутов.

Pygame отслеживает все сообщения о событиях через очередь событий. Процедуры в этом модуле помогают управлять этой очередью событий. Входная очередь сильно зависит от модуля отображения (display) pygame. Если дисплей не был инициализирован и видеорежим не установлен, очередь событий не будет работать.

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

Мышь

Модуль pygame.mouse

модуль pygame для работы с мышью

pygame.mouse.get_pressed получить состояние кнопок мыши
pygame.mouse.get_pos получить позицию курсора мыши
pygame.mouse.get_rel получить количество движений мыши
pygame.mouse.set_pos установить позицию курсора мыши
pygame.mouse.set_visible скрыть или показать курсор мыши
pygame.mouse.get_focused проверяет, принимает ли дисплей ввод мыши
pygame.mouse.set_cursor установить изображение для курсора мыши
pygame.mouse.get_cursor получить изображение для курсора мыши

Функции мыши можно использовать для получения текущего состояния устройства мышь. Эти функции также могут изменять курсор мыши.

Когда режим отображения (display) установлен, очередь событий начнет принимать события мыши. Кнопки мыши генерируют события pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP, когда они нажимаются и отпускаются. Эти события содержат атрибут кнопки, указывающий, какая кнопка была нажата. Колесо мыши будет генерировать pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP события при прокрутке.

Когда колесо повернуто вверх, кнопка будет установлена на 4, вниз -5. Всякий раз, когда мышь перемещается, генерируется событие pygame.MOUSEMOTION. Движение мыши разбито на небольшие и точные события движения. По мере перемещения мыши многие события движения будут помещены в очередь. События движения мыши, которые неправильно очищены от очереди событий, являются основной причиной того, что очередь событий заполняется.

Пример. Нарисовать курсор под текущей позицией мыши.

x, y = pygame.mouse.get_pos()
x -= mouse_cursor.get_width()/2
y -= mouse_cursor.get_height()/2
screen.blit(mouse_cursor, (x, y))

Определить какая кнопка была нажата на мышке можно используя значение event.button:

1 — left click
2 — middle click
3 — right click
4 — scroll up
5 — scroll down

Координаты курсора при нажатии кнопки мыши находятся в event.pos.

Пример. Перемещать картинку курсором мыши.

import pygame, sys, time from pygame.locals import * pygame.init() FPS=30 fpsClock=pygame.time.Clock() width=500 height=500 mainSurface=pygame.display.set_mode((width,height),0,32) pygame.display.set_caption(‘Keyb moves’) background=pygame.image.load(‘images//bg1.jpg’) sprite=pygame.image.load(‘images//pict2.gif’) # Place image to the center of mainSurface image_pos = ((mainSurface.get_width() — sprite.get_width())/2, (mainSurface.get_height() — sprite.get_height())/2) doMove = False # game loop while True: fpsClock.tick(FPS) # frame rate mainSurface.blit(background,(0,0)) # get all events from the queue for event in pygame.event.get(): # loop events queue if event.type == QUIT: # window close X pressed pygame.quit() sys.exit() if event.type == KEYDOWN and event.key == K_ESCAPE: # ESC key pressed pygame.quit() sys.exit() if event.type == pygame.MOUSEBUTTONDOWN: if event.button == 1: # левая кнопка мыши doMove = True if event.button == 3: # правая кнопка мыши image_pos = ((mainSurface.get_width() — sprite.get_width())/2, (mainSurface.get_height() — sprite.get_height())/2) doMove = False if event.type == pygame.MOUSEBUTTONUP: doMove = False if event.type == MOUSEMOTION and doMove: image_pos = event.pos mainSurface.blit(sprite,image_pos) pygame.display.update()

Клавиатура

Модуль pygame.key

Этот модуль содержит функции для работы с клавиатурой.Очередь событий получает события pygame.KEYDOWN и pygame.KEYUP при нажатии и отпускании клавиш клавиатуры.

Оба события имеют ключевой атрибут, который представляет собой целочисленный идентификатор, представляющий каждую клавишу на клавиатуре.Событие pygame.KEYDOWN имеет дополнительные атрибуты: unicode и scancode. unicode представляет собой одну символьную строку, которая соответствует введённому символу. Scancode представляет собой код для конкретной платформы.

Получить код клавиши:

pressed_keys = pygame.key.get_pressed()
if pressed_keys[K_SPACE]:
# Space key has been pressed
fire()

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

KeyASCIIASCIICommonName
K_BACKSPACE\bbackspace
K_TAB\ttab
K_CLEARclear
K_RETURN\rreturn
K_PAUSEpause
K_ESCAPE^[escape
K_SPACEspace
K_EXCLAIM!exclaim
K_QUOTEDBL«quotedbl
K_HASH#hash
K_DOLLAR$dollar
K_AMPERSAND&ampersand
K_QUOTEquote
K_LEFTPAREN(leftparenthesis
K_RIGHTPAREN)rightparenthesis
K_ASTERISK*asterisk
K_PLUS+plussign
K_COMMA,comma
K_MINUSminussign
K_PERIOD.period
K_SLASH/forwardslash
K_000
K_111
K_222
K_333
K_444
K_555
K_666
K_777
K_888
K_999
K_COLON:colon
K_SEMICOLON;semicolon
K_LESSless-thansign
K_EQUALS=equalssign
K_GREATER>greater-thansign
K_QUESTION?questionmark
K_AT@at
K_LEFTBRACKET[leftbracket
K_BACKSLASH\backslash
K_RIGHTBRACKET]rightbracket
K_CARET^caret
K_UNDERSCORE_underscore
K_BACKQUOTE`grave
K_aaa
K_bbb
K_ccc
K_ddd
K_eee
K_fff
K_ggg
K_hhh
K_iii
K_jjj
K_kkk
K_lll
K_mmm
K_nnn
K_ooo
K_ppp
K_qqq
K_rrr
K_sss
K_ttt
K_uuu
K_vvv
K_www
K_xxx
K_yyy
K_zzz
K_DELETEdelete
K_KP0keypad0
K_KP1keypad1
K_KP2keypad2
K_KP3keypad3
K_KP4keypad4
K_KP5keypad5
K_KP6keypad6
K_KP7keypad7
K_KP8keypad8
K_KP9keypad9
K_KP_PERIOD.keypadperiod
K_KP_DIVIDE/keypaddivide
K_KP_MULTIPLY*keypadmultiply
K_KP_MINUSkeypadminus
K_KP_PLUS+keypadplus
K_KP_ENTER\rkeypadenter
K_KP_EQUALS=keypadequals
K_UPuparrow
K_DOWNdownarrow
K_RIGHTrightarrow
K_LEFTleftarrow
K_INSERTinsert
K_HOMEhome
K_ENDend
K_PAGEUPpageup
K_PAGEDOWNpagedown
K_F1F1
K_F2F2
K_F3F3
K_F4F4
K_F5F5
K_F6F6
K_F7F7
K_F8F8
K_F9F9
K_F10F10
K_F11F11
K_F12F12
K_F13F13
K_F14F14
K_F15F15
K_NUMLOCKnumlock
K_CAPSLOCKcapslock
K_SCROLLOCKscrollock
K_RSHIFTrightshift
K_LSHIFTleftshift
K_RCTRLrightcontrol
K_LCTRLleftcontrol
K_RALTrightalt
K_LALTleftalt
K_RMETArightmeta
K_LMETAleftmeta
K_LSUPERleftWindowskey
K_RSUPERrightWindowskey
K_MODEmodeshift
K_HELPhelp
K_PRINTprintscreen
K_SYSREQsysrq
K_BREAKbreak
K_MENUmenu
K_POWERpower
K_EUROEuro

Направленное движение с помощью клавиш

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

вверх, вниз, влево, вправо.

Создать картинку, например:

sprite=pygame.image.load(‘images//pict2.gif’)

Проверить очередь событий:

pygame.event.get()

Проверить, является ли полученное событие нажатием на клавиши со стрелками:

event.type == KEYDOWN

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

spritex,spritey

И нарисовать картинку в новом месте:

blit(sprite,(spritex,spritey))

import pygame, sys, time from pygame.locals import * pygame.init() FPS=30 fpsClock=pygame.time.Clock() width=500 height=500 mainSurface=pygame.display.set_mode((width,height),0,32) pygame.display.set_caption(‘Keyb moves’) background=pygame.image.load(‘images//bg1.jpg’) sprite=pygame.image.load(‘images//pict2.gif’) # Create moving image # Place image to the center of mainSurface spritex=(mainSurface.get_width() — sprite.get_width())/2 spritey=(mainSurface.get_height() — sprite.get_height())/2 direction=False # —> def move(direction, spritex, spritey): # This function moves recalculates new image coordinates if direction: if direction == K_UP: spritey-=5 elif direction == K_DOWN: spritey+=5 if direction == K_LEFT: spritex-=5 elif direction == K_RIGHT: spritex+=5 return spritex, spritey # —> # game loop while True: fpsClock.tick(FPS) # define frame rate mainSurface.blit(background,(0,0)) mainSurface.blit(sprite,(spritex,spritey)) # get all events from the queue for event in pygame.event.get(): # loop events queue, remember in ‘direction’ pressed key code if event.type==QUIT: # window close X pressed pygame.quit() sys.exit() if event.type==KEYDOWN and event.key == K_ESCAPE: # ESC key pressed pygame.quit() sys.exit() if event.type == KEYDOWN: direction = event.key # Other key pressed if event.type == KEYUP: direction = False # Key released # calculate new image position spritex, spritey = move(direction, spritex, spritey) pygame.display.update()

Объект Surface

pygame.Surface

объект pygame для представления изображений

Surface((width, height), flags=0, depth=0, masks=None) -> Surface

Surface((width, height), flags=0, Surface) -> Surface

Наложение поверхностей, прозрачность.

#-*-coding: utf-8-*- import pygame pygame.init() # Create base surface screen = pygame.display.set_mode((500,500)) # Create new surface surface1 = pygame.Surface((150,150)) surface1.fill((255,0,0)) surface1.set_alpha(150) # surface2 = pygame.Surface((100,100)) surface2.fill((255,255,0)) surface2.set_alpha(100) # Create image bgImg = pygame.image.load(«images//bg3.jpg») bgImg = pygame.transform.scale(bgImg,(500,500)) # pict1 = pygame.image.load(«images//pict1.jpg») pict1 = pygame.transform.scale(pict1,(130,130)) pict1.set_alpha(100) # pict2 = pygame.image.load(«images//pict2.gif») pict2 = pygame.transform.scale(pict2,(50,50)) clock = pygame.time.Clock() running = 1 dX = dY = 1 x = y = 0 while running: clock.tick(50) event = pygame.event.poll() if event.type == pygame.QUIT: running = 0 x += 8 * dX y += 6 * dY if (y<0 or y>= (screen.get_height() — pict2.get_height())) : dY *= -1 if (x<0 or x>= (screen.get_width() — pict2.get_width())) : dX *= -1 screen.blit(bgImg,(0,0)) surface1.blit(pict1,(0,0)) screen.blit(surface1,(20,50)) screen.blit(surface2,(150,150)) screen.blit(pict2,(x,y)) pygame.display.flip() pygame.quit()

Управление временем

Модуль pygame.time содержит объект Clock, который можно использовать для отслеживания
времени. Чтобы создать объект типа: время, вызывается конструктор pygame.time.Clock:

clock = pygame.time.Clock()

Когда создан объект clock, можно вызвать его функцию tick один раз за кадр,
которая возвращает время, прошедшее со времени предыдущего вызова в миллисекундах:

time_passed = clock.tick ()

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

# Игра будет работать со скоростью не более 30 кадров в секунду

time_passed = clock.tick (30)

Звуки

Для управления звуком исползуется модуль pygame.mixer. Он отвечает за любые действия со звуками.

Загружаем звуковой файл в формате *.wav

sound = pygame.mixer.Sound(«sound.wav»)
(загружаем до игрового цикла, т.к. это очень долгая операция)

Проигрываем звук

sound.play()

Столкновения (collisions)

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

Эта задача может быть реализована разными способами.

Например, используя объект Rect 

#-*-coding:utf-8-*- import pygame, sys, time from pygame.locals import * pygame.init() FPS = 30 fpsClock = pygame.time.Clock() winWidth = 500 winHeight = 500 mainSurface = pygame.display.set_mode((winWidth,winHeight),0,32) pygame.display.set_caption(‘Collisions test’) background = pygame.image.load(‘images//bg1.jpg’) # Рисуем неподвижные компоненты на поверхности background # Места расположения границ border1Rect = pygame.Rect(0,0,100,500) border2Rect = pygame.Rect(0,150,300,50) # границы border1 = pygame.draw.rect(background, (0,0,0), border1Rect, 0) border2 = pygame.draw.rect(background, (0,0,0), border2Rect, 0) # Записываем их в массив borders = [] borders.append((border1,border1Rect)) borders.append((border2,border2Rect)) # Подвижный блок blockWidth = 50 blockHeight = 50 blockStep = 1 blockColor = (255,0,0) # Начальные координаты подвижного блока — по центру blockX = (mainSurface.get_width() — blockWidth)/2 blockY = (mainSurface.get_height() — blockHeight)/2 blockPosition = (blockX, blockY) direction = False # описание функции —> def newPosition(dirFlag, pos): (x,y) = pos # Функция пересчитывает координаты для подвижного объекта if dirFlag: if dirFlag == K_UP: y -= blockStep elif dirFlag == K_DOWN: y += blockStep if dirFlag == K_LEFT: x -= blockStep elif dirFlag == K_RIGHT: x += blockStep return (x, y) # —> while True: # Игра — начало # Частота обновления экрана fpsClock.tick(FPS) # Рисуем неподвижные компоненты mainSurface.blit(background,(0,0)) # Рисуем подвижный компонент blockRect = pygame.Rect(blockPosition, (blockWidth, blockHeight)) block = pygame.draw.rect(mainSurface, blockColor, blockRect, 1) # просматриваем очередь событий for event in pygame.event.get(): # loop events queue, remember in ‘direction’ pressed key code if event.type == QUIT: # window close X pressed pygame.quit() sys.exit() if event.type == KEYDOWN and event.key == K_ESCAPE: # ESC key pressed pygame.quit() sys.exit() if event.type == KEYDOWN: direction = event.key # Other key pressed if event.type == KEYUP: direction = False # Key released # Cохраняем старые координаты подвижного блока savedPosition = blockPosition # Рассчитываем новые координаты подвижного блока blockPosition = newPosition(direction, blockPosition) # Проверяем их корректность for border in borders: testRect = pygame.Rect(blockPosition, (blockWidth, blockHeight)) if testRect.colliderect(border[1]): print («Столкновение !») # Возвращаем старые координату blockPosition = savedPosition else: print («ok») pygame.display.update() # Игра — конец

Или используя поверхности — surface

#-*-coding:utf-8-*- import pygame, sys, time from pygame.locals import * # Блоки-ограничители рисуются как отдельные поверхности # Между ними курсором перемещаем мячик FPS = 30 # кадров в сек # Размеры окна игры width = 500 height = 500 # Заголовок окна игры title = «Collisions detection test» # Сообщение в консоль игры info = «Нет столкновений \n» # Переменная — индикатор движения direction = False # Шаг движения myStep = 2 pygame.mixer.init() pygame.mixer.music.load(«voice-prompts-reaction-reaction-1-child-3-yrs-oops-human-voice-kid-speak-talk.mp3») pygame.init() fpsClock = pygame.time.Clock() mainSurface=pygame.display.set_mode((width,height),0,32) pygame.display.set_caption(title) background=pygame.image.load(‘images//bg1.jpg’) # Фон sprite = pygame.image.load(‘images//pict2.gif’) # Подвижная картинка # Начальные координаты подвижной картинки # Важно, чтобы в начале работы она не перекрывала ни один блок spriteX=mainSurface.get_width() — sprite.get_width() spriteY=mainSurface.get_height() — sprite.get_height() # Неподвижные блоки — все сохраняем в одном списке # Структура списка blocks: # каждый элемент — пара значений: (поверхность, область её размещения) # blocks[0] — первый элемент списка, blocks[0][0] — surface первого элемента,blocks[0][1] — Rect первого элемента blocks = [] block1 = pygame.Surface((200,200)) block1.set_alpha(80) block1.fill((255,0,0)) block1Rect = pygame.Rect(0,0,block1.get_width(), block1.get_height()) blocks.append((block1,block1Rect)) # block2 = pygame.Surface((100,200)) block2.fill((0,255,0)) block2Rect = pygame.Rect(400,0,block2.get_width(), block2.get_height()) blocks.append((block2,block2Rect)) # block3 = pygame.Surface((300,100)) block3.fill((0,0,255)) block3Rect = pygame.Rect(0,350,block3.get_width(), block3.get_height()) blocks.append((block3,block3Rect)) # закончили с описанием 3-х блоков # *********> def newPosition (direction, spriteX, spriteY): # Функция пересчитывает координаты новой позиции подвижного объекта # Проверяем столкновений со всеми блоками-границаи global myStep if direction: if direction == K_UP: spriteY -= myStep elif direction == K_DOWN: spriteY += myStep elif direction == K_LEFT: spriteX -= myStep elif direction == K_RIGHT: spriteX += myStep return spriteX, spriteY # *********> # *********> def collisionDetected(): global blocks global spriteRectNew colFlag = False # Проверка столкновений со всеми блоками в массиве блоков for block in blocks: if spriteRectNew.colliderect(block[1]): collisionDir = direction colFlag = True return colFlag # *********> # Цикл игры while True: fpsClock.tick(FPS) # Частота обновления экрана # Обрабатываем очередь событий — начало for event in pygame.event.get(): # В цикле берём из очереди очередное событие, запоминаем в переменной event # Проверяем тип события и выполняем соответствующие лействия if event.type == QUIT: # Тип проверяемого события НАЖАТ Х В ОКНЕ ИГРЫ pygame.quit() sys.exit() if event.type == KEYDOWN and event.key == K_ESCAPE: # ESC key pressed pygame.quit() sys.exit() # Следующая строка получает управление только тогда, когда не отработали предыдущие проверки кода события # то есть произошло событие, отличное от перечисленных выше if event.type == KEYDOWN: direction = event.key if event.type == KEYUP: direction = False # Кнопка отпущена # Обрабатываем очередь событий — конец # Текущее место расположения подвижной картинки spriteRect = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height()) # Сохраняем старые координаты oldPos = (spriteX, spriteY) # Вычмсляем новые координаты, анализируя нажатые кнопки spriteX, spriteY = newPosition(direction, spriteX, spriteY) # Вычисляем новое место расположения картинки spriteRectNew = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height()) # Проверяем, не пересекает ли новое место блоки. Если пересекает, то вовращпни картинке старые координаты if collisionDetected(): (spriteX, spriteY) = oldPos # Play OOPS! pygame.mixer.music.play() # Рисуем всё на экране # Фон mainSurface.blit(background,(0,0)) # Блоки for block in blocks: mainSurface.blit(block[0],(block[1].x,block[1].y)) # Картинку mainSurface.blit(sprite,(spriteRect.x,spriteRect.y)) # Обновляем экран pygame.display.update()

PyGame — шпаргалка для использования — Записки преподавателя

Основные модули пакета Pygame

Модуль Назначение
pygame.cdrom Доступ к CD-приводам и управление ими
pygame.cursors Загружает изображения курсора
pygame.display Доступ к дисплею
pygame.draw Рисует фигуры, линии и точки
pygame.event Управление внешними событиями
pygame.font Использует системные шрифты
pygame.image Загружает и сохраняет изображение
pygame.joystick Использует джойстики и аналогичные устройства
pygame.key Считывает нажатия клавиш с клавиатуры
pygame.mixer Загружает и воспроизводит мелодии
pygame.mouse Управляет мышью
pygame.movie Воспроизведение видеофайлов
pygame.music Работает с музыкой и потоковым аудио
pygame.overlay Доступ к расширенным видеоизображениям
pygame Содержит функции Pygame высокого уровня
pygame.rect Управляет прямоугольными областями
pygame.sndarray Манипулирует звуковыми данными
pygame.sprite Управление движущимися изображениями
pygame.surface Управляет изображениями и экраном
pygame.surfarray Манипулирует данными пикселей изображения
pygame.time модуль pygame для управления временем и частотой кадров
pygame.transform Изменение размера и перемещение изображений

Окно Pygame


# Подключение библиотеки PyGame
import pygame

# Инициализация PyGame
pygame.init()

# Окно игры: размер, позиция
gameScreen = pygame.display.set_mode((400, 300))

# Модуль os - позиция окна
import os
x = 100
y = 100
os.environ['Sp_VIDEO_WINDOW_POS'] = "%d,%d" % (x,y)

# Параметры окна
size = [500, 500]
screen = pygame.display.set_mode(size)
pygame.display.set_caption("Test drawings")
gameScreen.fill((0,0,255))
pygame.display.flip()

Цикл игры, выход из игры


# Цикл игры
runGame = True # флаг выхода из цикла игры
while runGame:
    # Отслеживание события: "закрыть окно"
    for event in pygame.event.get():
        if event.type == pygame.QUIT: runGame = False

# Выход из игры: 
pygame.quit()

Рисование базовых элементов
модуль pygame.draw

pygame.draw.rect нарисовать прямоугольную форму
pygame.draw.polygon фигуру с любым количеством сторон
pygame.draw.circle круг вокруг точки
pygame.draw.ellipse нарисовать круглую форму внутри прямоугольника
pygame.draw.arc нарисовать секцию эллипса
pygame.draw.line нарисовать сегмент прямой линии
pygame.draw.lines для рисования нескольких смежных отрезков
pygame.draw.aaline рисовать тонкую линию
pygame.draw.aalines нарисовать связанную последовательность сглаженных линий

rect(Surface, color, Rect, wiph=0) -> Rect
polygon(Surface, color, pointlist, wiph=0) -> Rect
circle(Surface, color, pos, radius, wiph=0) -> Rect
ellipse(Surface, color, Rect, wiph=0) -> Rect
arc(Surface, color, Rect, start_angle, stop_angle, wiph=1) -> Rect
line(Surface, color, start_pos, end_pos, wiph=1) -> Rect
lines(Surface, color, closed, pointlist, wiph=1) -> Rect
aaline(Surface, color, startpos, endpos, blend=1) -> Rect
aalines(Surface, color, closed, pointlist, blend=1) -> Rect

Загрузка изображения


# Модуль pygame.image позволяет загрузить изображерие из файла и возвращает объект типа Surface.
pygame.image.load("путь к файлу" )

# загрузить новое изображение из файла
load(filename) -> Surface

# Загрузить изображение (путь к файлу для Windows)
myImage = pygame.image.load('images\\bg1.jpg')

# определить место размещения
myRect = (0,0,600,400)

# выгрузить объект Surface, который содержит загруженное из файла изображение (myImage), в описанное место на экране (myRect)
screen.blit(myImage,myRect)

Объект Rect

pygame.Rect

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


Rect(left, top, wiph, height) -> Rect

Rect((left, top), (wiph, height)) -> Rect

Rect(object) -> Rect
Методы работы с Rect
pygame.Rect.copy Возвращает новый прямоугольник, имеющий ту же позицию и размер, что и оригинал.
pygame.Rect.move Возвращает новый прямоугольник, перемещаемый данным смещением. Аргументы x и y могут быть любым целочисленным значением, положительным или отрицательным.
pygame.Rect.move_ip То же, что и метод Rect.move (), но работает на месте.
pygame.Rect.inflate увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.inflate_ip увеличивать или уменьшать размер прямоугольника, на месте
pygame.Rect.clamp перемещает прямоугольник внутри другого
pygame.Rect.clamp_ip перемещает прямоугольник внутри другого, на месте
pygame.Rect.clip обрезает прямоугольник внутри другого
pygame.Rect.union соединяет два прямоугольника в один
pygame.Rect.union_ip соединяет два прямоугольника в один, на месте
pygame.Rect.unionall объединение многих прямоугольников
pygame.Rect.unionall_ip объединение многих прямоугольников, на месте
pygame.Rect.fit изменить размер и переместить прямоугольник учмиывая соотношение сторон
pygame.Rect.normalize корректировать отрицательные размеры
pygame.Rect.contains проверить, находится ли один прямоугольник внутри другого
pygame.Rect.collidepoint проверить, находится ли точка внутри прямоугольника
pygame.Rect.colliderect тест, пересекаются ли два прямоугольника
pygame.Rect.collidelist проверить, пересекается ли хоть один прямоугольник в списке
pygame.Rect.collidelistall пересекаются ли все прямоугольники в списке
pygame.Rect.collidedict проверить, если один прямоугольник в словаре пересекается
pygame.Rect.collidedictall пересекаются ли все прямоугольники в словаре

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

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

Функция get в модуле pygame.event возвращает последнее событие, ожидающее в очереди и удаляет его из очереди.

Объект event

Модуль pygame.event для обработки очереди событий

pygame.event.pump Если вы не используете другие функции событий в своей игре, вы должны вызвать pygame.event.pump (), чтобы позволить pygame обрабатывать внутренние действия
pygame.event.get получает события из очереди
pygame.event.poll получить одно событие из очереди
pygame.event.wait ждёт одиночного события из очереди
pygame.event.peek проверить, ждут ли очереди события определённого типа
pygame.event.clear удалить все события из очереди
pygame.event.event_name возвращает имя для типа события. Строка находится в стиле WordCap
pygame.event.set_blocked проверяет, какие события не разрешены в очереди
pygame.event.set_allowed проверяет, какие события разрешены в очереди
pygame.event.get_blocked проверить, заблокирован ли тип события из очереди
pygame.event.set_grab проверяет совместное использование устройств ввода с другими приложениями
pygame.event.get_grab проверить, работает ли программа на устройствах ввода данных
pygame.event.post поместить новое событие в очередь
pygame.event.Event создать новый объект события
pygame.event.EventType Объект Python, представляющий событие SDL. Экземпляры пользовательских событий создаются с вызовом функции Event. Тип EventType не может быть напрямую вызван. Экземпляры EventType поддерживают назначение и удаление атрибутов.

Pygame отслеживает все сообщения о событиях через очередь событий. Процедуры в этом модуле помогают управлять этой очередью событий. Входная очередь сильно зависит от модуля отображения (display) pygame. Если дисплей не был инициализирован и видеорежим не установлен, очередь событий не будет работать.

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

Мышь

Модуль pygame.mouse для работы с мышью

pygame.mouse.get_pressed получить состояние кнопок мыши
pygame.mouse.get_pos получить позицию курсора мыши
pygame.mouse.get_rel получить количество движений мыши
pygame.mouse.set_pos установить позицию курсора мыши
pygame.mouse.set_visible скрыть или показать курсор мыши
pygame.mouse.get_focused проверяет, принимает ли дисплей ввод мыши
pygame.mouse.set_cursor установить изображение для курсора мыши
pygame.mouse.get_cursor получить изображение для курсора мыши

Функции мыши можно использовать для получения текущего состояния устройства мышь. Эти функции также могут изменять курсор мыши.

Когда режим отображения (display) установлен, очередь событий начнет принимать события мыши. Кнопки мыши генерируют события pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP, когда они нажимаются и отпускаются. Эти события содержат атрибут кнопки, указывающий, какая кнопка была нажата. Колесо мыши будет генерировать pygame.MOUSEBUTTONDOWN и pygame.MOUSEBUTTONUP события при прокрутке.

Когда колесо повернуто вверх, кнопка будет установлена на 4, вниз -5. Всякий раз, когда мышь перемещается, генерируется событие pygame.MOUSEMOTION. Движение мыши разбито на небольшие и точные события движения. По мере перемещения мыши многие события движения будут помещены в очередь. События движения мыши, которые неправильно очищены от очереди событий, являются основной причиной того, что очередь событий заполняется.

Пример. Нарисовать курсор под текущей позицией мыши.


x, y = pygame.mouse.get_pos()
x -= mouse_cursor.get_width()/2
y -= mouse_cursor.get_height()/2
screen.blit(mouse_cursor, (x, y))

Определить какая кнопка была нажата на мышке можно используя значение event.button:


1 - left click
2 - middle click
3 - right click
4 - scroll up
5 - scroll down

Координаты курсора при нажатии кнопки мыши находятся в event.pos.

Пример. Перемещать картинку курсором мыши.


import pygame, sys, time
from pygame.locals import *
pygame.init()
FPS=30
fpsClock=pygame.time.Clock()
width=500
height=500
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption('Keyb moves')
background=pygame.image.load('images//bg1.jpg')
sprite=pygame.image.load('images//pict2.gif') 

# Place image to the center of mainSurface
image_pos = ((mainSurface.get_width() - sprite.get_width())/2, (mainSurface.get_height() - sprite.get_height())/2)
doMove = False

# game loop
while True:
    fpsClock.tick(FPS) # frame rate
    mainSurface.blit(background,(0,0))
    
    # get all events from the queue
    for event in pygame.event.get():
        # loop events queue
        if event.type == QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()

        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()

        if event.type == pygame.MOUSEBUTTONDOWN:
            if event.button == 1:  #  левая кнопка мыши
                doMove = True
            if event.button == 3:  # правая кнопка мыши
                image_pos = ((mainSurface.get_width() - sprite.get_width())/2, (mainSurface.get_height() - sprite.get_height())/2)
                doMove = False

        if event.type == pygame.MOUSEBUTTONUP: doMove = False
            
        if event.type == MOUSEMOTION and doMove:
            image_pos = event.pos

    mainSurface.blit(sprite,image_pos)
    pygame.display.update()

Клавиатура

Модуль pygame.key

Этот модуль содержит функции для работы с клавиатурой.Очередь событий получает события pygame.KEYDOWN и pygame.KEYUP при нажатии и отпускании клавиш клавиатуры.

Оба события имеют ключевой атрибут, который представляет собой целочисленный идентификатор, представляющий каждую клавишу на клавиатуре.Событие pygame.KEYDOWN имеет дополнительные атрибуты: unicode и scancode. unicode представляет собой одну символьную строку, которая соответствует введённому символу. Scancode представляет собой код для конкретной платформы.

Получить код клавиши:


pressed_keys = pygame.key.get_pressed()
if pressed_keys[K_SPACE]:
# Space key has been pressed
fire()

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

KeyASCII ASCII CommonName
K_BACKSPACE \b backspace
K_TAB \t tab
K_CLEAR clear
K_RETURN \r return
K_PAUSE pause
K_ESCAPE ^[ escape
K_SPACE space
K_EXCLAIM ! exclaim
K_QUOTEDBL « quotedbl
K_HASH # hash
K_DOLLAR $ dollar
K_AMPERSAND & ampersand
K_QUOTE quote
K_LEFTPAREN ( leftparenthesis
K_RIGHTPAREN ) rightparenthesis
K_ASTERISK * asterisk
K_PLUS + plussign
K_COMMA , comma
K_MINUS minussign
K_PERIOD . period
K_SLASH / forwardslash
K_0 0 0
K_1 1 1
K_2 2 2
K_3 3 3
K_4 4 4
K_5 5 5
K_6 6 6
K_7 7 7
K_8 8 8
K_9 9 9
K_COLON : colon
K_SEMICOLON ; semicolon
K_LESS less-thansign
K_EQUALS = equalssign
K_GREATER > greater-thansign
K_QUESTION ? questionmark
K_AT @ at
K_LEFTBRACKET [ leftbracket
K_BACKSLASH \ backslash
K_RIGHTBRACKET ] rightbracket
K_CARET ^ caret
K_UNDERSCORE _ underscore
K_BACKQUOTE ` grave
K_a a a
K_b b b
K_c c c
K_d d d
K_e e e
K_f f f
K_g g g
K_h h h
K_i i i
K_j j j
K_k k k
K_l l l
K_m m m
K_n n n
K_o o o
K_p p p
K_q q q
K_r r r
K_s s s
K_t t t
K_u u u
K_v v v
K_w w w
K_x x x
K_y y y
K_z z z
K_DELETE delete
K_KP0 keypad0
K_KP1 keypad1
K_KP2 keypad2
K_KP3 keypad3
K_KP4 keypad4
K_KP5 keypad5
K_KP6 keypad6
K_KP7 keypad7
K_KP8 keypad8
K_KP9 keypad9
K_KP_PERIOD . keypadperiod
K_KP_DIVIDE / keypaddivide
K_KP_MULTIPLY * keypadmultiply
K_KP_MINUS keypadminus
K_KP_PLUS + keypadplus
K_KP_ENTER \r keypadenter
K_KP_EQUALS = keypadequals
K_UP uparrow
K_DOWN downarrow
K_RIGHT rightarrow
K_LEFT leftarrow
K_INSERT insert
K_HOME home
K_END end
K_PAGEUP pageup
K_PAGEDOWN pagedown
K_F1 F1
K_F2 F2
K_F3 F3
K_F4 F4
K_F5 F5
K_F6 F6
K_F7 F7
K_F8 F8
K_F9 F9
K_F10 F10
K_F11 F11
K_F12 F12
K_F13 F13
K_F14 F14
K_F15 F15
K_NUMLOCK numlock
K_CAPSLOCK capslock
K_SCROLLOCK scrollock
K_RSHIFT rightshift
K_LSHIFT leftshift
K_RCTRL rightcontrol
K_LCTRL leftcontrol
K_RALT rightalt
K_LALT leftalt
K_RMETA rightmeta
K_LMETA leftmeta
K_LSUPER leftWindowskey
K_RSUPER rightWindowskey
K_MODE modeshift
K_HELP help
K_PRINT printscreen
K_SYSREQ sysrq
K_BREAK break
K_MENU menu
K_POWER power
K_EURO Euro

Направленное движение с помощью клавиш

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

Создать картинку, например:

sprite=pygame.image.load('images//pict2.gif')

Проверить очередь событий:

pygame.event.get()

Проверить, является ли полученное событие нажатием на клавиши со стрелками:

event.type == KEYDOWN

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

spritex,spritey

И нарисовать картинку в новом месте:

blit(sprite,(spritex,spritey))


import pygame, sys, time
from pygame.locals import *

pygame.init()

FPS=30
fpsClock=pygame.time.Clock()
width=500
height=500
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption('Keyb moves')

background=pygame.image.load('images//bg1.jpg')

sprite=pygame.image.load('images//pict2.gif') # Create moving image

# Place image to the center of mainSurface
spritex=(mainSurface.get_width() - sprite.get_width())/2
spritey=(mainSurface.get_height() - sprite.get_height())/2
direction=False

# --->
def move(direction, spritex, spritey):
    # This function moves recalculates new image coordinates
    if direction:
        if direction == K_UP:
            spritey-=5
        elif direction == K_DOWN:
            spritey+=5
        if direction == K_LEFT:
            spritex-=5
        elif direction == K_RIGHT:
            spritex+=5
    return spritex, spritey
# --->

# game loop
while True:
    fpsClock.tick(FPS) # define frame rate
    mainSurface.blit(background,(0,0))
    mainSurface.blit(sprite,(spritex,spritey))

    # get all events from the queue
    for event in pygame.event.get():
        # loop events queue, remember in 'direction' pressed key code
        if event.type==QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()
        if event.type==KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN: direction = event.key # Other key pressed
        if event.type == KEYUP:  direction = False # Key released

    # calculate new image position    
    spritex, spritey = move(direction, spritex, spritey)

    pygame.display.update()

Объект Surface

pygame.Surface — объект pygame для представления изображений


Surface((width, height), flags=0, depth=0, masks=None) -> Surface

Surface((width, height), flags=0, Surface) -> Surface

 
Наложение поверхностей, прозрачность.


#-*-coding: utf-8-*-
import pygame
pygame.init()

# Create base surface
screen = pygame.display.set_mode((500,500))

# Create new surface
surface1 = pygame.Surface((150,150))
surface1.fill((255,0,0))
surface1.set_alpha(150)
#
surface2 = pygame.Surface((100,100))
surface2.fill((255,255,0))
surface2.set_alpha(100)

# Create image
bgImg = pygame.image.load("images//bg3.jpg")
bgImg = pygame.transform.scale(bgImg,(500,500))
#
pict1 = pygame.image.load("images//pict1.jpg")
pict1 = pygame.transform.scale(pict1,(130,130))
pict1.set_alpha(100)
#
pict2 = pygame.image.load("images//pict2.gif")
pict2 = pygame.transform.scale(pict2,(50,50))

clock = pygame.time.Clock()
running = 1
dX = dY = 1
x = y = 0

while running:
    clock.tick(50)
    event = pygame.event.poll()
    if event.type == pygame.QUIT: running = 0
    x += 8 * dX
    y += 6 * dY
    if (y= (screen.get_height() - pict2.get_height())) :
        dY *= -1
    if (x= (screen.get_width() - pict2.get_width())) :
        dX *= -1
    
    screen.blit(bgImg,(0,0))
    surface1.blit(pict1,(0,0))
    screen.blit(surface1,(20,50))
    screen.blit(surface2,(150,150))
    screen.blit(pict2,(x,y))
    
    pygame.display.flip()

pygame.quit()   

 

Управление временем

Модуль pygame.time содержит объект Clock, который можно использовать для отслеживания
времени. Чтобы создать объект типа: время, вызывается конструктор pygame.time.Clock:
clock = pygame.time.Clock()

Когда создан объект clock, можно вызвать его функцию tick один раз за кадр,
которая возвращает время, прошедшее со времени предыдущего вызова в миллисекундах:
time_passed = clock.tick ()

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

# Игра будет работать со скоростью не более 30 кадров в секунду

time_passed = clock.tick (30)

Звуки

Для управления звуком используется модуль pygame.mixer. Он отвечает за любые действия со звуками.

Загружаем звуковой файл в формате *.wav

sound = pygame.mixer.Sound("sound.wav")
(загружаем до игрового цикла, т.к. это очень долгая операция)

Проигрываем звук

sound.play()

Столкновения (collisions)

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

Эта задача может быть реализована разными способами.

Например, используя объект Rect


#-*-coding:utf-8-*-
import pygame, sys, time
from pygame.locals import *

pygame.init()
FPS         = 30
fpsClock    = pygame.time.Clock()
winWidth    = 500
winHeight   = 500
mainSurface = pygame.display.set_mode((winWidth,winHeight),0,32)
pygame.display.set_caption('Collisions test')
background = pygame.image.load('images//bg1.jpg')

# Рисуем неподвижные компоненты на поверхности background
# Места расположения границ
border1Rect = pygame.Rect(0,0,100,500)
border2Rect = pygame.Rect(0,150,300,50)
# границы
border1 = pygame.draw.rect(background, (0,0,0), border1Rect, 0)
border2 = pygame.draw.rect(background, (0,0,0), border2Rect, 0)
# Записываем их в массив
borders = []
borders.append((border1,border1Rect))
borders.append((border2,border2Rect))
# Подвижный блок
blockWidth  = 50
blockHeight = 50
blockStep = 1
blockColor  = (255,0,0)
# Начальные координаты подвижного блока - по центру 
blockX = (mainSurface.get_width()   - blockWidth)/2
blockY = (mainSurface.get_height()  - blockHeight)/2
blockPosition = (blockX, blockY)
direction = False

# описание функции --->
def newPosition(dirFlag, pos):
    (x,y) = pos
    # Функция пересчитывает координаты для подвижного объекта
    if dirFlag:
        if dirFlag      == K_UP:
            y -= blockStep
        elif dirFlag    == K_DOWN:
            y += blockStep
        if dirFlag      == K_LEFT:
            x -= blockStep
        elif dirFlag    == K_RIGHT:
            x += blockStep
    return (x, y)
# --->

while True:   # Игра - начало
    # Частота обновления экрана
    fpsClock.tick(FPS)
    # Рисуем неподвижные компоненты
    mainSurface.blit(background,(0,0))
    # Рисуем подвижный компонент
    blockRect = pygame.Rect(blockPosition, (blockWidth, blockHeight))
    block = pygame.draw.rect(mainSurface, blockColor, blockRect, 1)
    # просматриваем очередь событий
    for event in pygame.event.get():
        # loop events queue, remember in 'direction' pressed key code
        if event.type == QUIT:
            # window close X pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN: direction = event.key # Other key pressed
        if event.type == KEYUP:  direction = False # Key released
    # Cохраняем старые координаты подвижного блока
    savedPosition = blockPosition
    # Рассчитываем новые координаты подвижного блока
    blockPosition = newPosition(direction, blockPosition)
    # Проверяем их корректность 
    for border in borders:
        testRect = pygame.Rect(blockPosition, (blockWidth, blockHeight))  
        if testRect.colliderect(border[1]):
            print ("Столкновение !")
            # Возвращаем старые координату
            blockPosition = savedPosition
        else: print ("ok")
    pygame.display.update()
# Игра - конец 

Или используя поверхности — surface


#-*-coding:utf-8-*-
import pygame, sys, time
from pygame.locals import *

# Блоки-ограничители рисуются как отдельные поверхности
# Между ними курсором перемещаем мячик

FPS = 30 # кадров в сек
# Размеры окна игры
width  = 500
height = 500
# Заголовок окна игры
title = "Collisions detection test"
# Сообщение в консоль игры
info = "Нет столкновений \n"
# Переменная - индикатор движения
direction = False
# Шаг движения
myStep = 2
pygame.mixer.init()
pygame.mixer.music.load("voice-prompts-reaction-reaction-1-child-3-yrs-oops-human-voice-kid-speak-talk.mp3")

pygame.init()
fpsClock = pygame.time.Clock()
mainSurface=pygame.display.set_mode((width,height),0,32)
pygame.display.set_caption(title)
background=pygame.image.load('images//bg1.jpg')     # Фон 
sprite = pygame.image.load('images//pict2.gif')     # Подвижная картинка

# Начальные координаты подвижной картинки
# Важно, чтобы в начале работы она не перекрывала ни один блок
spriteX=mainSurface.get_width() - sprite.get_width()
spriteY=mainSurface.get_height() - sprite.get_height()

# Неподвижные блоки - все сохраняем в одном списке
# Структура списка blocks:
# каждый элемент - пара значений: (поверхность, область её размещения)
# blocks[0] - первый элемент списка, blocks[0][0] - surface первого элемента,blocks[0][1]  - Rect первого элемента
blocks = []
block1 = pygame.Surface((200,200))
block1.set_alpha(80)
block1.fill((255,0,0))
block1Rect = pygame.Rect(0,0,block1.get_width(), block1.get_height())
blocks.append((block1,block1Rect))
#
block2 = pygame.Surface((100,200))
block2.fill((0,255,0))
block2Rect = pygame.Rect(400,0,block2.get_width(), block2.get_height())
blocks.append((block2,block2Rect))
#
block3 = pygame.Surface((300,100))
block3.fill((0,0,255))
block3Rect = pygame.Rect(0,350,block3.get_width(), block3.get_height())
blocks.append((block3,block3Rect))
# закончили с описанием 3-х блоков


# *********>
def newPosition (direction, spriteX, spriteY):
    # Функция пересчитывает координаты новой позиции подвижного объекта
    # Проверяем столкновений со всеми блоками-границаи
    global myStep
    if direction:
        if direction == K_UP:
            spriteY -= myStep
        elif direction == K_DOWN:
            spriteY += myStep
        elif direction == K_LEFT:
            spriteX -= myStep
        elif direction == K_RIGHT:
            spriteX += myStep
    return spriteX, spriteY
# *********>



# *********>
def collisionDetected():
    global blocks
    global spriteRectNew
    colFlag = False
    # Проверка столкновений со всеми блоками в массиве блоков
    for block in blocks:
        if spriteRectNew.colliderect(block[1]):
            collisionDir = direction
            colFlag = True
    return colFlag
# *********>

# Цикл игры
while True:
    fpsClock.tick(FPS) # Частота обновления экрана
    
    # Обрабатываем очередь событий - начало 
    for event in pygame.event.get(): 
        # В цикле берём из очереди очередное событие, запоминаем в переменной event
        # Проверяем тип события и выполняем соответствующие лействия
        if event.type == QUIT:
            # Тип проверяемого события НАЖАТ Х В ОКНЕ ИГРЫ
            pygame.quit()
            sys.exit()
        if event.type == KEYDOWN and event.key == K_ESCAPE:
            # ESC key pressed
            pygame.quit()
            sys.exit()

        # Следующая строка получает управление только тогда, когда не отработали предыдущие проверки кода события
        # то есть произошло событие, отличное от перечисленных выше
        if event.type == KEYDOWN:
            direction = event.key
        if event.type == KEYUP:
            direction = False # Кнопка отпущена
    # Обрабатываем очередь событий - конец 


    # Текущее место расположения подвижной картинки 
    spriteRect = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height())

    # Сохраняем старые координаты
    oldPos = (spriteX, spriteY)
    
    # Вычмсляем новые координаты, анализируя нажатые кнопки
    spriteX, spriteY = newPosition(direction, spriteX, spriteY)

    # Вычисляем новое место расположения картинки
    spriteRectNew = pygame.Rect(spriteX,spriteY,sprite.get_width(), sprite.get_height())

    
    # Проверяем, не пересекает ли новое место блоки. Если пересекает, то вовращпни картинке старые координаты
    if collisionDetected():
        (spriteX, spriteY) = oldPos
        # Play OOPS!
        pygame.mixer.music.play()
        
    # Рисуем всё на экране
    #    Фон 
    mainSurface.blit(background,(0,0))
    #    Блоки 
    for block in blocks:
        mainSurface.blit(block[0],(block[1].x,block[1].y))
    #    Картинку 
    mainSurface.blit(sprite,(spriteRect.x,spriteRect.y))
    #    Обновляем экран
    pygame.display.update()

PyGame — шпаргалка для использования, опубликовано К ВВ, лицензия — Creative Commons Attribution-NonCommercial 4.0 International.


Респект и уважуха

Библиотека pygame (Часть 1)

Назад в начало

pygame — это библиотека модулей для языка Python, созданная для разработки 2D игр.

Для того чтобы установить pygame на свой компьютер необходимо открыть командную строку или терминал и написать команду

pip3 install pygame

После установки необходимо создать новый файл и импортировать модуль pygame и написать шаблон игры

# Импортируем библиотеку pygame
import pygame
# Импортируем системную функцию exit
from sys import exit

# Инициализируем pygame
pygame.init()

# Создаем окошко 800 пикселей шириной
# и 600 пикселей высотой и записываем его
# в переменную display.
# Переменную display называют поверхностью.
display = pygame.display.set_mode( (800, 600) )

# Основной цикл игры
while True:
    # Ждем события (действия пользователя)
    for event in pygame.event.get():
        # Если нажали на крестик,
        # то закрываем окно
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    # Обновляем поверхность игры
    # на каждом шаге основного цикла игры
    pygame.display.update()

Пользователь может взаимодействовать с нашей игрой. Каждое действие пользователя — это некоторое событие, которое мы можем обработать. Выражение pygame.event.get() — это список событий, произошедших в нашей игре.

Цикл for просто перебирает необработанные события. Каждое событие он присваивает переменной event (можно написать любую другую).

Поговорим о цикле while, основном цикле игры. Как часто он выполняется? Очень и очень часто, это зависит от мощности компьютера. Для обновления экрана в играх часто используют 60 кадров в секунду.

Ограничим количество выполнений цикла.

import pygame
from sys import exit

pygame.init()

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

FPS = 60 # Создаем переменную FPS
clock = pg.time.Clock() # Создаем счетчик для FPS
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    pygame.display.update()

    clock.tick(FPS) # Замедляем цикл до 60 выполнений в секунду

Методу tick() передается желаемое количество кадров в секунду. Задержку он вычисляет сам. На каждой итерации основного цикла игры секунда делится на 60 и на вычисленную величину выполняется задержка.

В библиотеке pygame существует множество функций для рисования различных фигур.

Функция polygon() рисует произвольную фигуру. Она принимает 3 обязательных параметра (поверхность, цвет и кортеж координат) и 1 необязательный (толщину линий).

import pygame
from sys import exit

pygame.init()

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

# Рисуем полигон (да, получится квадратик)
pygame.draw.polygon( display, (255, 0, 0) , ( (0, 0), (100, 0), (100, 100), (0, 100) ) )

FPS = 60
clock = pg.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    pygame.display.update()

    clock.tick(FPS)

display — наша поверхность

(255, 0, 0) — красный цвет, почитайте про rgb

( (0, 0), (100, 0), (100, 100), (0, 100) ) — координаты вершин квадрата. Возьмите листочек и нарисуйте его координатах (замените сотню на единицу).

Давайте нарисуем треугольник

import pygame
from sys import exit

pygame.init()

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

# Рисуем квадратик
pygame.draw.polygon( display, (255, 0, 0) , ( (0, 0), (100, 0), (100, 100), (0, 100) ) )
# Рисуем синий треугольник
pygame.draw.polygon( display, (0, 0, 255) , ( (100, 100), (200, 200), (100, 200) ) )

FPS = 60 # Создаем переменную FPS
clock = pg.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    pygame.display.update()

    clock.tick(FPS)

display — поверхность

(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

pygame.init()

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

# Рисуем квадратик
pygame.draw.polygon( display, (255, 0, 0) , ( (0, 0), (100, 0), (100, 100), (0, 100) ) )
# Рисуем синию линию
pygame.draw.polygon( display, (0, 0, 255) , ( (100, 100), (200, 200), (100, 200) ) )
# Рисуем желтую окружность с радиусом 100 пикселей
pygame.draw.circle( display, (255, 255, 0) , (400,200), 100)

FPS = 60
clock = pg.time.Clock()
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            exit()

    pygame.display.update()

    clock.tick(FPS)

display — наша поверхнотсть для рисования

(255, 255, 0) — желтый цвет

(400, 200) — координаты точки центра (в нашем случае 400 пикселей от верхнего левого угла по горизонтали и 200 пикселей по вертикали)

100 — радиус нашей окружности в пикселях

Объявления переменных для цветов

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

import pygame
from sys import exit

pygame.init()

WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
PURPLE = (156, 39, 176)
INDIGO = (63, 81

PyGame. Введение / Хабр

PyGame. Введение.


Довелось мне как-то пообщаться с этой библиотекой, чем и хотелось бы поделиться с вами, и себе зарубочку оставить, дабы не забывать:) В этом небольшом, надеюсь, посте, я на наглядном примере, опуская некоторые самые-самые теоретические основы (которые изложены в документации), покажу базовые принципы работы с библиотекой.
Задача.
Создать «игровое» пространство, в котором, при помощи клавиш-стрелок, можно будет перемещать объект.
Теория.
Прежде чем выкладывать листинги, остановлюсь на используемых методах из модулей библиотеки, описание которых взято из оф. документации.

Модуль image
1. pygame.image.load (filename): return Surface
Как можно догадаться, функция загружает некоторое изображение, и возвращеает в виде поверхности, типа, с которым при помощи функций pygame уже можно выполнять какие-либо операции (трансформировать, перемащать, удалять и пр.)

Модуль Surface
2. Surface.blit (source, dest, area=None, special_flags = 0)
Отрисовывает заданную поверхность (source) поверх базовой (Surface), где dest — кортеж (x, y), кординат отрисвоки, area — (width, height) — размеры source поверхности. На счет флагов, если честно пока не разбирался))
3. Surface.get_rect ()
Возвращет кортеж вида (x, y, width, height), где x, y — кординаты левого верхнего угла поверхности (Surface), width, height — соответственно ее размеры.

Модуль event
Он позволяет взаимодействовать с событиями и запросами. Иными словами, любое событие в pygame, нажатие клавиши например, помещается в список, состоящий из Event objects. Все эти «событийные объекты» имеют тип, получить доступ к которому можно путем Event.type.
4. pygame.event.get ()
Метод get () позволяет получить список событий.

Модуль Rect
Модуль для работы с кортежами типа rect.
5. Rect.move (X, Y)
Возвращает новый rect, в котором координаты смещены, относительно исходных, на заданные X, Y, в качестве которых может быть положительное или отрицательное целое число.

Практика.
Взяв на вооружение вышесказанное, получаем:
  1. # -*- coding: cp1251 -*-
  2. # Пример реализации движения при помощи pygame.

  3. from pygame import *
  4. import sys
  5. # Инициализируем загруженную библиотеку.
  6. init()

  7. # Создаем окно разрешением 640х480
  8. screen = display.set_mode((640, 480))

  9. # Устанавливаем название окна
  10. display.set_caption('example')

  11. # Загружаем фоновый рисунок, в формате:
  12. # jpg, png, gif(без анимации), bmp, pcx, tga(без сжатия), tif.
  13. background = image.load('background.bmp')

  14. # Отрисовываем рисунок в нашем окне
  15. screen.blit(background, (0, 0))

  16. # Создаем игровой объект
  17. class GameObj:
  18.     def __init__(self, img, x, y, step):
  19.         self.img = img # Картинка объекта
  20.         self.x = x # x, y - коодинаты начального положения
  21.         self.y = y
  22.         self.step = step # Шаг, на который будет смещаться объкт
  23.         self.pos = img.get_rect().move(x, y)
  24.     def _move(self, event):
  25.         if event.key == K_UP: #273 код клавиши вверх
  26.             self.pos = self.pos.move(0, -self.step)
  27.         if event.key == K_DOWN:
  28.             self.pos = self.pos.move(0, self.step)
  29.         if event.key == 276:
  30.             self.pos = self.pos.move(-self.step, 0)
  31.         if event.key == 275:
  32.             self.pos = self.pos.move(self.step, 0)
  33.        
  34. avatar = image.load('player.bmp')

  35. # Инициируем игровой объект
  36. x = GameObj(avatar, 320, 220, 10)

  37. # Рисуем картинку объекта, в его координатах
  38. screen.blit(x.img, x.pos)

  39. # Запускаем бесконечный цикл, чтобы окно не схлопнулось после появления :)
  40. while 1:
  41.     for i in event.get(): # Перебор в списке событий
  42.         if i.type == QUIT: # Обрабатываем событие шечка по крестику закрытия окна
  43.             sys.exit()
  44.         if i.type == KEYDOWN:
  45.             screen.blit(background, x.pos, x.pos)
  46.             x._move(i)
  47.             screen.blit(x.img, x.pos)
  48.     # Обновляем изображение в окне, чтобы изменения в нем стали видны
  49.     display.flip()


Послесловие.

Собственно вот и все, коротко и сердито:) Полистав огромное колл-во игр, выложенных на оф. сайте, и обнаружив там настоящие 3д поделки — удивился и возрадовался одновременно)) Хоть я и не собираюсь покорять игродельческие вершины, но приятно, что любимый язык настолько многомерен. Если кому-то будет интересна эта тема, и у меня не пропадет желание записывать — то непременно будет продолжение).

Основы PyGame — Python Course documentation

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

Документация, обучающие материалы и дополнительная информация доступна разработчикам на сайте проекта: https://www.pygame.org/docs/

Начало работы

Начнем знакомство с библиотекой непосредственно с разбора примера простого приложения:

import pygame
import sys

pygame.init()

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

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

В первую очередь импортируем модуль pygame в наш файл с исходным кодом:

Затем вызываем функцию init() для подготовки модулей pygame к работе:

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

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

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

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

После того как ожидаемое событие наступило, завершаем работу с библиотекой pygame вызовом функции pygame.quit() и нашей программы вызовом функции exit() из модуля sys.

Рисование геометрических фигур

Разместим в окне нашего приложения прямоугольник. Прямоугольные объекты представлены типом Rect:

Rect(left, top, width, height)
Rect((left, top), (width, height))

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

Обратите внимание, что начало координат (0, 0) находится в левом верхнем углу окна.

В библиотеке pygame функции отображения геометрических фигур находятся в модуле draw. Нарисуем прямоугольник c помощью функции rect():

rect(Surface, color, Rect, width=0) -> Rect

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

Рассмотрим готовый пример:

import pygame
import sys

pygame.init()

screen = pygame.display.set_mode((1000, 800))
r = pygame.Rect(50, 50, 100, 200)
pygame.draw.rect(screen, (255, 0, 0), r, 0)

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.q

Создание игр на Python 3 и Pygame: Часть 1 / Хабр

Многие разработчики приходят в разработку ПО, потому что хотят создавать игры. Не все могут стать профессиональными разработчиками игр, но любой может создавать собственные игры из интереса (а может быть, и с выгодой). В этом туториале, состоящем из пяти частей, я расскажу вам, как создавать двухмерные однопользовательские игры с помощью Python 3 и замечательного фреймворка PyGame.

(Остальные части туториала: вторая, третья, четвёртая, пятая.)

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

Мы реализуем следующие функции и возможности:

  • простые стандартные GameObject и TextObject
  • простой стандартный Game object
  • простая стандартная кнопка
  • файл конфигурации
  • обработка событий клавиатуры и мыши
  • кирпичи, ракетка и мяч
  • управление движением ракетки
  • обработка коллизий мяча с объектами игры
  • фоновое изображение
  • звуковые эффекты
  • расширяемая система спецэффектов

Не стоит ожидать, что игра будет очень красива графически. Я программист, а не художник, меня больше интересует эстетика кода. Созданный мной дизайн может неприятно удивить. С другой стороны, у вас будут почти неограниченные возможности по улучшению графики этой версии Breakout. Если вы отважитесь повторять за мной, посмотрите на скриншот:
Готовый исходный код выложен здесь.

Краткое введение в программирование игр


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

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


Основной цикл (main loop) игры выполняется и обновляет экран через фиксированные интервалы времени. Они называются частотой кадров и определяют плавность перемещения. Обычно игры обновляют экран 30-60 раз в секунду. Если частота будет меньше, то покажется, что объекты на экране дёргаются.

Внутри основного цикла есть три основных операции: обработка событий, обновление состояния игры и отрисовка текущего состояния на экране.

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


События в игре состоят из всего, что происходит за пределами управления кода игры, но относится к выполнению игры. Например, если в Breakout игрок нажимает клавишу «стрелка влево», то игре нужно переместить ракетку влево. Стандартными событиями являются нажатия (и отжатия) клавиш, движение мыши, нажатия кнопок мыши (особенно в меню) и события таймера (например, действие спецэффекта может длиться 10 секунд).

Обновление состояния


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

Существует также вспомогательное состояние, позволяющее управлять игрой:

  • Отображается ли сейчас меню?
  • Закончена ли игра?
  • Победил ли игрок?

Отрисовка


Игре нужно отображать своё состояние на экране, в том числе отрисовывать геометрические фигуры, изображения и текст.

Игровая физика


В большинстве игр симулируется физическое окружение. В Breakout мяч отскакивает от объектов и имеет очень приблизительную систему физики твёрдого тела (если это можно так назвать).

В более сложных играх могут использоваться более изощрённые и реалистичные физические системы (особенно в 3D-играх). Стоит также отметить, что в некоторых играх, например, в карточных, физики почти нет, и это совершенно нормально.

ИИ (искусственный интеллект)


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

Например, враги преследуют игрока и знают о его местоположении. В Breakout нет никакого ИИ. Игрок сражается с холодными и твёрдыми кирпичами. Однако ИИ в играх часто очень прост и всего лишь следует простым (или сложным) правилам, обеспечивающим псевдоразумные результаты.

Воспроизведение звука


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

Фоновая музыка — это просто музыка, постоянно играющая на фоне. В некоторых играх она не используется, а в некоторых меняется на каждом уровне.

Жизни, очки и уровни


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

Знакомство с Pygame


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

Что такое Pygame?


Pygame — это фреймворк языка Python для программирования игр. Он создан поверх SDL и обладает всем необходимым:
  • зрелостью
  • хорошим сообществом
  • открытым исходным кодом
  • кроссплатформенностью
  • качественной документацией
  • множеством примеров игр
  • простотой изучения

Установка Pygame


Введите pip install pygame, чтобы установить фреймворк. Если вам нужно что-то ещё, то следуйте инструкциям из раздела Getting Started в Wiki проекта. Если у вас, как и у меня, macOS Sierra, то могут возникнуть проблемы. Мне удалось установить Pygame без сложностей, и код работает отлично, но окно игры никогда не появляется.

Это станет серьёзным препятствием при запуске игры. В конце концов мне пришлось запускать её в Windows внутри VirtualBox VM. Надеюсь, ко времени прочтения этой статьи проблема будет решена.

Архитектура игры


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

Структура папок и файлов

├── Pipfile
├── Pipfile.lock
├── README.md
├── ball.py
├── breakout.py
├── brick.py
├── button.py
├── colors.py
├── config.py
├── game.py
├── game_object.py
├── images
│   └── background.jpg
├── paddle.py
├── sound_effects
│   ├── brick_hit.wav
│   ├── effect_done.wav
│   ├── level_complete.wav
│   └── paddle_hit.wav
└── text_object.py

Pipfile и Pipfile.lock — это современный способ управления зависимостями в Python. Папка images содержит изображения, используемые игрой (в нашей версии будет только фоновое изображение), а в папке sound_effects directory лежат короткие звуковые клипы, используемые (как можно догадаться) в качестве звуковых эффектов.

Файлы ball.py, paddle.py и brick.py содержат код, относящийся к каждому из этих объектов Breakout. Подробнее я рассмотрю их в следующих частях туториала. Файл text_object.py содержит код отображения текста на экране, а в файле background.py содержится игровая логика Breakout.

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

Класс GameObject


GameObject представляет собой визуальный объект, знающий о том, как себя рендерить, сохранять свои границы и перемещаться. В Pygame есть и класс Sprite, исполняющий похожую роль, но в этом туториале я хочу показать вам, как всё работает на низком уровне, а не полагаться слишком активно на готовую магию. Вот как выглядит класс GameObject:
from pygame.rect import Rect


class GameObject:
    def __init__(self, x, y, w, h, speed=(0,0)):
        self.bounds = Rect(x, y, w, h)
        self.speed = speed

    @property
    def left(self):
        return self.bounds.left

    @property
    def right(self):
        return self.bounds.right

    @property
    def top(self):
        return self.bounds.top

    @property
    def bottom(self):
        return self.bounds.bottom

    @property
    def width(self):
        return self.bounds.width

    @property
    def height(self):
        return self.bounds.height

    @property
    def center(self):
        return self.bounds.center

    @property
    def centerx(self):
        return self.bounds.centerx

    @property
    def centery(self):
        return self.bounds.centery

    def draw(self, surface):
        pass

    def move(self, dx, dy):
        self.bounds = self.bounds.move(dx, dy)

    def update(self):
        if self.speed == [0, 0]:
            return

        self.move(*self.speed)

GameObject предназначен для того, чтобы быть базовым классом для других объектов. Он непосредственно раскрывает множество свойств его прямоугольника self.bounds, а в своём методе update() он перемещает объект в соответствии с его текущей скоростью. Он ничего не делает в своём методе draw(), который должен быть переопределён подклассами.

Класс Game


Класс Game — это ядро игры. Он выполняется в основном цикле. В нём есть множество полезных возможностей. Давайте разберём его метод за методом.

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

Элемент self.objects хранит все игровые объекты, которые должны рендериться и обновляться. Различные обработчики управляют списками функций-обработчиков, которые должны выполняться при определённых событиях.

import pygame
import sys

from collections import defaultdict


class Game:
    def __init__(self, 
                 caption, 
                 width, 
                 height, 
                 back_image_filename, 
                 frame_rate):
        self.background_image = \
            pygame.image.load(back_image_filename)
        self.frame_rate = frame_rate
        self.game_over = False
        self.objects = []
        pygame.mixer.pre_init(44100, 16, 2, 4096)
        pygame.init()
        pygame.font.init()
        self.surface = pygame.display.set_mode((width, height))
        pygame.display.set_caption(caption)
        self.clock = pygame.time.Clock()
        self.keydown_handlers = defaultdict(list)
        self.keyup_handlers = defaultdict(list)
        self.mouse_handlers = []

Методы update() и draw() очень просты. Они обходят все управляемые игровые объекты и вызывают соответствующие им методы. Если два объекта накладываются друг на друга на экране, то порядок списка объектов определяет, какой из них будет рендериться первым, а остальные будут частично или полностью его перекрывать.
    def update(self):
        for o in self.objects:
            o.update()

    def draw(self):
        for o in self.objects:
            o.draw(self.surface)

Метод handle_events() слушает события, генерируемые Pygame, такие как события клавиш и мыши. Для каждого события он вызывает все функции-обработчики, которые должны обрабатывать события соответствующих типов.
    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            elif event.type == pygame.KEYDOWN:
                for handler in self.keydown_handlers[event.key]:
                    handler(event.key)
            elif event.type == pygame.KEYUP:
                for handler in self.keydown_handlers[event.key]:
                    handler(event.key)
            elif event.type in (pygame.MOUSEBUTTONDOWN, 
                                pygame.MOUSEBUTTONUP, 
                                pygame.MOUSEMOTION):
                for handler in self.mouse_handlers:
                    handler(event.type, event.pos)

Наконец, метод run() выполняет основной цикл. Он выполняется до тех пор, пока элемент game_over не принимает значение True. В каждой итерации он рендерит фоновое изображение и вызывает по порядку методы handle_events(), update() и draw().

Затем он обновляет экран, то есть записывает на физический дисплей всё содержимое, которое было отрендерено на текущей итерации. И последнее, но не менее важное — он вызывает метод clock.tick() для управления тем, когда будет вызвана следующая итерация.

    def run(self):
        while not self.game_over:
            self.surface.blit(self.background_image, (0, 0))

            self.handle_events()
            self.update()
            self.draw()

            pygame.display.update()
            self.clock.tick(self.frame_rate)

Заключение


В этой части мы изучили основы программирования игр и все компоненты, участвующие в создании игр. Также мы рассмотрели сам Pygame и узнали, как его установить. Наконец, мы погрузились в архитектуру игры и изучили структуру папок, классы GameObject и Game.

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

Главная страница Pygame — документация pygame v2.0.0.dev7

Главная страница Pygame — документация pygame v2.0.0.dev7

Документы

Ознакомительные сведения
Основная информация о pygame: что это такое, кто участвует и где его найти.
Установить
шагов, необходимых для компиляции pygame на нескольких платформах. Также поможет найти и установить готовые двоичные файлы для вашей системы.
Аргументы функции пути к файлу
Как pygame обрабатывает пути в файловой системе.
Лицензия LGPL
Это лицензия, под которой распространяется Pygame. Он предусматривает распространение pygame с открытым исходным кодом и коммерческим программным обеспечением. Обычно, если pygame не изменен, его можно использовать с любым типом программ.

Учебники

Введение в Pygame
Введение в основы pygame. Это написано для пользователей Python и опубликовано во втором томе журнала Py.
Импорт и инициализация
Первые шаги по импорту и инициализации pygame.Пакет pygame состоит из нескольких модулей. Некоторые модули включены не во все платформы.
Как переместить изображение?
Базовое руководство, охватывающее концепции компьютерной 2D-анимации. Информация о рисовании и удалении объектов, чтобы они выглядели анимированными.
Учебное пособие по шимпанзе, строка за строкой
Примеры pygame включают простую программу с интерактивным кулаком и шимпанзе. Это было навеяно раздражающим флэш-баннером начала 2000-х.В этом руководстве исследуется каждая строка кода, использованная в примере.
Введение в модуль спрайтов
Pygame включает модуль спрайтов более высокого уровня для помощи в организации игр. Модуль спрайтов включает несколько классов, которые помогают управлять деталями практически во всех типах игр. Классы Sprite немного более продвинуты, чем обычные модули pygame, и нужно больше понимания для правильного использования.
Surfarray Введение
Pygame использовал модуль Python NumPy для обеспечения эффективных эффектов на пиксель на изображениях.Использование массивов поверхностей — это расширенная функция, позволяющая настраивать эффекты и фильтры. Здесь также исследуются некоторые простые эффекты из примера pygame, arraydemo.py.
Обзор модуля камеры
Pygame, начиная с версии 1.9, имеет модуль камеры, который позволяет снимать изображения, смотреть прямые трансляции и пользоваться компьютерным зрением. В этом руководстве рассматриваются эти варианты использования.
Руководство для новичков
Список из тринадцати полезных советов, которые помогут людям освоиться с pygame.
Учебное пособие по созданию игр
Большой учебник, охватывающий более важные темы, необходимые для создания игры.
Режимы отображения
Получение отображаемой поверхности для экрана.

Редактировать на GitHub .

Работа с текстом — документация Pygame tutorial 2019

В pygame текст не может быть записан прямо на экран. Первый шаг для создания объекта Font с заданным размером шрифта. Второй шаг — визуализировать текст в изображение с заданным цветом. Третий шаг — вывести изображение на экран. Это шаги:

 font = pygame.font.SysFont (Нет, 24)
img = font.render ('привет', правда, СИНИЙ)
screen.blit (img, (20, 20))
 

После создания шрифта его размер изменить нельзя.Объект Font используется для создания объекта Surface из строки. Pygame не обеспечивают прямой способ записи текста на объект Surface . Метод render () должен быть используется для создания объекта Surface из текста, который затем может быть перенесен на экран. Метод render () может отображать только отдельные строки. Символ новой строки не отображается.

Инициализировать шрифт

Инициализация шрифта может занять несколько секунд.На MacBook Air создание Системный объект Font:

 t0 = время. Время ()
font = pygame.font.SysFont (Нет, 48)
print ('время, необходимое для создания шрифта:', time.time () - t0)
 

заняло более 8 секунд:

 время, необходимое для создания шрифта: 8.230187892913818
 

Функция get_fonts () возвращает список всех установленных шрифтов. Следующий код проверяет, какие шрифты есть в вашей системе и сколько, и выводит их на консоль:

 шрифтов = pygame.font.get_fonts ()
печать (len (шрифты))
для f в шрифтах:
    печать (е)
 

Вы получите что-то вроде этого:

 344
bigcaslonttf
Silomttf
sfnsdisplayblackitalicotf
chalkdusterttf
...
 

Вывести текст

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

 img = font.render (sysfont, True, RED)
rect = img.get_rect ()
pygame.draw.rect (img, СИНИЙ, rect, 1)
 

Затем мы создаем еще два шрифта: Chalkduster и Didot размером 72 балла.Рендерим текст обоими шрифтами:

 font1 = pygame.font.SysFont ('chalkduster.ttf', 72).
img1 = font1.render ('chalkduster.ttf', Истина, СИНИЙ)

font2 = pygame.font.SysFont ('didot.ttc', 72)
img2 = font2.render ('didot.ttc', True, ЗЕЛЕНЫЙ)
 

Наконец, текстовые изображения отображаются на экране как обычные изображения:

 screen.fill (фон)
screen.blit (img, (20, 20))
screen.blit (img1, (20, 50))
screen.blit (img2, (20, 120))
pygame.display.update ()
 

Это результат:

Вот полный код.

 "" "Нарисовать текст на экране." ""
импортировать pygame
из импорта pygame.locals *
время импорта
 
ЧЕРНЫЙ = (0, 0, 0)
КРАСНЫЙ = (255; 0; 0)
ЗЕЛЕНЫЙ = (0, 255, 0)
СИНИЙ = (0, 0, 255)
СЕРЫЙ = (200, 200, 200)

pygame.init ()
экран = pygame.display.set_mode ((640, 240))

sysfont = pygame.font.get_default_font ()
print ('системный шрифт:', sysfont)

t0 = время. время ()
font = pygame.font.SysFont (Нет, 48)
print ('время, необходимое для создания шрифта:', time.time () - t0)

img = font  
.

pygame.key — документация pygame v2.0.0.dev7

модуль pygame для работы с клавиатурой

Этот модуль содержит функции для работы с клавиатурой.

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

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

Игра pygame.Событие KEYDOWN имеет дополнительные атрибуты unicode и скан-код .

  • unicode : односимвольная строка, которая полностью переведена введенный символ, при этом учитываются клавиши Shift и композиция
  • скан-код : код клавиши для конкретной платформы, который может отличаться от с клавиатуры на клавиатуру, но полезно для выбора необычных клавиш, таких как мультимедийные клавиши

Новое в pygame 2.0.0: событие pygame.TEXTINPUT предпочтительнее атрибута unicode из pygame.KEYDOWN . Атрибут , текст содержит ввод.

Ниже приводится список всех констант (из pygame.locals констант pygame), используемых для представляют собой клавиши клавиатуры.

 pygame
Постоянное описание ASCII
---------------------------------
K_BACKSPACE \ b backspace
K_TAB \ t вкладка
K_CLEAR очистить
K_RETURN \ r возврат
K_PAUSE пауза
K_ESCAPE ^ [escape
K_SPACE пробел
K_EXCLAIM! воскликнуть
K_QUOTEDBL "quotedbl
K_HASH # хэш
K_DOLLAR $ доллар
K_AMPERSAND и амперсанд
K_QUOTE цитата
K_LEFTPAREN (левая скобка
K_RIGHTPAREN) правая скобка
K_ASTERISK * звездочка
K_PLUS + знак плюса
K_COMMA, запятая
K_MINUS - знак минус
K_PERIOD.период
K_SLASH / косая черта
К_0 0 0
К_1 1 1
К_2 2 2
К_3 3 3
К_4 4 4
К_5 5 5
К_6 6 6
К_7 7 7
К_8 8 8
К_9 9 9
K_COLON: двоеточие
K_SEMICOLON; точка с запятой
K_LESS <знак меньше
K_EQUALS = знак равенства
K_GREATER> знак больше
K_QUESTION? вопросительный знак
K_AT @ at
K_LEFTBRACKET [левая квадратная скобка
K_BACKSLASH \ обратная косая черта
K_RIGHTBRACKET] правая скобка
K_CARET ^ каретка
K_UNDERSCORE _ подчеркивание
K_BACKQUOTE `могила
К_а а а
К_б б б
K_c c c
Кід д д
Кіе е е
К_ф ф ф
Кг г г
К_ч ч ч
К_и я я
K_j j j
Кік к к
Кіл л л
Кім м м
Кін н н
К_о о о
Кіп п п
K_q q q
Кір р р
Кіс с с
К_т т т
K_u u u
Ків в в
K_w w w
К_х х х
К_й у у
K_z z z
K_DELETE удалить
K_KP0 клавиатура 0
K_KP1 клавиатура 1
К_КП2 клавиатура 2
К_КП3 клавиатура 3
К_КП4 клавиатура 4
K_KP5 клавиатура 5
K_KP6 клавиатура 6
К_КП7 клавиатура 7
K_KP8 клавиатура 8
K_KP9 клавиатура 9
K_KP_PERIOD.период клавиатуры
K_KP_DIVIDE / разделение клавиатуры
K_KP_MULTIPLY * клавиатура умножить
K_KP_MINUS - минус клавиатуры
K_KP_PLUS + клавиатура плюс
K_KP_ENTER \ r клавиатура ввод
K_KP_EQUALS = клавиатура равно
K_UP стрелка вверх
K_DOWN стрелка вниз
K_RIGHT стрелка вправо
K_LEFT стрелка влево
K_INSERT вставить
K_HOME домой
K_END конец
K_PAGEUP страница вверх
K_PAGEDOWN на страницу вниз
K_F1 F1
K_F2 F2
K_F3 F3
K_F4 F4
K_F5 F5
K_F6 F6
K_F7 F7
K_F8 F8
K_F9 F9
K_F10 F10
K_F11 F11
K_F12 F12
K_F13 F13
K_F14 F14
K_F15 F15
K_NUMLOCK numlock
K_CAPSLOCK capslock
K_SCROLLOCK прокрутка
K_RSHIFT правый сдвиг
K_LSHIFT сдвиг влево
K_RCTRL правый элемент управления
K_LCTRL левый элемент управления
K_RALT правый alt
K_LALT левый alt
K_RMETA правая мета
K_LMETA оставил мета
K_LSUPER левая клавиша Windows
K_RSUPER правая клавиша Windows
K_MODE сдвиг режима
K_HELP помощь
Экран печати K_PRINT
K_SYSREQ sysrq
K_BREAK перерыв
K_MENU меню
K_POWER мощность
K_EURO евро
 

На клавиатуре также есть список состояний модификаторов (из pygame.locals константы pygame), могут быть собраны путем побитового ИЛИ их вместе.

 pygame
Постоянное описание
-------------------------
KMOD_NONE не нажаты клавиши-модификаторы
KMOD_LSHIFT сдвиг влево
KMOD_RSHIFT сдвиг вправо
KMOD_SHIFT сдвиг влево или вправо или оба
KMOD_LCTRL левый элемент управления
KMOD_RCTRL правый элемент управления
KMOD_CTRL левый элемент управления или правый элемент управления или оба
KMOD_LALT левый alt
KMOD_RALT правый alt
KMOD_ALT левый альт или правый альт или оба
KMOD_LMETA левая мета
KMOD_RMETA правая мета
KMOD_META левая мета или правая мета или оба
KMOD_CAPS Caps Lock
KMOD_NUM num lock
KMOD_MODE AltGr
 

Информация о модификаторе содержится в атрибуте mod pygame.KEYDOWN и pygame.KEYUP событий. Атрибут mod является битовая маска всех клавиш-модификаторов, которые были в нажатом состоянии, когда событие произошло. Информация о модификаторе может быть декодирована с помощью побитового И (кроме для KMOD_NONE , которое следует сравнивать, используя равно == ). Например:

 для события в pygame.event.get ():
    если event.type == pygame.KEYDOWN или event.type == pygame.KEYUP:
        если event.mod == pygame.KMOD_NONE:
            print ('При этом ни одна из клавиш-модификаторов не была нажата'
                  событие произошло.')
        еще:
            если event.mod и pygame.KMOD_LSHIFT:
                print ('Левый сдвиг находился в нажатом состоянии, когда это событие'
                      'произошло.')
            если event.mod и pygame.KMOD_RSHIFT:
                print ('Правый сдвиг был в нажатом состоянии, когда это событие'
                      'произошло.')
            если event.mod и pygame.KMOD_SHIFT:
                print ('Сдвиг влево или вправо или оба были в'
                      'нажатое состояние, когда это событие произошло.')
 
.

pygame.draw — документация pygame v2.0.0.dev7

Параметры:
  • поверхность ( Поверхность ) — поверхность для рисования
  • цвет ( Цвет или int или кортеж ( int , int , int , [ int ] ) ) ) — цвет для рисования, альфа-значение необязательно при использовании кортеж (RGB [A])
  • rect ( Rect ) — прямоугольник для рисования, положение и размеры
  • ширина ( int ) —

    (необязательно) используется для толщины линии или для обозначения того, что прямоугольник должен быть заполнен (не путать со значением ширины параметра rect )

    , если width == 0 , (по умолчанию) заполнить прямоугольник

    , если width> 0 , используется для толщины линии

    если width <0 , ничего не будет отрисовано

    Примечание

    При использовании ширины значений > 1 линии края будут расти за пределами исходной границы прямоугольника.Подробнее о как увеличивается толщина краевых линий, см. примечания к ширине из pygame.draw.line () рисует функцию прямой линии.

  • border_radius ( int ) - (необязательно) используется для рисования прямоугольника с закругленными углами. Поддерживаемый диапазон: [0, мин (высота, ширина) / 2], где 0 представляет прямоугольник. без закругленных углов.
  • border_top_left_radius ( int ) - (необязательно) используется для установки значения верхнего левого угла граница.Если вы не установите это значение, оно будет использовать значение border_radius.
  • border_top_right_radius ( int ) - (необязательно) используется для установки значения верхнего правого угла граница. Если вы не установите это значение, оно будет использовать значение border_radius.
  • border_bottom_left_radius ( int ) - (необязательно) используется для установки значения нижнего левого угла граница. Если вы не установите это значение, оно будет использовать значение border_radius.
  • border_bottom_right_radius ( int ) -

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

    , если border_radius <1 , он будет рисовать прямоугольник без закругленных углов

    , если какой-либо из радиусов границы имеет значение <0 , он будет использовать значение border_radius

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

    получит масштабирование

.

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

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

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa