Руководство по pygame на русском

Время на прочтение
6 мин

Количество просмотров 58K

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

Что такое Pygame?

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

• Графика и анимация

• Звук (включая музыку)

• Управление (мышь, клавиатура, геймпад и так далее)

Игровой цикл

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

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

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

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

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

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

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

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

Время

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

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

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

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

# Pygame шаблон - скелет для нового проекта Pygame
import pygame
import random

WIDTH = 360  # ширина игрового окна
HEIGHT = 480 # высота игрового окна
FPS = 30 # частота кадров в секунду

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Контроль FPS

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

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

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

Итог

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

# Pygame шаблон - скелет для нового проекта Pygame
import pygame
import random

WIDTH = 360
HEIGHT = 480
FPS = 30
# Задаем цвета
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
# Создаем игру и окно
pygame.init()
pygame.mixer.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("My Game")
clock = pygame.time.Clock()
# Цикл игры
running = True
while running:
    # Держим цикл на правильной скорости
    clock.tick(FPS)
    # Ввод процесса (события)
    for event in pygame.event.get():
        # check for closing window
        if event.type == pygame.QUIT:
            running = False
<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; padding-left: 0px; color: rgb(152, 143, 129);" class="token comment"># Обновление</span>

<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; padding-left: 0px; color: rgb(152, 143, 129);" class="token comment"># Рендеринг</span>
screen<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">.</span>fill<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">(</span>BLACK<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">)</span>
<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; padding-left: 0px; color: rgb(152, 143, 129);" class="token comment"># После отрисовки всего, переворачиваем экран</span>
pygame<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">.</span>display<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">.</span>flip<span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">(</span><span style="box-sizing: border-box; font-weight: inherit !important; font-size: inherit; color: rgb(168, 160, 149);" class="token punctuation">)</span>

pygame.quit()

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

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

Python — самый популярный язык программирования нового поколения. Во всех новых областях компьютерных наук Python активно присутствует. Python имеет обширные библиотеки для различных областей, таких как машинное обучение (Numpy, Pandas, Matplotlib), искусственный интеллект (Pytorch, TensorFlow) и разработка игр (Pygame, Pyglet).

В этом уроке мы узнаем о разработке игр и рассмотрим возможности программирования с использованием Pygame (библиотека Python).

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

Прежде чем изучать pygame, нам нужно понять, какую игру мы хотим разработать. Чтобы изучить pygame, необходимо иметь базовые знания Python.

Установка pygame в Windows

Перед установкой Pygame в системе должен быть установлен Python, желательно версии 3.6.1 или выше, потому что она намного удобнее для новичков и, кроме того, работает быстрее. В основном есть два способа установить Pygame, которые приведены ниже:

1. Установка через pip. Хороший способ установить Pygame — использовать инструмент pip (применяется в Python для установки пакетов). Команда следующая:

 
py -m pip install -U pygame --user 

2. Установка через IDE. Второй способ — установить его через IDE, и здесь мы используем Pycharm IDE. Установка pygame в pycharm проста. Мы можем установить его, выполнив указанную выше команду в терминале или выполнив следующие шаги:

• Откройте вкладку «Файл» и нажмите «Настройки».

• Выберите интерпретатор проекта и щелкните значок +.

• Он отобразит окно поиска. Найдите pygame и нажмите кнопку установки пакета.

Чтобы проверить, правильно ли установлен pygame, в интерпретаторе IDLE введите следующую команду и нажмите Enter:

 
import pygame 

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

Установка pygame на Mac

Чтобы установить pygame на Mac, выполните следующие действия.

• Посетите официальный сайт pygame pygame.org и в следующем окне загрузите pygame-1.9.1release-python.org-32bit-py2.7-macosx10.3.dmg:

Примечание. Если вы используете другую версию Python, загрузите последнюю ссылку.

• Дважды щелкните загруженный файл и разархивируйте его. Теперь дважды щелкните распакованный файл mpkg, чтобы запустить программу установки. Следуйте инструкциям по установке pygame.
• Запустите терминал (Cmd+Пробел, затем введите «терминал» в поле поиска). В терминале введите «python2.7» и нажмите Enter.
• Python должен запуститься, отобразить версию 2.7.2 (2.7.1 тоже подойдет) и выдать подсказку. В командной строке Python введите «import pygame». Если вы не получаете никаких ошибок, все работает нормально.

Простой пример pygame

Вот простая программа pygame, которая дает общее представление о синтаксисе.

 
import pygame 
 
pygame.init() 
screen = pygame.display.set_mode((400,500)) 
done = False 
 
while not done: 
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT: 
            done = True 
    pygame.display.flip() 

Выход:

После успешного выполнения он выдаст следующее окно в качестве вывода:

Давайте разберемся с основным синтаксисом приведенной выше программы построчно:

• import pygame — обеспечивает доступ к фреймворку pygame и импортирует все функции pygame.
• pygame.init() — используется для инициализации всех необходимых модулей pygame.
• pygame.display.set_mode((width, height)) — используется для отображения окна нужного размера. Возвращаемое значение — это объект Surface, который является объектом, в котором мы будем выполнять графические операции.
• pygame.event.get() — очищает очередиь событий. Если мы не назовем это, оконные сообщения начнут накапливаться, и игра перестанет отвечать на запросы операционной системы.
• pygame.QUIT — используется для завершения события, когда мы нажимаем кнопку закрытия в углу окна.
• pygame.display.flip() — Pygame использует двойную буферизацию, поэтому буферы смещаются. Очень важно вызвать эту функцию, чтобы сделать видимыми любые обновления, которые вы делаете на игровом экране.

Surface Pygame

Поверхность pygame используется для отображения любого изображения. Pygame имеет предустановленное разрешение и формат пикселей. Цвет поверхности по умолчанию черный. Его размер определяется передачей аргумента размера.

Поверхности могут иметь ряд дополнительных атрибутов, таких как альфа-плоскости, цветовые ключи, отсечение исходного прямоугольника и другие. Подпрограммы blit будут пытаться использовать аппаратное ускорение, когда это возможно; в противном случае они будут использовать усовершенствованные методы копирования программного обеспечения.

Pygame часы

Время представлено в миллисекундах (1/1000 секунды) в pygame. Часы Pygame используются для отслеживания времени. Время необходимо для создания движения, воспроизведения звука или реакции на любое событие. В общем, мы не считаем время в секундах. Считаем в миллисекундах. Часы также предоставляют различные функции, помогающие контролировать частоту кадров в игре. Имеют несколько функций:

• tick()

Эта функция используется для обновления часов. Синтаксис следующий:

 
tick(framerate=0) 

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

• tick_busy_loop()

Функция tick_busy_loop() аналогична функции tick(). При вызове Clock.tick_busy_loop(20) один раз за кадр программа никогда не будет работать со скоростью более 20 кадров в секунду. Синтаксис следующий:

 
tick_busy_loop() 

• get_time()

get_time() используется для получения предыдущего тика. Число миллисекунд, которое isdra прошло между двумя последними вызовами в Clock.tick().

 
get_time() 

Что такое Pygame Blit в Python?

Блиттинг pygame в Python — это процесс рендеринга игрового объекта на поверхность, и этот процесс называется блиттингом. Когда мы создаем игровой объект, нам нужно его визуализировать. Если мы не отрендерим игровые объекты и не запустим программу, то на выходе она выдаст черное окно.

Блиттинг — одна из самых медленных операций в любой игре, поэтому нам нужно быть осторожными, чтобы не сильно блитить на экране в каждом кадре. Основная функция, используемая в блиттинге, — это blit(), а именно:

 
blit(source,dest,area=None,special_flags=0) 

Эта функция используется для вставки одного изображения в другое. Может быть размещена с аргументом dest. Аргумент dest может быть парой координат, представляющих левый верхний угол источника.

Добавление изображения

Чтобы добавить изображение в окно, сначала нам нужно создать пустую поверхность, вызвав конструктор Surface с кортежем ширины и высоты.

 
surface = pygame.Surface((100,100)) 

Приведенная выше строка создает пустое 24-битное изображение RGB размером 100*100 пикселей с черным цветом по умолчанию.

Для прозрачной инициализации Surface передайте аргумент SRCALPHA.

 
surface = pygame.Surface((100,100), pygame.SRCALPHA) 

Рассмотрим следующий пример для отображения изображения на поверхности:

 
import pygame 
pygame.init() 
white =(255, 255, 255) 
# assigning values to height and width variable  
height = 400 
width = 400 
# creating the display surface object  
# of specific dimension..e(X, Y).  
display_surface = pygame.display.set_mode((height, width)) 
 
# set the pygame window name  
pygame.display.set_caption('Image') 
 
# creating a surface object, image is drawn on it.  
image = pygame.image.load(r'C:UsersDEVANSH SHARMADesktopdownload.png') 
 
# infinite loop  
while True: 
    display_surface.fill(white) 
    display_surface.blit(image,(0, 0)) 
 
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT: 
            pygame.quit() 
            # quit the program.  
            quit() 
        # Draws the surface object to the screen.  
        pygame.display.update()  

Выход:

Прямоугольник в Pygame

Rect используется для рисования прямоугольника в Pygame. Pygame использует объекты Rect для хранения прямоугольных областей и управления ими. Rect может быть сформирован из комбинации значений left, top, width и height. Его также можно создать из объектов Python, которые уже являются Rect или имеют атрибут с именем «rect».

Функция rect() используется для изменения положения или размера прямоугольника. Он возвращает новую копию Rect с затронутыми изменениями. Никаких изменений в исходном прямоугольнике не происходит.

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

 
x,y 
top, left, right, bottom 
topleft, bottomleft, topright, bottomright 
midtop, midleft, midbottom, midright 
center, centerx, centery 
size, width, height 
w,h 

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

Если ширина или высота являются ненулевым значением Rect, то для ненулевого теста будет возвращено значение True. Некоторые методы возвращают Rect с размерами 0 для представления недопустимого прямоугольника.

Давайте создадим Rectangle в окне pygame, используя Rect:

 
import pygame 
 
pygame.init() 
screen = pygame.display.set_mode((400, 300)) 
done = False 
 
while not done: 
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT: 
            done = True 
    pygame.draw.rect(screen,(0, 125, 255), pygame.Rect(30, 30, 60, 60))   
 
    pygame.display.flip() 

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

Клавиши Pygame

Pygame KEYDOWN и KEYUP обнаруживают событие, если клавиша физически нажата и отпущена. KEYDOWN определяет нажатие клавиши, KEYUP определяет ее отпускание. Оба события (нажатие клавиши и отпускание клавиши) имеют два следующих атрибута:

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

Рассмотрим следующий пример нажатия и отпускания клавиши.

 
import pygame 
pygame.init() 
# sets the window title 
pygame.display.set_caption(u'Keyboard events') 
# sets the window size 
pygame.display.set_mode((400, 400)) 
 
while True: 
    # gets a single event from the event queue 
    event = pygame.event.wait() 
    # if the 'close' button of the window is pressed 
    if event.type == pygame.QUIT: 
        # stops the application 
        break 
    # Detects the 'KEYDOWN' and 'KEYUP' events 
    if event.type in(pygame.KEYDOWN, pygame.KEYUP): 
        # gets the key name 
        key_name = pygame.key.name(event.key) 
        # converts to uppercase the key name 
        key_name = key_name.upper() 
        # if any key is pressed 
        if event.type == pygame.KEYDOWN: 
            # prints on the console the key pressed 
            print(u'"{}" key pressed'.format(key_name)) 
        # if any key is released 
        elif event.type == pygame.KEYUP: 
            # prints on the console the released key 
            print(u'"{}" key released'.format(key_name)) 

Выход:

Давайте посмотрим на другой пример:

 
import pygame 
 
pygame.init() 
screen = pygame.display.set_mode((400, 300)) 
done = False 
is_blue = True 
x = 30 
y = 30 
 
while not done: 
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT: 
            done = True 
        if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: 
            is_blue = not is_blue 
 
    pressed = pygame.key.get_pressed() 
    if pressed[pygame.K_UP]: y -= 3 
    if pressed[pygame.K_DOWN]: y += 3 
    if pressed[pygame.K_LEFT]: x -= 3 
    if pressed[pygame.K_RIGHT]: x += 3 
 
    if is_blue: 
        color =(0, 128, 255) 
    else:  
        color =(255, 100, 0) 
    pygame.draw.rect(screen, color, pygame.Rect(x, y, 60, 60)) 
 
    pygame.display.flip() 

В приведенном выше коде прямоугольник будет отображаться в окне pygame.

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

Pygame Draw

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

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

• Объекты pygame.Color
• Триплет(RGB)(кортеж/список)
• Четверка(RGBA)(кортеж/список)
• Целочисленное значение, сопоставленное с пиксельным форматом поверхности.

Рисование прямоугольника

Следующие функции используются для рисования прямоугольника на заданной поверхности.

 
pygame.draw.rect(surface, color, rect) 
pygame.draw.rect(surface, color, rect, width=0) 

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• rect(Rect) – рисование прямоугольника, положение и размеры.
• width(int) — чтобы использовать толщину линии или указать, что прямоугольник заполнен, необязателен.

 
if width == 0,(default) fill the rectangle 
if width > 0, used for line thickness 
if width < 0, nothing will be drawn 

Рисование многоугольника

Следующие функции используются для рисования многоугольника на заданной поверхности.

• pygame.draw.polygon(surface,color,points)
• pygame.draw.polygon(surface, color, points, width=0)

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• points(tuple(coordinate) или list(coordinate)): последовательность из 3 или более(x, y) координат, составляющих вершины многоугольника. Каждая координата в последовательности должна быть кортежем/списком.

Примечание. – Если len(points) < 3 или точки не являются последовательностью или точки не содержат числовой пары, это вызовет ошибку значения.

Эллипс

Следующие функции используются для рисования эллипса на заданной поверхности.

 
pygame.draw.ellipse(surface, color, rect) 
pygame.draw.ellipse(surface, color, rect, width=0) 

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• rect(Rect) – рисование прямоугольника, положение и размеры.

Прямая линия

Этот метод используется для рисования прямой линии на заданной поверхности. Концовок нет.

 
pygame.draw.line(surface,color,start_pos,end_pos,width) 
pygame.draw.line(surface,color,start_pos,end_pos,width=1) 

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• start_pos — начальная позиция линии(x,y)
• end_pos — конечная позиция строки.

Круг

Ниже приведены функции, которые используются для рисования окружности на заданной поверхности.

• circle(surface, color, center, radius)
• circle(surface, color, center, radius, width=0)

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• center – центральная точка круга как последовательность двух int/float, например(x,y)
• radius(int или float) – радиус окружности, отсчитываемый от параметра center, если радиус равен нулю, то будет отрисовываться только центральный пиксель.

Эллиптическая дуга

Следующие функции используются для рисования эллиптической дуги на заданной поверхности.

 
?  arc(surface, color, rect, start_angle, stop_angle)  
?  arc(surface, color, rect, start_angle, stop_angle, width=1) 

Параметры:

• Surface — экран для рисования.
• color — этот аргумент используется для окрашивания заданной формы. Альфа-значение является необязательным, если мы используем кортеж.
• rect(Rect) – рисование прямоугольника, его положение и размеры.
• start_angle — начальный угол дуги в радианах.
• stop_angle — конечный угол дуги в радианах.

Есть три условия для параметров start_angle и stop_angle:

1. Если start_angle < stop_angle, то дуга будет нарисована против часовой стрелки от start_angle до end_angle.
2. Если start_angle>stop_angle, то tau(tau=2*pi) будет добавлено к углу остановки.
3. Если start_angle==stop_angle, ничего не будет нарисовано.

Рассмотрим пример:

 
import pygame 
from math import pi 
pygame.init() 
# size variable is using for set screen size 
size = [400, 300] 
screen = pygame.display.set_mode(size) 
pygame.display.set_caption("Example program to draw geometry") 
# done variable is using as flag  
done = False 
clock = pygame.time.Clock() 
while not done: 
    # clock.tick() limits the while loop to a max of 10 times per second. 
        clock.tick(10) 
 
    for event in pygame.event.get():  # User did something 
        if event.type == pygame.QUIT:  # If user clicked on close symbol  
            done = True  # done variable that we are complete, so we exit this loop 
 
    # All drawing code occurs after the for loop and but 
    # inside the main while done==False loop. 
 
    # Clear the default screen background and set the white screen background 
    screen.fill((0, 0, 0)) 
 
    # Draw on the screen a green line which is 5 pixels wide. 
    pygame.draw.line(screen,(0, 255, 0), [0, 0], [50, 30], 5) 
    # Draw on the screen a green line which is 5 pixels wide. 
    pygame.draw.lines(screen,(0, 0, 0), False, [[0, 80], [50, 90], [200, 80], [220, 30]], 5) 
 
    # Draw a rectangle outline 
    pygame.draw.rect(screen,(0, 0, 0), [75, 10, 50, 20], 2) 
 
    # Draw a solid rectangle 
    pygame.draw.rect(screen,(0, 0, 0), [150, 10, 50, 20]) 
 
    # This draw an ellipse outline, using a rectangle as the outside boundaries 
    pygame.draw.ellipse(screen,(255, 0, 0), [225, 10, 50, 20], 2) 
 
    # This draw a solid ellipse, using a rectangle as the outside boundaries 
    pygame.draw.ellipse(screen,(255, 0, 0), [300, 10, 50, 20]) 
 
    # Draw a triangle using the polygon function 
    pygame.draw.polygon(screen,(0, 0, 0), [[100, 100], [0, 200], [200, 200]], 5) 
 
    # This draw a circle 
    pygame.draw.circle(screen,(0, 0, 255), [60, 250], 40) 
 
    # This draw an arc 
    pygame.draw.arc(screen,(0, 0, 0), [210, 75, 150, 125], 0, pi / 2, 2) 
 
    # This function must write after all the other drawing commands. 
    pygame.display.flip() 
 
# Quite the execution when clicking on close 
pygame.quit() 

Выход:

Текст и шрифт Pygame

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

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

• render()

Эта функция используется для рисования текста на новой поверхности. Pygame не имеет возможности рисовать текст на существующей поверхности. Это создает новую поверхность с указанным текстовым рендерингом на ней. Синтаксис следующий:

 
render(text, antialias, color, background=None) 

• size()

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

 
size(bool) 

• set_bold()

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

 
set_bold(bool) 

Рассмотрим следующий пример:

 
import pygame 
pygame.init() 
screen = pygame.display.set_mode((640, 480)) 
done = False 
 
#load the fonts 
font = pygame.font.SysFont("Times new Roman", 72) 
# Render the text in new surface 
text = font.render("Hello, Pygame", True,(158, 16, 16)) 
while not done: 
    for event in pygame.event.get(): 
        if event.type == pygame.QUIT: 
            done = True 
        if event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE: 
            done = True 
    screen.fill((255, 255, 255)) 
    #We will discuss blit() in the next topic 
    screen.blit(text,(320 - text.get_width() // 2, 240 - text.get_height() // 2)) 
 
    pygame.display.flip() 

Выход:

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

 
 all_font = pygame.font.get_fonts() 

Существует еще одна функция для создания экземпляра системного шрифта по умолчанию:

 
font = pygame.font.Font(None,size) 

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

Pygame Sprite и обнаружение столкновений

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

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

Модуль Sprite содержит различные простые классы для использования в играх. Необязательно использовать классы Sprite и различные групповые классы при использовании pygame.

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

Рассмотрим следующий пример:

 
import pygame 
import sys 
#Sprite class  
class Sprite(pygame.sprite.Sprite): 
    def __init__(self, pos): 
        pygame.sprite.Sprite.__init__(self) 
        self.image = pygame.Surface([20, 20]) 
        self.image.fill((255, 0, 255)) 
        self.rect = self.image.get_rect() 
        self.rect.center = pos 
def main(): 
    pygame.init() 
    clock = pygame.time.Clock() 
    fps = 50 
    bg = [0, 0, 0] 
    size =[300, 300] 
    screen = pygame.display.set_mode(size) 
    player = Sprite([40, 50]) 
    # Define keys for player movement 
    player.move = [pygame.K_LEFT, pygame.K_RIGHT, pygame.K_UP, pygame.K_DOWN] 
    player.vx = 5 
    player.vy = 5 
 
    wall = Sprite([100, 60]) 
 
    wall_group = pygame.sprite.Group() 
    wall_group.add(wall) 
 
    player_group = pygame.sprite.Group() 
    player_group.add(player) 
 
    while True: 
        for event in pygame.event.get(): 
            if event.type == pygame.QUIT: 
                return False 
        key = pygame.key.get_pressed() 
        for i in range(2): 
            if key[player.move[i]]: 
                player.rect.x += player.vx * [-1, 1][i] 
 
        for i in range(2): 
            if key[player.move[2:4][i]]: 
                player.rect.y += player.vy * [-1, 1][i] 
        screen.fill(bg) 
        # first parameter takes a single sprite 
        # second parameter takes sprite groups 
        # third parameter is a kill command if true 
        hit = pygame.sprite.spritecollide(player, wall_group, True) 
        if hit: 
        # if collision is detected call a function to destroy 
            # rect 
            player.image.fill((255, 255, 255)) 
        player_group.draw(screen) 
        wall_group.draw(screen) 
        pygame.display.update() 
        clock.tick(fps) 
    pygame.quit() 
    sys.exit 
if __name__ == '__main__': 

Выход:

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

Pyglet

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

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

Вот несколько особенностей pyglet:

• Никаких внешних требований к установке или зависимостей.
• Воспользуйтесь преимуществами нескольких окон и нескольких мониторов.
• Он может загружать изображения, звук, музыку и видео в любом формате.
• Pyglet предоставляется под лицензией BSD с открытым исходным кодом.
• Он поддерживает как Python 2, так и 3.

Установка pyglet проста; его можно установить, введя следующую команду.

 
pip install pyglet 

Рассмотрим следующий пример.

 
import pyglet 
window = pyglet.window.Window() 
lable = pyglet.text.Label('Hello world', font_name='Times New Roman', font_size=36, 
                          x= window.width//2,y=window.height//2,anchor_x='center', anchor_y='center') 
@window.event 
def on_draw(): 
    window.clear() 
    lable.draw() 
pyglet.app.run() 

Выход:

Сравнение между Pygame и Pyglet

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

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

К концу этой статьи вы сможете:

Вы можете получить весь код в этой статье, чтобы следовать:

$ python3 -m pygame.examples.aliens

 1 # Simple pygame program
 2
 3 # Import and initialize the pygame library
 4 import pygame
 5 pygame.init()
 6
 7 # Set up the drawing window
 8 screen = pygame.display.set_mode([500, 500])
 9
10 # Run until the user asks to quit
11 running = True
12 while running:
13
14     # Did the user click the window close button?
15     for event in pygame.event.get():
16         if event.type == pygame.QUIT:
17             running = False
18
19     # Fill the background with white
20     screen.fill((255, 255, 255))
21
22     # Draw a solid blue circle in the center
23     pygame.draw.circle(screen, (0, 0, 255), (250, 250), 75)
24
25     # Flip the display
26     pygame.display.flip()
27
28 # Done! Time to quit.
29 pygame.quit()

 1 # Import the pygame module
 2 import pygame
 3
 4 # Import pygame.locals for easier access to key coordinates
 5 # Updated to conform to flake8 and black standards
 6 from pygame.locals import (
 7     K_UP,
 8     K_DOWN,
 9     K_LEFT,
10     K_RIGHT,
11     K_ESCAPE,
12     KEYDOWN,
13     QUIT,
14 )
15
16 # Initialize pygame
17 pygame.init()

 1 # Import the pygame module
 2 import pygame
 3
 4 # Import pygame.locals for easier access to key coordinates
 5 # Updated to conform to flake8 and black standards
 6 from pygame.locals import (
 7     K_UP,
 8     K_DOWN,
 9     K_LEFT,
10     K_RIGHT,
11     K_ESCAPE,
12     KEYDOWN,
13     QUIT,
14 )
15
16 # Initialize pygame
17 pygame.init()
18
19 # Define constants for the screen width and height
20 SCREEN_WIDTH = 800
21 SCREEN_HEIGHT = 600
22
23 # Create the screen object
24 # The size is determined by the constant SCREEN_WIDTH and SCREEN_HEIGHT
25 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

27 # Variable to keep the main loop running
28 running = True
29
30 # Main loop
31 while running:
32     # Look at every event in the queue
33     for event in pygame.event.get():
34         # Did the user hit a key?
35         if event.type == KEYDOWN:
36             # Was it the Escape key? If so, stop the loop.
37             if event.key == K_ESCAPE:
38                 running = False
39
40         # Did the user click the window close button? If so, stop the loop.
41         elif event.type == QUIT:
42             running = False

44 # Fill the screen with white
45 screen.fill((255, 255, 255))
46
47 # Create a surface and pass in a tuple containing its length and width
48 surf = pygame.Surface((50, 50))
49
50 # Give the surface a color to separate it from the background
51 surf.fill((0, 0, 0))
52 rect = surf.get_rect()

54 # This line says "Draw surf onto the screen at the center"
55 screen.blit(surf, (SCREEN_WIDTH/2, SCREEN_HEIGHT/2))
56 pygame.display.flip()

54 # Put the center of surf at the center of the display
55 surf_center = (
56     (SCREEN_WIDTH-surf.get_width())/2,
57     (SCREEN_HEIGHT-surf.get_height())/2
58 )
59
60 # Draw surf at the new coordinates
61 screen.blit(surf, surf_center)
62 pygame.display.flip()

20 # Define a Player object by extending pygame.sprite.Sprite
21 # The surface drawn on the screen is now an attribute of 'player'
22 class Player(pygame.sprite.Sprite):
23     def __init__(self):
24         super(Player, self).__init__()
25         self.surf = pygame.Surface((75, 25))
26         self.surf.fill((255, 255, 255))
27         self.rect = self.surf.get_rect()

55 # Fill the screen with black
56 screen.fill((0, 0, 0))
57
58 # Draw the player on the screen
59 screen.blit(player.surf, player.rect)
60
61 # Update the display
62 pygame.display.flip()

54 # Get the set of keys pressed and check for user input
55 pressed_keys = pygame.key.get_pressed()

29 # Move the sprite based on user keypresses
30 def update(self, pressed_keys):
31     if pressed_keys[K_UP]:
32         self.rect.move_ip(0, -5)
33     if pressed_keys[K_DOWN]:
34         self.rect.move_ip(0, 5)
35     if pressed_keys[K_LEFT]:
36         self.rect.move_ip(-5, 0)
37     if pressed_keys[K_RIGHT]:
38         self.rect.move_ip(5, 0)

52 # Main loop
53 while running:
54     # for loop through the event queue
55     for event in pygame.event.get():
56         # Check for KEYDOWN event
57         if event.type == KEYDOWN:
58             # If the Esc key is pressed, then exit the main loop
59             if event.key == K_ESCAPE:
60                 running = False
61         # Check for QUIT event. If QUIT, then set running to false.
62         elif event.type == QUIT:
63             running = False
64
65     # Get all the keys currently pressed
66     pressed_keys = pygame.key.get_pressed()
67
68     # Update the player sprite based on user keypresses
69     player.update(pressed_keys)
70
71     # Fill the screen with black
72     screen.fill((0, 0, 0))

25 # Move the sprite based on user keypresses
26 def update(self, pressed_keys):
27     if pressed_keys[K_UP]:
28         self.rect.move_ip(0, -5)
29     if pressed_keys[K_DOWN]:
30         self.rect.move_ip(0, 5)
31     if pressed_keys[K_LEFT]:
32         self.rect.move_ip(-5, 0)
33     if pressed_keys[K_RIGHT]:
34         self.rect.move_ip(5, 0)
35
36     # Keep player on the screen
37     if self.rect.left < 0:
38         self.rect.left = 0
39     if self.rect.right > SCREEN_WIDTH:
40         self.rect.right = SCREEN_WIDTH
41     if self.rect.top <= 0:
42         self.rect.top = 0
43     if self.rect.bottom >= SCREEN_HEIGHT:
44         self.rect.bottom = SCREEN_HEIGHT

 4 # Import random for random numbers
 5 import random

55 # Define the enemy object by extending pygame.sprite.Sprite
56 # The surface you draw on the screen is now an attribute of 'enemy'
57 class Enemy(pygame.sprite.Sprite):
58     def __init__(self):
59         super(Enemy, self).__init__()
60         self.surf = pygame.Surface((20, 10))
61         self.surf.fill((255, 255, 255))
62         self.rect = self.surf.get_rect(
63             center=(
64                 random.randint(SCREEN_WIDTH + 20, SCREEN_WIDTH + 100),
65                 random.randint(0, SCREEN_HEIGHT),
66             )
67         )
68         self.speed = random.randint(5, 20)
69
70     # Move the sprite based on speed
71     # Remove the sprite when it passes the left edge of the screen
72     def update(self):
73         self.rect.move_ip(-self.speed, 0)
74         if self.rect.right < 0:
75             self.kill()

82 # Create the 'player'
83 player = Player()
84
85 # Create groups to hold enemy sprites and all sprites
86 # - enemies is used for collision detection and position updates
87 # - all_sprites is used for rendering
88 enemies = pygame.sprite.Group()
89 all_sprites = pygame.sprite.Group()
90 all_sprites.add(player)
91
92 # Variable to keep the main loop running
93 running = True

117 # Fill the screen with black
118 screen.fill((0, 0, 0))
119
120 # Draw all sprites
121 for entity in all_sprites:
122     screen.blit(entity.surf, entity.rect)
123
124 # Flip everything to the display
125 pygame.display.flip()

78 # Create the screen object
79 # The size is determined by the constant SCREEN_WIDTH and SCREEN_HEIGHT
80 screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
81
82 # Create a custom event for adding a new enemy
83 ADDENEMY = pygame.USEREVENT + 1
84 pygame.time.set_timer(ADDENEMY, 250)
85
86 # Instantiate player. Right now, this is just a rectangle.
87 player = Player()

100 # Main loop
101 while running:
102     # Look at every event in the queue
103     for event in pygame.event.get():
104         # Did the user hit a key?
105         if event.type == KEYDOWN:
106             # Was it the Escape key? If so, stop the loop.
107             if event.key == K_ESCAPE:
108                 running = False
109
110         # Did the user click the window close button? If so, stop the loop.
111         elif event.type == QUIT:
112             running = False
113
114         # Add a new enemy?
115         elif event.type == ADDENEMY:
116             # Create the new enemy and add it to sprite groups
117             new_enemy = Enemy()
118             enemies.add(new_enemy)
119             all_sprites.add(new_enemy)
120
121     # Get the set of keys pressed and check for user input
122     pressed_keys = pygame.key.get_pressed()
123     player.update(pressed_keys)
124
125     # Update enemy position
126     enemies.update()

130 # Draw all sprites
131 for entity in all_sprites:
132     screen.blit(entity.surf, entity.rect)
133
134 # Check if any enemies have collided with the player
135 if pygame.sprite.spritecollideany(player, enemies):
136     # If so, then remove the player and stop the loop
137     player.kill()
138     running = False

 7 # Import pygame.locals for easier access to key coordinates
 8 # Updated to conform to flake8 and black standards
 9 # from pygame.locals import *
10 from pygame.locals import (
11     RLEACCEL,
12     K_UP,
13     K_DOWN,
14     K_LEFT,
15     K_RIGHT,
16     K_ESCAPE,
17     KEYDOWN,
18     QUIT,
19 )
20
21 # Define constants for the screen width and height
22 SCREEN_WIDTH = 800
23 SCREEN_HEIGHT = 600
24
25
26 # Define the Player object by extending pygame.sprite.Sprite
27 # Instead of a surface, use an image for a better-looking sprite
28 class Player(pygame.sprite.Sprite):
29     def __init__(self):
30         super(Player, self).__init__()
31         self.image = pygame.image.load("jet.png").convert()
32         self.image.set_colorkey((255, 255, 255), RLEACCEL)
33         self.rect = self.image.get_rect()

59 # Define the enemy object by extending pygame.sprite.Sprite
60 # Instead of a surface, use an image for a better-looking sprite
61 class Enemy(pygame.sprite.Sprite):
62     def __init__(self):
63         super(Enemy, self).__init__()
64         self.surf = pygame.image.load("missile.png").convert()
65         self.surf.set_colorkey((255, 255, 255), RLEACCEL)
66         # The starting position is randomly generated, as is the speed
67         self.rect = self.surf.get_rect(
68             center=(
69                 random.randint(SCREEN_WIDTH + 20, SCREEN_WIDTH + 100),
70                 random.randint(0, SCREEN_HEIGHT),
71             )
72         )
73         self.speed = random.randint(5, 20)

 83 # Define the cloud object by extending pygame.sprite.Sprite
 84 # Use an image for a better-looking sprite
 85 class Cloud(pygame.sprite.Sprite):
 86     def __init__(self):
 87         super(Cloud, self).__init__()
 88         self.surf = pygame.image.load("cloud.png").convert()
 89         self.surf.set_colorkey((0, 0, 0), RLEACCEL)
 90         # The starting position is randomly generated
 91         self.rect = self.surf.get_rect(
 92             center=(
 93                 random.randint(SCREEN_WIDTH + 20, SCREEN_WIDTH + 100),
 94                 random.randint(0, SCREEN_HEIGHT),
 95             )
 96
 97     # Move the cloud based on a constant speed
 98     # Remove the cloud when it passes the left edge of the screen
 99     def update(self):
100         self.rect.move_ip(-5, 0)
101         if self.rect.right < 0:
102             self.kill()

116 # Create custom events for adding a new enemy and a cloud
117 ADDENEMY = pygame.USEREVENT + 1
118 pygame.time.set_timer(ADDENEMY, 250)
119 ADDCLOUD = pygame.USEREVENT + 2
120 pygame.time.set_timer(ADDCLOUD, 1000)

125 # Create groups to hold enemy sprites, cloud sprites, and all sprites
126 # - enemies is used for collision detection and position updates
127 # - clouds is used for position updates
128 # - all_sprites is used for rendering
129 enemies = pygame.sprite.Group()
130 clouds = pygame.sprite.Group()
131 all_sprites = pygame.sprite.Group()
132 all_sprites.add(player)

137 # Main loop
138 while running:
139     # Look at every event in the queue
140     for event in pygame.event.get():
141         # Did the user hit a key?
142         if event.type == KEYDOWN:
143             # Was it the Escape key? If so, then stop the loop.
144             if event.key == K_ESCAPE:
145                 running = False
146
147         # Did the user click the window close button? If so, stop the loop.
148         elif event.type == QUIT:
149             running = False
150
151         # Add a new enemy?
152         elif event.type == ADDENEMY:
153             # Create the new enemy and add it to sprite groups
154             new_enemy = Enemy()
155             enemies.add(new_enemy)
156             all_sprites.add(new_enemy)
157
158         # Add a new cloud?
159         elif event.type == ADDCLOUD:
160             # Create the new cloud and add it to sprite groups
161             new_cloud = Cloud()
162             clouds.add(new_cloud)
163             all_sprites.add(new_cloud)

167 # Update the position of enemies and clouds
168 enemies.update()
169 clouds.update()
170
171 # Fill the screen with sky blue
172 screen.fill((135, 206, 250))

106 # Setup the clock for a decent framerate
107 clock = pygame.time.Clock()

188 # Flip everything to the display
189 pygame.display.flip()
190
191 # Ensure program maintains a rate of 30 frames per second
192 clock.tick(30)

106 # Setup for sounds. Defaults are good.
107 pygame.mixer.init()
108
109 # Initialize pygame
110 pygame.init()
111
112 # Set up the clock for a decent framerate
113 clock = pygame.time.Clock()

135 # Load and play background music
136 # Sound source: http://ccmixter.org/files/Apoxode/59262
137 # License: https://creativecommons.org/licenses/by/3.0/
138 pygame.mixer.music.load("Apoxode_-_Electric_1.mp3")
139 pygame.mixer.music.play(loops=-1)
140
141 # Load all sound files
142 # Sound sources: Jon Fincher
143 move_up_sound = pygame.mixer.Sound("Rising_putter.ogg")
144 move_down_sound = pygame.mixer.Sound("Falling_putter.ogg")
145 collision_sound = pygame.mixer.Sound("Collision.ogg")

26 # Define the Player object by extending pygame.sprite.Sprite
27 # Instead of a surface, use an image for a better-looking sprite
28 class Player(pygame.sprite.Sprite):
29     def __init__(self):
30         super(Player, self).__init__()
31         self.surf = pygame.image.load("jet.png").convert()
32         self.surf.set_colorkey((255, 255, 255), RLEACCEL)
33         self.rect = self.surf.get_rect()
34
35     # Move the sprite based on keypresses
36     def update(self, pressed_keys):
37         if pressed_keys[K_UP]:
38             self.rect.move_ip(0, -5)
39             move_up_sound.play()
40         if pressed_keys[K_DOWN]:
41             self.rect.move_ip(0, 5)
42             move_down_sound.play()

201 # Check if any enemies have collided with the player
202 if pygame.sprite.spritecollideany(player, enemies):
203     # If so, then remove the player
204     player.kill()
205
206     # Stop any moving sounds and play the collision sound
207     move_up_sound.stop()
208     move_down_sound.stop()
209     collision_sound.play()
210
211     # Stop the loop
212     running = False

220 # All done! Stop and quit the mixer.
221 pygame.mixer.music.stop()
222 pygame.mixer.quit()

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

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

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

pip3 install pygame

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

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

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

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

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

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

Рисование фигур

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

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

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

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

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

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

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 — радиус окружности в пикселях

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

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

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

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

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

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

Рисование прямоугольников

Для отрисовки прямоугольников можно использовать метод rect.

pygame.draw.rect(display, color, (x, y, width, height) )

color — цвет (теперь можно просто написать имя переменную)

(x, y, width, height) — кортеж из четырех значений. Первые два значения — это координаты верхнего левого угла прямоугольника, а два последних — это ширина и высота.

Если ваша творческая натура требует большего, то вот ссылка на документацию модулю draw

Там можно найти рисование линий, дуг, эллипсов.

Большой пример (запусти его у себя на компьтере:

Задания:

1. Нарисуйте дерево из minecraft, используя полученные знания

2. Нарисуйте оранжевую, красную, синию и фиолетовую звезды

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

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

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

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

 python -m pip install -U pygame --user

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

python -m pygame.examples.aliens

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

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

Игровой цикл

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

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

while True:
      # Code
      pygame.display.update()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Цвета

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

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

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

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

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

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

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

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

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

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

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

import pygame
from pygame.locals import *

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

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

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

 import random

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

pygame.init()

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

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

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

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

class Player(pygame.sprite.Sprite):
    def __init__(self):
        super().__init__() 
        self.image = pygame.image.load("Player.png")
        self.rect = self.image.get_rect()
        self.rect.center = (160, 520)

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

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

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

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

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

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

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

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

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

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

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

Игровой цикл

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

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

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

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

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

Заключение

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

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

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

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

Статья расскажет о том, какие преимущества и недостатки имеет соответствующий язык разработки, а также познакомит с Pygame – одним из мощнейших инструментов при создании the game. Также будут изучены уже написанные проекты.

Определение

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

Python – язык с динамической типизацией данных. Он является достаточно простым для изучения, благодаря чему его активно используют новички. The first game написать на Python будет не слишком трудно даже с минимальными знаниями.

Плюсы

Python является языком разработки со следующими преимуществами:

• стабильное функционирование;
• читабельный и простой код;
• элементарный синтаксис, в основе которого лежит язык ABC;
• универсальность – одинакового подходит как для the business apps, так и для игр;
• в небольших приложениях работает достаточно быстро;
• наличие динамической типизации.

У The Python имеется обширный спектр фреймворков, а также встроенных инструментов и библиотек. Все это помогает with the game programming.

Минусы

Недостатков у Питона не очень много. К ним относят:

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

Из-за «веса» получаемые games can be slowly. Приложения рискую медленно работать, а также сильно нагружать операционную систему устройства. Именно поэтому for the game programming Питон используется тогда, когда речь идет о не самых крупных проектах.

Игровой цикл

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

1. Ввод данных. Производится со стороны непосредственного пользователя.
2. Обновление кадра.
3. Визуализация. Эта операция отвечает за вывод изображения на экран. В процессе производится отрисовка элементов там, где они должны были располагаться по первоначальной задумке. 

In the big projects появляется искусственный интеллект и физика. Для создания полноценной игры нужно разобраться с воспроизведением звуков и музыки. Иногда в ней предусматривается набор очков, повышение уровня, а также индикаторы жизни.

The Pygame – мощный инструмент разработчика развлекательного программного обеспечения. Фреймворк (библиотека), совместимая с Python 3.0. Данный модуль вышел в 2000 году и стремительно развивался. Его поддержка производится по сей день.

Игры, созданные при помощи the Pygame – это масштабируемые проекты. Они одинаково хорошо запускаются on the mobile и ПК.

Модуль Pygame:

• является кроссплатформенным;
• обладает открытым исходным кодом;
• достаточно прост в изучении;
• имеет неплохую поддержку;
• обладает зрелой library.

Найти tutorial of the Pygame не составит особого труда – в сети полно документации (documents) и видео-гайдов. Данный модуль является обязательным для изучения всеми, кто планирует писать игры на Питоне. Это его ключевое предназначение.

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

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

Для того, чтобы использовать данный модуль, его нужно сначала инициализировать. Скачивается библиотека с сервиса pygame org. Здесь же можно найти documentation and tutorials по рассматриваемой «платформе».

Перед созданием проекта потребуется:

1. Изучить основы программирования to the Python language.
2. Использовать команду pip install pygame. Она отвечает за инициализацию.

Теперь можно формировать проект и редактировать его.

Пример приложения

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

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()

Здесь:

• import pygame отвечает за импорт libraries, включенный to the module;
• init() используется для подготовки модулей к работе;
• screen отвечает за создание графического окна, передав в set_mode() разрешение в качестве парный цифр;
• while True – основной цикл, перехватывающий событие закрытия основного графического окна посетителем.

После наступления желаемого события происходит завершение работы с библиотекой при помощи функции quit. Exit() отвечает за прекращение использования всего итогового приложения.

Рисование фигур

While running Pygame Platform, разработчикам может потребуется изображение геометрических фигур. Прямоугольные объекты представлены типом Rect:

Создать объект соответствующего типа in the program легко – нужно указать координаты левого верхнего угла прямоугольника, а также длины его сторон:

Здесь стоит обратить внимание на то, что начало координат расположено in the left corner окна, сверху. В изучаемой библиотеке функции отображения геометрических фигур расположены в модуле под названием draw.

Изначально все графические объекты, которые хочется разместить на основном экране, сначала попадают в специальный буфер of the platform. Отображение изменений производится при помощи функции flip.

Любой tutorial расскажет о функциях рисования графических фигур:

1. Line. Позволяет рисовать линию на поверхности с заданным цветом и началом. Также предусматривается конец в точке end_pos и возможность указания толщины линии.
2. Lines. Рисует линию, которая соединяет точки последовательности. Каждая из них представлена в приложении координатной парой. Если третий параметр (closed) – это true, конечная точка будет соединена с начальной.
3. Circle. Точка pos здесь – это центр. Если толщина линии будет равна нулю, окружность закрасится.
4. Ellipse. Функция, которую уроки по рассматриваемому модулю описывают как возможность нарисовать эллипс, ограниченный прямоугольником Rect. Если толщина линии равняется нулю, фигура будет закрашена.

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

Цвета

Цвета в модуле представлены моделью RGB. Посмотреть ее можно на Wikipedia org. Значение данного параметра задается в рамках диапазона от 0 до 255 включительно. Первая характеристика указывает на количество красного, вторая – зеленого, третья – голубого. Чем меньше значение, тем более темным окажется оттенок.

Вот несколько примеров, которые используют различные platforms:

• белый – (255, 255, 255);
• красный – (255, 0, 0);
• черный – (0, 0, 0).

Любой tutorial по Pygame в Python укажет на то, что модуль color включает в себя словарь – THECOLORS.

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

Текст и шрифт

Pygame documentation на сайте Питона org содержит данные о работе с текстом и шрифтами. Последние – это группы символов, которые объединены по стилистическому или иному признаку. Шрифты в библиотеке представлены типом под названием Font.

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

Здесь:

• параметр name отвечает за передачу функции имени шрифта;
• size – это размер «символов» в пунктах;
• bold и italic – особенности начертания.

Списки уже имеющихся шрифтов в системе удается получить при помощи команды get_fonts():

Теперь при помощи метода render для объекта Font нужно получить изображение с текстом. Последний передается методу built() для отрисовки на основном дисплее устройства:

Тест при обработке соответствующего кода будет располагаться по координатам (50, 50).

Класс GameObject

В официальной documentation рассматриваемого модуля выделяется объект GameObject. Он представлен визуальным элементом, который знает, как рендерить самого себя. Позволяет хранить границы и перемещаться. С аналогичными возможностями на изучаемой платформе есть класс Sprite. Новичкам он не нужен.

Этот код работает так:

1. GameObject согласно tutorial document используется в виде базового класса других объектов в играх.
2. Отвечает за разнообразие свойств прямоугольника.
3. Метод update() перемещает объект с установленной (текущей) скоростью.
4. Метод draw() должен определяется подклассами. Он ничего не предпринимает в программном коде.

Для создания собственной игры через «Пигейм»также потребуется знать the class Game.

Класс Game

Это – игровое ядро. Оно выполняется в основном цикле. Наделен полезными инструментами. Обладает такими методами:

1. Init. Используется за инициализацию Pygame, шрифтов, а также микшера звуков. Three вызова нужны, чтобы задействовать в исходном коде только нужные элементы, а также держать подсистемы под контролем. С его помощью создаются фоны, основная поверхность и таймер с поддержкой отображения частоты кадров.
2. Update и draw. Вызывают соответствующие методы. При наложении объектов на дисплее, порядок списка объектов будет определять, что рендерится изначально.
3. Handle_events(). Метод, за счет которого прослушиваются генерируемые события. Сюда можно отнести нажатие на кнопки мыши, а также события клавиш. Каждое действие вызывает все функции-обработки, которые проходят обработку событий.

Также используется метод run(). Он отвечает за работоспособность основного цикла. Используется до получения в значении game_over итога «ложь».

Готовые проекты – наглядные примеры

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

• EVE Online;
• Battlefield;
• Mount and Blade;
• Civilization 4.

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

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

Шаг 1: Установка необходимых инструментов

Первым шагом в создании игры на Python является установка необходимых инструментов. Вам понадобится установить Python, библиотеку Pygame и интегрированную среду разработки (IDE), такую как PyCharm или Visual Studio Code. Убедитесь, что у вас установлена последняя версия Python и Pygame.

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

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

В этом примере мы импортируем библиотеку Pygame, инициализируем ее и создаем экран размером 800 на 600 пикселей.

Шаг 3: Добавление спрайтов

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

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

Шаг 4: Обработка событий

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

В этом примере мы создаем цикл while, который обрабатывает события в игре. Мы проверяем каждое событие, чтобы убедиться, что оно не является событием завершения игры (QUIT). Затем мы проверяем, какие клавиши были нажаты, и обновляем координаты спрайта в соответствии с этими нажатиями. Мы также очищаем экран, рисуем спрайты и обновляем экран с помощью метода flip().

Шаг 5: Добавление коллизий

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

В этом примере мы создаем класс Enemy и добавляем его в группу спрайтов. Затем мы проверяем коллизии между игроком и врагом с помощью метода collide_rect(). Если происходит столкновение, мы выводим сообщение в консоль.

Шаг 6: Добавление звука и музыки

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

В этом примере мы инициализируем модуль pygame.mixer для работы с звуком и загружаем музыкальный файл и звуковой эффект. Мы используем метод play() для воспроизведения музыки и звукового эффекта.

Шаг 7: Добавление меню и интерфейса

Чтобы игрок мог начать игру и управлять ею, нам нужно создать меню и интерфейс пользователя (UI). Для этого мы можем использовать модуль pygame_gui, который предоставляет инструменты для создания пользовательского интерфейса.

В этом примере мы создаем окно и менеджер GUI, а затем создаем кнопку «Play». Мы также создаем цикл обработки событий, который обрабатывает события GUI и pygame. Мы обновляем менеджер GUI и отрисовываем интерфейс пользователя.

Шаг 8: Добавление сохранения и загрузки

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

Чтобы наша игра была более интересной и вызывала больше эмоций, мы можем добавить искусственный интеллект (AI), который будет управлять поведением некоторых объектов в игре. Например, мы можем создать противника, который будет убегать от игрока или атаковать его.

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

В этом примере мы добавляем отладку с помощью pdb. Мы также добавляем команды print() для отображения значений переменных в консоли.

Шаг 11: Оптимизация и улучшение производительности

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

Некоторые способы оптимизации:

Шаг 12: Публикация игры

После того, как игра полностью готова и протестирована, мы можем опубликовать ее на различных платформах, таких как Steam, App Store или Google Play.

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

Заключение

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