Как написать самую легкую игру на питон
Перейти к содержимому

Как написать самую легкую игру на питон

  • автор:

Пишем простую игру на python

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

from tkinter import * import random as rdm class Main(Frame): def __init__(self, root): super(Main, self).__init__(root) self.startUI() def startUI(self): pass if __name__ == '__main__': root = Tk() root.geometry("500x500+200+200") root.title("Камень, ножницы, бумага") root.resizable(False, False) root["bg"] = "#FFF" app = Main(root) app.pack() root.mainloop() 

Здесь мы создаём неизменяемое окно 500 на 500 с заголовком «Камень, ножницы, бумага» и белым фоном. Именно в это окошко мы будем добавлять кнопочки, счетчики и т.д.

Теперь в наш метод startUI добавим такие строчки:

btn = Button(root, text="Камень", font=("Times New Roman", 15)) btn = Button(root, text="Ножницы", font=("Times New Roman", 15)) btn3 = Button(root, text="Бумага", font=("Times New Roman", 15)) btn.place(x=10, y=100, width=120, height=50) btn2.place(x=155, y=100, width=120, height=50) btn3.place(x=300, y=100, width=120, height=50) 

Эти 7 строчек добавят в наше окно 3 кнопки которые нечего не делают. Мы исправим это позже.

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

А вот теперь мы добавим функцию, которая будет обрабатывать выбор, и выдавать ответ, кто же выиграл в этом раунде. Сделаем это вот таким образом:

btn = Button(root, text="Камень", font=("Times New Roman", 15), command=lambda x=1: self.btn_click(x)) btn2 = Button(root, text="Ножницы", font=("Times New Roman", 15), command=lambda x=2: self.btn_click(x)) btn3 = Button(root, text="Бумага", font=("Times New Roman", 15), command=lambda x=3: self.btn_click(x)) 

Что тут происходит?

Всё очень просто. Грубо говоря, если игрок нажмет камень, отправится 1, если ножницы, то 2, а если бумага, то 3, причем не только отправится, но и выведется в консоль.
На счет компьютера. Он свой выбор делает, но его выбор никуда не идёт.

Перед тем, как делать логику, нам нужно передать игроку результат, и для этого мы будем использовать Label. Добавим в startUI такие строчки:

self.lbl = Label(root, text="Начало игры!", bg="#FFF", font=("Times New Roman", 21, "bold")) self.lbl.place(x=120, y=25) self.lbl2 = Label(root, justify="left", font=("Times New Roman", 13), text=f"Побед: \nПроигрышей:" f" \nНичей: ", bg="#FFF") self.lbl2.place(x=5, y=5) 

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

Сделаем 3 счетчика:

1. Поражений
2. Побед
3. Ничей

Для этого все в тот же startUI добавим такую строку:

self.win = self.drow = self.lose = 0 

Теперь в классе main создаем метод btn_click, и пишем в него следующие строки:

def btn_click(self, choise): comp_choise = rdm.randint(1, 3) print(choise) 

Недолго музыка играла. Там же, в btn_click, удаляем

print(choise)

и пишем вот эти строки:

if choise == comp_choise: self.drow += 1 self.lbl.configure(text="Ничья") elif choise == 1 and comp_choise == 2 \ or choise == 2 and comp_choise == 3 \ or choise == 3 and comp_choise == 1: self.win += 1 self.lbl.configure(text="Победа") else: self.lose += 1 self.lbl.configure(text="Проигрыш") self.lbl2.configure(text=f"Побед: \nПроигрышей:" f" \nНичей: ") del comp_choise 

Собственно всё, на этом создание закончилось. Всё работает, можно играть.

Полный код:

from tkinter import * import random as rdm class Main(Frame): def __init__(self, root): super(Main, self).__init__(root) self.startUI() def startUI(self): btn = Button(root, text="Камень", font=("Times New Roman", 15), command=lambda x=1: self.btn_click(x)) btn2 = Button(root, text="Ножницы", font=("Times New Roman", 15), command=lambda x=2: self.btn_click(x)) btn3 = Button(root, text="Бумага", font=("Times New Roman", 15), command=lambda x=3: self.btn_click(x)) btn.place(x=10, y=100, width=120, height=50) btn2.place(x=155, y=100, width=120, height=50) btn3.place(x=300, y=100, width=120, height=50) self.lbl = Label(root, text="Начало игры!", bg="#FFF", font=("Times New Roman", 21, "bold")) self.lbl.place(x=150, y=25) self.win = self.drow = self.lose = 0 self.lbl2 = Label(root, justify="left", font=("Times New Roman", 13), text=f"Побед: \nПроигрышей:" f" \nНичей: ", bg="#FFF") self.lbl2.place(x=5, y=5) def btn_click(self, choise): comp_choise = rdm.randint(1, 3) if choise == comp_choise: self.drow += 1 self.lbl.configure(text="Ничья") elif choise == 1 and comp_choise == 2 \ or choise == 2 and comp_choise == 3 \ or choise == 3 and comp_choise == 1: self.win += 1 self.lbl.configure(text="Победа") else: self.lose += 1 self.lbl.configure(text="Проигрыш") self.lbl2.configure(text=f"Побед: \nПроигрышей:" f" \nНичей: ") del comp_choise if __name__ == '__main__': root = Tk() root.geometry("430x160+200+200") root.title("Камень, ножницы, бумага") root.resizable(False, False) root["bg"] = "#FFF" app = Main(root) app.pack() root.mainloop() 
  • GUI на python
  • python 2.7

Создаём «Змейку» — первую игру на Python и Pygame

Учимся программировать через разработку игр. Сегодня напишем знакомую всем «Змейку» — вспомним правила игры и реализуем их на Python.

Иллюстрация: Оля Ежак для Skillbox Media

Антон Яценко

Антон Яценко
Изучает Python, его библиотеки и занимается анализом данных. Любит путешествовать в горах.

Pygame — популярная библиотека для создания игр под различные устройства на Windows, macOS, Linux или Android. Она помогает разработчику не только описать геймплей, но и работать с клавиатурой, мышью, акселерометром, звуком и видео.

Первая версия Pygame была представлена Питом Шиннерсом в октябре 2000 года. За 22 года вокруг библиотеки сложилось большое комьюнити, а о работе с ней написано несколько десятков книг. Последняя стабильная версия на июль 2022 года — 2.1.2.

Давайте разберёмся в том, как устроена Pygame, и напишем свою первую игру — классическую «Змейку» на Python, которую студенты часто берут для курсовой работы по программированию.

Устанавливаем Pygame и разбираемся

Pygame — не самостоятельная библиотека. На самом деле это обёртка для библиотеки SDL, Simple DirectMedia Layer. Именно SDL позволяет задействовать любые внешние устройства — например, мышь или клавиатуру. А Pygame делает работу с ними удобной для Python-разработчика.

Установить Pygame просто. Для этого воспользуемся терминалом или командной строкой и командой pip:

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

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

Шаг 3

Описываем движения змейки

Управлять перемещением змейки можно с помощью специального класса Pygame KEYDOWN. Класс позволяет использовать четыре стандартных события, получая их с клавиавтуры: K_UP, K_DOWN, K_LEFT и K_RIGHT — они соответствуют движениям змейки вверх, вниз, влево и вправо. Срабатывание любого события из класса KEYDOWN приводит к изменению положения змейки. Зададим шаг этого движения в 10 пикселей.

Кроме того, мы должны создать две переменные для хранения значений координат первой клетки нашей змейки по осям x и y. Назовём их x1_change и y1_change.

Шаг 4

Учитываем препятствия — границы игрового поля

Если змейка попадает на границу экрана, то игрок терпит поражение, а игра заканчивается. Чтобы закодить это правило, можно воспользоваться оператором if, который определяет координаты x и y для змейки и анализирует, выходят ли они за границы игрового поля. Добавим необходимый код.

Шаг 5

Добавляем еду для змейки

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

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

Шаг 6

Увеличиваем длину змейки

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

Шаг 7

Добавляем отображение счёта

Добавим отображение счёта текущей игры. Для этого создадим функцию Your_score. Она будет отображать длину змейки, вычитая из неё 1 (ведь 1 — это начальный размер змейки, и это не является достижением игрока).

Можно считать, что наша работа над «Змейкой» закончена. Мы полностью реализовали геймплей, который запланировали на старте работы.

Итоговый код

Наш код полностью и без комментариев:

import pygame import time import random pygame.init() white = (255, 255, 255) yellow = (255, 255, 102) black = (0, 0, 0) red = (213, 50, 80) green = (0, 255, 0) blue = (50, 153, 213) dis_width = 800 dis_height = 600 dis = pygame.display.set_mode((dis_width, dis_height)) pygame.display.set_caption('Змейка от Skillbox') clock = pygame.time.Clock() snake_block = 10 snake_speed = 15 font_style = pygame.font.SysFont("bahnschrift", 25) score_font = pygame.font.SysFont("comicsansms", 35) def Your_score(score): value = score_font.render("Ваш счёт: " + str(score), True, yellow) dis.blit(value, [0, 0]) def our_snake(snake_block, snake_list): for x in snake_list: pygame.draw.rect(dis, black, [x[0], x[1], snake_block, snake_block]) def message(msg, color): mesg = font_style.render(msg, True, color) dis.blit(mesg, [dis_width / 6, dis_height / 3]) def gameLoop(): game_over = False game_close = False x1 = dis_width / 2 y1 = dis_height / 2 x1_change = 0 y1_change = 0 snake_List = [] Length_of_snake = 1 foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0 foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0 while not game_over: while game_close == True: dis.fill(blue) message("Вы проиграли! Нажмите Q для выхода или C для повторной игры", red) Your_score(Length_of_snake - 1) pygame.display.update() for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_q: game_over = True game_close = False if event.key == pygame.K_c: gameLoop() for event in pygame.event.get(): if event.type == pygame.QUIT: game_over = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: x1_change = -snake_block y1_change = 0 elif event.key == pygame.K_RIGHT: x1_change = snake_block y1_change = 0 elif event.key == pygame.K_UP: y1_change = -snake_block x1_change = 0 elif event.key == pygame.K_DOWN: y1_change = snake_block x1_change = 0 if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0: game_close = True x1 += x1_change y1 += y1_change dis.fill(blue) pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block]) snake_Head = [] snake_Head.append(x1) snake_Head.append(y1) snake_List.append(snake_Head) if len(snake_List) > Length_of_snake: del snake_List[0] for x in snake_List[:-1]: if x == snake_Head: game_close = True our_snake(snake_block, snake_List) Your_score(Length_of_snake - 1) pygame.display.update() if x1 == foodx and y1 == foody: foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0 foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0 Length_of_snake += 1 clock.tick(snake_speed) pygame.quit() quit() gameLoop()

Что дальше?

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

  • «Учим Python, делая крутые игры» Эла Свейгарта;
  • «Beginning Game Development with Python and Pygame: From Novice to Professional» Уилла Макгугана;
  • «Program Arcade Games: With Python and Pygame» Пола Винсента Крэйвена.

Больше интересного про код в нашем телеграм-канале. Подписывайтесь!

Игры на Python: примеры и перспективы

О чем речь? Считается, что игры на Python не пишутся, так как этот язык программирования не подходит для развлечений. Однако на самом деле существуют известные и даже крупные проекты, например, EVE Online.

На что обратить внимание? Критики выбора Python для создания игр тоже правы. Язык действительно практически не используется для написания движка, но зато регулярно применяется для создания логики, запуска скриптов.

В статье рассказывается:

  1. Роль Python в разработке игр
  2. Плюсы и минусы Python для разработки игр
  3. 10 библиотек Python для игр
  4. Алгоритм создания игры на Python
  5. Примеры игр, в которых используется Python
  6. Часто задаваемые вопросы об играх на Python

Пройди тест и узнай, какая сфера тебе подходит:
айти, дизайн или маркетинг.
Бесплатно от Geekbrains

Роль Python в разработке игр

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

  • высокобюджетные AAA-проекты (triple-A) от крупных студий (например, Assassin’sCreed и Call of Duty);
  • инди-игры от независимых разработчиков;
  • игры для мобильных устройств.

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

Поскольку игровой движок требует высокую производительность, Python — не лучший выбор для написания ядра игр. Он работает медленнее, чем другие языки программирования, поэтому чаще всего для движка используются С/С++, С# или другие компилируемые языки. Несмотря на это, есть примеры специальных игровых движков, полностью написанных на Python.

Unity, Unreal Engine 4, CryEngine, Source и другие движки, написанные на С++, популярны среди известных компаний-разработчиков. Часто на этом языке ими пишутся и собственные движки, например Anvil, Fox, REDengine.

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

К примеру, в игровом движке Unreal Engine 4 используются С# как основа для Unity, а также С++, Blueprint и аналог JavaScript. В какой-то момент для него пробовали использовать Boo (Python с типизацией), но впоследствии от него отказались. Только один из популярных движков крупных разработчиков (Godot) использует похожий на Python язык как основной. В этом движке используется GDScript.

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

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

Написанные на Python скрипты позволяют разделить логику игры и основные ее элементы, такие как графика, физические процессы, сетевое взаимодействие, ввод и вывод и прочее. Например, скрипты на Python обеспечивают запуск отдельных сцен, диалогов, а также взаимодействие персонажей друг с другом, бег, ходьбу, взаимодействие с NPC (Non-player character, неигровой персонаж). Такие скрипты также используются для отображения статистики противников (скорости, точности, здоровья) и разных процессов в игре.

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

Плюсы и минусы Python для разработки игр

В последние годы Python набирает популярность. Он все чаще используется в разработке программ любых типов и сложности благодаря своей мощности и универсальности. Игры на языке Python могут быть разными: как простыми текстовыми, так и масштабными 3D-проектами.

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

Узнай, какие ИТ — профессии
входят в ТОП-30 с доходом
от 210 000 ₽/мес
Павел Симонов
Исполнительный директор Geekbrains

Команда GeekBrains совместно с международными специалистами по развитию карьеры подготовили материалы, которые помогут вам начать путь к профессии мечты.

Подборка содержит только самые востребованные и высокооплачиваемые специальности и направления в IT-сфере. 86% наших учеников с помощью данных материалов определились с карьерной целью на ближайшее будущее!

Скачивайте и используйте уже сегодня:

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

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

Топ-30 самых востребованных и высокооплачиваемых профессий 2023

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

Подборка 50+ бесплатных нейросетей для упрощения работы и увеличения заработка

Только проверенные нейросети с доступом из России и свободным использованием

ТОП-100 площадок для поиска работы от GeekBrains

Список проверенных ресурсов реальных вакансий с доходом от 210 000 ₽

Получить подборку бесплатно
Уже скачали 27950

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

Игры на Python создаются как в 2D, так и в 3D-формате. Пользуясь библиотеками подпрограмм, разработчики имеют огромные возможности для творчества: начиная с разработки игр в жанре платформер или шутер до более сложных стратегических, ролевых (RPG) и игр с открытым виртуальным миром.

Библиотеки Python (например, TensorFlow, Scikit-learn) также позволяют работать с искусственным интеллектом, который позволяет делать игры с возможностью обучения и адаптации к действиям пользователя.

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

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

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

  • Как уже отмечалось выше, среди языков программирования это один из самых мощных и универсальных. Пользуясь им, разработчики имеют доступ к большому количеству библиотек. Он легок в изучении и применении, что позволяет писать на нем коды для игр любой сложности, включая проекты с детализированной графикой.
  • Может быть обеспечена максимально высокая частота кадров в играх, и проблем с запуском не возникнет. Кроме того, Python позволяет оптимизировать приложения для мобильных и других платформ.
  • Благодаря популярности этого языка любой новичок имеет возможность начать разработку собственных проектов. Поддержку им может оказать большое сообщество профессионалов, которые уже давно работают с Python.

Есть также трудности, с которыми можно столкнуться, используя этот язык для разработки игр:

  • Сложности со встроенной поддержкой звука и графики. Разработчики сталкиваются с проблемой нестабильности некоторых библиотек (Pygame, Pyglet) и уделяют слишком много времени попыткам изучить, как эффективно использовать их.
  • Проблемы также связаны с тем, что поддержка сети не встроена.
  • Скорость Python значительно ниже, чем у других языков. Разработчикам требуется больше усилий для оптимизации кода для выполнения отдельных задач.

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

10 библиотек Python для игр

Pygame

Pygame — это библиотека для Python с открытым исходным кодом, которая помогает создавать игры. Она основана на библиотеке SDL и доступна для разных языков, таких как C, Python, Native и OpenGL.

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

Библиотека Pygame для Python обладает следующими особенностями:

  • Поддерживает многозадачность, хорошо работает с многоядерными процессорами.
  • Для основных функций используются оптимизированные коды C и Assembler, что делает ее быстрой.
  • Проста в использовании и легко переносима на разные операционные системы.
  • Даже небольшой объем кода может использоваться для создания приложений.

Для вас подарок! В свободном доступе до 05.05 —>
Скачайте ТОП-10 нейросетей, которые помогут облегчить
вашу работу
Чтобы получить подарок, заполните информацию в открывшемся окне

PyKyra

Это один из быстрых фреймворков, позволяющих создание игры на Python. Он базируется на библиотеке SDL (программной и документарной локализации) и движке kyra. Этот фреймворк предоставляет стандартные функции для создания игр, а также поддерживает работу с видео и звуками в форматах MPEG, такими как MP3, WAV, Ogg Vorbis, а также позволяет непосредственно работать с изображениями и имеет много других возможностей:

  • Поддержка различных видов переводов: как боковые симметричные (горизонтальные), так и сверху вниз (вертикальные).
  • Множество представлений подокон позволяет разделить экран, и каждое подокно может иметь свои собственные преобразования объектов.
  • Быстрый движок с оптимизированными алгоритмами обеспечивает эффективный рендеринг обновлений в игре.
  • Продвинутые инструменты, такие как редактор спрайтов и кодировщик, облегчают создание игровых ресурсов.
  • Движок Kyra позволяет объединять альфа-значения и изменять цвета, что полезно для создания эффектов и анимаций.
  • Все объекты в PyKyra встроены в удобную иерархию, что облегчает управление ими.

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

Pyglet

Еще одна полезная кроссплатформенная оконная и мультимедийная библиотека. Она имеет открытый исходный код. Основная сфера применения — разработка игр, приложений с ярким визуальным контентом и программ в Windows, Linux и Mac OS X.

Эта библиотека для Python имеет поддержку пользовательского интерфейса, который позволяет обрабатывать события, графику OpenGL, джойстики, загрузку и воспроизведение мультимедиа, а также работу с окнами. Она совместима с версиями Python 3.5 и выше, поддерживает работу интерпретаторов, таких как Pypy.

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

Эта библиотека имеет следующие отличительные черты:

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

PyOpenGL

Это самая популярная кроссплатформенная библиотека для Python, которая создана для связи с OpenGL и связанными с ними API. В PyOpenGL используется стандартная библиотека C-типов для обеспечения интероперабельности.

Эта библиотека является стандартизированным инструментом Python, который может взаимодействовать с разнообразными графическими интерфейсами и звуковыми библиотеками, такими как PyGame, Raw XLib, PyQt и многими другими.

Kivy

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

Она поддерживает множество платформ, включая Windows, Android, Raspberry Pi, Linux, OS X и iOS, и может взаимодействовать с разнообразными входными устройствами и протоколами, такими как трекпады Mac OS X, сенсорные экраны, перо, устройства ввода Linux и другие. Kivy включает в себя ускоренный графический процессор (GPU) и предоставляет более 20 виджетов, которые легко настраивать и расширять.

Библиотека Kivy доступна для использования по лицензии MIT (начиная с версии 1.7.2) и LGPL 3 (для более ранних версий), что позволяет ее использовать в коммерческих продуктах. Она обладает высокой стабильностью, документированным API и руководством по программированию, что облегчает начало работы для разработчиков.

Panda3D

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

Python-Ogre

Этот фреймворк (также известный как PyOgre) представляет собой программную платформу для создания игр, основанную на библиотеке Ogre3D. Это кроссплатформенная библиотека, которая написана на языке C++. Предоставляет гибкие и быстрые возможности для разработки увлекательных игр.

Python-Ogre состоит из двух основных библиотек: Ogre3D, которая представляет собой движок 3D-рендеринга, и CEGUi, систему встроенного графического пользовательского интерфейса (GUI). Используется для создания сцен и графики в игре. Фреймворк PyOgre используется для версий, разработанных до версии v1.05. После этого доступно множество других модулей.

Ogre также включает в себя скрипты на Python, которые облегчают импорт в него данных из Blender. Это позволяет пользователям создавать ресурсы в Blender для своих игр и легко импортировать их в Ogre. Кроме того, в этой структуре доступны и другие формы экспортеров для удобства работы с различными типами данных.

Ren’Py

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

Дарим скидку от 60%
на курсы от GeekBrains до 05 мая
Уже через 9 месяцев сможете устроиться на работу с доходом от 150 000 рублей

Благодаря поддержке языка сценариев Python, Ren’Py также позволяет создавать сложные игровые логики. Большим преимуществом этого фреймворка является его способность работать на любой операционной системе компьютера.

Cocos2d

Среда Python, которая применяется для разработки разнообразных интерактивных программ, включая игры, приложения и другое программное обеспечение, использующее кроссплатформенный графический пользовательский интерфейс (GUI). Имея открытый исходный код, этот фреймворк предоставляет разработчикам широкие возможности.

Имеет различные варианты, включая Cocos2D-x, Cocos2D-XNA и Cocos2D-JS. Он написан на языке C++, обладает минимальной платформозависимостью и предоставляет инструменты для разработки разнообразных приложений и игр. Cocos2D-JS — это версия фреймворка, основанная на JavaScript, которая сохраняет полную функциональность Cocos2D-x и предоставляет простой набор API для разработчиков.

Soya3d

Это фреймворк высокого уровня, который позволяет создавать трехмерные игры. Soya3d бесплатна, использует лицензию General Public License (GPL). Совместима с разными платформами и операционными системами, включая Windows, Mac OS X, Linux.

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

Алгоритм создания игры на Python

Давайте создадим настоящую игру, чтобы более подробно изучить работу Pygame.

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

# Импортируем библиотеку и инициализируем

# Случайное размещение монет

from random import randint

from pathlib import Path

from typing import Tuple

# Установка размеров окна

# Настройка частоты появления монет (мс)

# Максимальное количество монет на экране для завершения игры

# Определяем вид графического объекта для игрока

«»»Инициализация вида игрока»»»

# Определение изображения персонажа

Path.cwd() / «pygame» / «images» / «alien_green_stand.png»

# Загрузка изображения, настройка альфа-канал для прозрачности

# Добавление прямоугольника для перемещения объекта

def update(self, pos: Tuple):

«»»Обновление позиции персонажа

pos — (X,Y) позиция для движения персонажа

# Определение графического изображения для монет

«»»Инициализация вида монеты»»»

# Определение изображения монеты

coin_image = str(Path.cwd() / «pygame» / «images» / «coin_gold.png»)

# Загрузка изображения, настройка альфа-канала для прозрачности

# Определение позиция для старта, генерация случайной позиции

randint(10, WIDTH — 10),

randint(10, HEIGHT — 10),

screen = pygame.display.set_mode(size=[WIDTH, HEIGHT])

# Скрыть курсор мыши

# Запуск часов для фиксации времени

# Создание события для добавления монеты

ADDCOIN = pygame.USEREVENT + 1

# Настройка списка монет

# Установка звука для сбора монет

str(Path.cwd() / «pygame» / «sounds» / «coin_pickup.wav»)

# Создание графического изображения игрока и установка на позицию старта

# Запуск цикла событий

# Проверка, нажал ли пользователь кнопку закрытия окна

for event in pygame.event.get():

if event.type == pygame.QUIT:

# Определение условий для добавления монеты

elif event.type == ADDCOIN:

# Добавление новой монеты

# Ускорение игры при наличии менее трех монет на экране

# Установка ограничения скорости

# Запуск нового таймера

# Обновление позиции персонажа

# Проверка, собрал ли герой монету и удаление, если да

sprite=player, group=coin_list, dokill=True

for coin in coins_collected:

# Установка счета за собранные монеты

# Воспроизведение звука для сбора монеты

# Проверка допустимого количества монет

if len(coin_list) >= COIN_COUNT:

# Если лимит превышен, игра останавливается

# Установка цвета фона

screen.fill((255, 170, 164))

for coin in coin_list:

# Вывод текущего счета

score_font = pygame.font.SysFont(«any_font», 36)

score_block = score_font.render(f»Score: », False, (0, 0, 0))

screen.blit(score_block, (50, HEIGHT — 50))

# Отображение всех элементов на экране

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

# Вывод итогового результата

print(f»Game over! Final score: »)

# Возврат видимости курсора

В Pygame спрайты имеют только базовый функционал, который расширяется в написанном коде с помощью подклассов для персонажей (Player) и монет (Coin). Эти объекты хранятся в self.surf и позиционируются с использованием self.rect.

Чтобы добавлять монеты на экран через равные временные интервалы, используется функция таймера time.set_timer(), который отсчитывает время до миллисекунд (coin_countdown). Событие ADDCOIN вызывает создание нового объекта Coin и добавление его в coin_list. Затем необходимо проверить, сколько монет отображается на экране: меньше трех — уменьшаем значение coin_countdown, при этом происходит остановка таймера и запуск нового.

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

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

Примеры игр, в которых используется Python

В 2002 году появилась необычная ролевая игра под названием Freedom Force. Её разработала известная студия Irrational Games (известная по таким проектам как System Shock, BioShock и SWAT 4). Игра представила нам захватывающий рассказ о команде супергероев, которые спасали Америку с юмором, пародией и шутками на самом высоком уровне. Помимо этого, она также выделялась тактической глубиной и возможностью взаимодействовать с окружающей средой. Например, на злодеев можно было нападать с помощью вырванных из асфальта столбов или даже использовать светофоры в битве.

Только до 6.05
Скачай подборку материалов, чтобы гарантированно найти работу в IT за 14 дней
Список документов:

ТОП-100 площадок для поиска работы от GeekBrains

20 профессий 2023 года, с доходом от 150 000 рублей

Чек-лист «Как успешно пройти собеседование»

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

Несмотря на все разговоры о сюжетной линии одиночных игр и лаврах Call of Duty, по интенсивности онлайн-сражений ни одна игра не смогла превзойти бренд Battlefield. В разработке нескольких игр из этой франшизы, таких как Battlefield 2, Battlefield 2142 и Battlefield Heroes, был задействован Python. Эти проекты по достоинству оценили как критики, так и пользователи. Такие игры показали, что соперничество с живыми игроками всегда приносит уникальный и более интересный опыт по сравнению со сражениями с искусственным интеллектом. О ценности сюжетных одиночных игр мы можем поговорить в другой раз.

Онлайновый космический симулятор EVE Online, одна из самых популярных игр, был разработан с использованием языка Python. Этот проект является, возможно, наиболее заметным примером применения этого языка в игровой индустрии. EVE Online — игра, которая отличается своей уникальностью и имеет высокий порог входа, что делает её малоподходящей для случайных игроков.

Более того, игра не предоставляет условно-бесплатную модель, и доступ к миру EVE открывается только за определенную плату. Тем не менее EVE Online остается невероятно популярной, и одной из её самых знаменитых особенностей являются масштабные космические баталии, в которых были уничтожены корабли на сумму, достигающую 300 тысяч долларов США.

В 2008 году команда разработчиков из Турции, работая над своим «спящим хитом» Mount and Blade, воспользовалась Python. Несмотря на ограниченный бюджет, они создали игру, которая стала мечтой для многих игроков. Открытые просторы средневекового мира и высокая степень свободы привлекли огромное сообщество игроков. Mount and Blade с тех пор стала успешной серией, и новая игра под названием Bannerlord собрала в Steam большое количество фанатов. Уникальная система боевых сражений на мечах и копьях, а также возможность управлять многочисленными армиями, были бы невозможны без искусного использования языка Python.

В 2005 году мастер стратегий Сид Мейер перенес свою серию глобальных стратегий в трехмерное измерение при выходе четвертой части под названием Sid Meier’s Civilization IV. На тот момент игра выглядела и звучала потрясающе. Механика игры также была на высшем уровне, и игроки могли буквально утонуть в мире пошаговой стратегии, рассчитывая каждый свой ход. Для создания этого безоговорочного хита Сид Мейер использовал язык Python.

The Sims 4 — игра, разработчики которой продали более миллиона копий и завоевали сердца игроков, также написана на языке Python. Эта симуляция жизни поразила своей детализацией, привлекая даже тех, кто ранее не был заинтересован в видеоиграх. Продукт оставался в лидерах продаж на протяжении двух лет как в Северной Америке, так и в Европе. В Python была реализована поддержка пользовательских модификаций, и фанаты игры создали десятки, а то и сотни различных модов для The Sims 4. Это наглядно демонстрирует популярность и успех этой игры.

В 2006 году из Финляндии пришла музыкальная игра Frets on Fire, полностью написанная на Python, которая во многом напоминает Guitar Hero. Однако есть одно отличие, которое делает эту финскую игру уникальной — она имеет открытый исходный код. Это позволяет использовать Frets on Fire для изучения программирования и практики без каких-либо ограничений. И ещё один плюс — игра очень проста в освоении и не требует специализированного образования.

Часто задаваемые вопросы об играх на Python

Что сделать до начала работы над игрой?

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

Можно ли написать на Python ААА-игру?

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

Пишем игру на Python

Прежде чем мы начнём программировать что-то полезное на Python, давайте закодим что-нибудь интересное. Например, свою игру, где нужно не дать шарику упасть, типа Арканоида. Вы, скорее всего, играли в детстве во что-то подобное, поэтому освоиться будет просто.

Логика игры

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

Алгоритм

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

  • игра начинается;
  • шарик начинает двигаться;
  • если нажаты стрелки влево или вправо — двигаем платформу;
  • если шарик коснулся стенок, потолка или платформы — делаем отскок;
  • если шарик коснулся платформы — увеличиваем счёт на единицу;
  • если шарик упал на пол — выводим сообщение и заканчиваем игру.

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

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

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

По коням, пишем на Python

Для этого проекта вам потребуется установить и запустить среду Python. Как это сделать — читайте в нашей статье.

Начало программы

Чтобы у нас появилась графика в игре, используем библиотеку Tkinter. Она входит в набор стандартных библиотек Python и позволяет рисовать простейшие объекты — линии, прямоугольники, круги и красить их в разные цвета. Такой простой Paint, только для Python.

Чтобы создать окно, где будет видна графика, используют класс Tk(). Он просто делает окно, но без содержимого. Чтобы появилось содержимое, создают холст — видимую часть окна. Именно на нём мы будем рисовать нашу игру. За холст отвечает класс Canvas(), поэтому нам нужно будет создать свой объект из этого класса и дальше уже работать с этим объектом.

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

Последнее, что нам глобально нужно, — задавать случайным образом начальное положение шарика и платформы, чтобы было интереснее играть. За это отвечает модуль Random — он помогает генерировать случайные числа и перемешивать данные.

Запишем всё это в виде кода на Python:

# подключаем графическую библиотеку from tkinter import * # подключаем модули, которые отвечают за время и случайные числа import time import random # создаём новый объект — окно с игровым полем. В нашем случае переменная окна называется tk, и мы его сделали из класса Tk() — он есть в графической библиотеке tk = Tk() # делаем заголовок окна — Games с помощью свойства объекта title tk.title('Game') # запрещаем менять размеры окна, для этого используем свойство resizable tk.resizable(0, 0) # помещаем наше игровое окно выше остальных окон на компьютере, чтобы другие окна не могли его заслонить tk.wm_attributes('-topmost', 1) # создаём новый холст — 400 на 500 пикселей, где и будем рисовать игру canvas = Canvas(tk, width=500, height=400, highlightthickness=0) # говорим холсту, что у каждого видимого элемента будут свои отдельные координаты canvas.pack() # обновляем окно с холстом tk.update()

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

Любишь Python? Зарабатывай на нём!

Любишь Python? Зарабатывай на нём! Любишь Python? Зарабатывай на нём! Любишь Python? Зарабатывай на нём! Любишь Python? Зарабатывай на нём!

Шарик

Сначала проговорим словами, что нам нужно от шарика. Он должен уметь:

  • задавать своё начальное положение и направление движение;
  • понимать, когда он коснулся платформы;
  • рисовать сам себя и понимать, когда нужно отрисовать себя в новом положении (например, после отскока от стены).

Этого достаточно, чтобы шарик жил своей жизнью и умел взаимодействовать с окружающей средой. При этом нужно не забыть о том, что каждый класс должен содержать конструктор — код, который отвечает за создание нового объекта. Без этого сделать шарик не получится. Запишем это на Python:

# Описываем класс Ball, который будет отвечать за шарик class Ball: # конструктор — он вызывается в момент создания нового объекта на основе этого класса def __init__(self, canvas, paddle, score, color): # задаём параметры объекта, которые нам передают в скобках в момент создания self.canvas = canvas self.paddle = paddle self.score = score # цвет нужен был для того, чтобы мы им закрасили весь шарик # здесь появляется новое свойство id, в котором хранится внутреннее название шарика # а ещё командой create_oval мы создаём круг радиусом 15 пикселей и закрашиваем нужным цветом self.id = canvas.create_oval(10,10, 25, 25, fill=color) # помещаем шарик в точку с координатами 245,100 self.canvas.move(self.id, 245, 100) # задаём список возможных направлений для старта starts = [-2, -1, 1, 2] # перемешиваем его random.shuffle(starts) # выбираем первый из перемешанного — это будет вектор движения шарика self.x = starts[0] # в самом начале он всегда падает вниз, поэтому уменьшаем значение по оси y self.y = -2 # шарик узнаёт свою высоту и ширину self.canvas_height = self.canvas.winfo_height() self.canvas_width = self.canvas.winfo_width() # свойство, которое отвечает за то, достиг шарик дна или нет. Пока не достиг, значение будет False self.hit_bottom = False # обрабатываем касание платформы, для этого получаем 4 координаты шарика в переменной pos (левая верхняя и правая нижняя точки) def hit_paddle(self, pos): # получаем кординаты платформы через объект paddle (платформа) paddle_pos = self.canvas.coords(self.paddle.id) # если координаты касания совпадают с координатами платформы if pos[2] >= paddle_pos[0] and pos[0] = paddle_pos[1] and pos[3] = self.canvas_height: # помечаем это в отдельной переменной self.hit_bottom = True # выводим сообщение и количество очков canvas.create_text(250, 120, text='Вы проиграли', font=('Courier', 30), fill='red') # если было касание платформы if self.hit_paddle(pos) == True: # отправляем шарик наверх self.y = -2 # если коснулись левой стенки if pos[0] = self.canvas_width: # движемся влево self.x = -2

Платформа

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

  • двигаться влево или вправо в зависимости от нажатой стрелки;
  • понимать, когда игра началась и можно двигаться.

А вот как это будет в виде кода:

# Описываем класс Paddle, который отвечает за платформы class Paddle: # конструктор def __init__(self, canvas, color): # canvas означает, что платформа будет нарисована на нашем изначальном холсте self.canvas = canvas # создаём прямоугольную платформу 10 на 100 пикселей, закрашиваем выбранным цветом и получаем её внутреннее имя self.id = canvas.create_rectangle(0, 0, 100, 10, fill=color) # задаём список возможных стартовых положений платформы start_1 = [40, 60, 90, 120, 150, 180, 200] # перемешиваем их random.shuffle(start_1) # выбираем первое из перемешанных self.starting_point_x = start_1[0] # перемещаем платформу в стартовое положение self.canvas.move(self.id, self.starting_point_x, 300) # пока платформа никуда не движется, поэтому изменений по оси х нет self.x = 0 # платформа узнаёт свою ширину self.canvas_width = self.canvas.winfo_width() # задаём обработчик нажатий # если нажата стрелка вправо — выполняется метод turn_right() self.canvas.bind_all('', self.turn_right) # если стрелка влево — turn_left() self.canvas.bind_all('', self.turn_left) # пока игра не началась, поэтому ждём self.started = False # как только игрок нажмёт Enter — всё стартует self.canvas.bind_all('', self.start_game) # движемся вправо def turn_right(self, event): # будем смещаться правее на 2 пикселя по оси х self.x = 2 # движемся влево def turn_left(self, event): # будем смещаться левее на 2 пикселя по оси х self.x = -2 # игра начинается def start_game(self, event): # меняем значение переменной, которая отвечает за старт self.started = True # метод, который отвечает за движение платформы def draw(self): # сдвигаем нашу платформу на заданное количество пикселей self.canvas.move(self.id, self.x, 0) # получаем координаты холста pos = self.canvas.coords(self.id) # если мы упёрлись в левую границу if pos[0] = self.canvas_width: # останавливаемся self.x = 0

Счёт

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

От счёта нам нужно только одно (кроме конструктора) — чтобы он правильно реагировал на касание платформы, увеличивал число очков и выводил их на экран:

# Описываем класс Score, который отвечает за отображение счетов class Score: # конструктор def __init__(self, canvas, color): # в самом начале счёт равен нулю self.score = 0 # будем использовать наш холст self.canvas = canvas # создаём надпись, которая показывает текущий счёт, делаем его нужно цвета и запоминаем внутреннее имя этой надписи self.id = canvas.create_text(450, 10, text=self.score, font=('Courier', 15), fill=color) # обрабатываем касание платформы def hit(self): # увеличиваем счёт на единицу self.score += 1 # пишем новое значение счёта self.canvas.itemconfig(self.id, text=self.score) 

Игра

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

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

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

# создаём объект — зелёный счёт score = Score(canvas, 'green') # создаём объект — белую платформу paddle = Paddle(canvas, 'White') # создаём объект — красный шарик ball = Ball(canvas, paddle, score, 'red') # пока шарик не коснулся дна while not ball.hit_bottom: # если игра началась и платформа может двигаться if paddle.started == True: # двигаем шарик ball.draw() # двигаем платформу paddle.draw() # обновляем наше игровое поле, чтобы всё, что нужно, закончило рисоваться tk.update_idletasks() # обновляем игровое поле, и смотрим за тем, чтобы всё, что должно было быть сделано — было сделано tk.update() # замираем на одну сотую секунды, чтобы движение элементов выглядело плавно time.sleep(0.01) # если программа дошла досюда, значит, шарик коснулся дна. Ждём 3 секунды, пока игрок прочитает финальную надпись, и завершаем игру time.sleep(3) 

ПОЛНЫЙ КОД ПРОГРАММЫ

# подключаем графическую библиотеку from tkinter import * # подключаем модули, которые отвечают за время и случайные числа import time import random # создаём новый объект — окно с игровым полем. В нашем случае переменная окна называется tk, и мы его сделали из класса Tk() — он есть в графической библиотеке tk = Tk() # делаем заголовок окна — Games с помощью свойства объекта title tk.title('Game') # запрещаем менять размеры окна, для этого используем свойство resizable tk.resizable(0, 0) # помещаем наше игровое окно выше остальных окон на компьютере, чтобы другие окна не могли его заслонить. Попробуйте :) tk.wm_attributes('-topmost', 1) # создаём новый холст — 400 на 500 пикселей, где и будем рисовать игру canvas = Canvas(tk, width=500, height=400, highlightthickness=0) # говорим холсту, что у каждого видимого элемента будут свои отдельные координаты canvas.pack() # обновляем окно с холстом tk.update() # Описываем класс Ball, который будет отвечать за шарик class Ball: # конструктор — он вызывается в момент создания нового объекта на основе этого класса def __init__(self, canvas, paddle, score, color): # задаём параметры объекта, которые нам передают в скобках в момент создания self.canvas = canvas self.paddle = paddle self.score = score # цвет нужен был для того, чтобы мы им закрасили весь шарик # здесь появляется новое свойство id, в котором хранится внутреннее название шарика # а ещё командой create_oval мы создаём круг радиусом 15 пикселей и закрашиваем нужным цветом self.id = canvas.create_oval(10,10, 25, 25, fill=color) # помещаем шарик в точку с координатами 245,100 self.canvas.move(self.id, 245, 100) # задаём список возможных направлений для старта starts = [-2, -1, 1, 2] # перемешиваем его random.shuffle(starts) # выбираем первый из перемешанного — это будет вектор движения шарика self.x = starts[0] # в самом начале он всегда падает вниз, поэтому уменьшаем значение по оси y self.y = -2 # шарик узнаёт свою высоту и ширину self.canvas_height = self.canvas.winfo_height() self.canvas_width = self.canvas.winfo_width() # свойство, которое отвечает за то, достиг шарик дна или нет. Пока не достиг, значение будет False self.hit_bottom = False # обрабатываем касание платформы, для этого получаем 4 координаты шарика в переменной pos (левая верхняя и правая нижняя точки) def hit_paddle(self, pos): # получаем кординаты платформы через объект paddle (платформа) paddle_pos = self.canvas.coords(self.paddle.id) # если координаты касания совпадают с координатами платформы if pos[2] >= paddle_pos[0] and pos[0] = paddle_pos[1] and pos[3] = self.canvas_height: # помечаем это в отдельной переменной self.hit_bottom = True # выводим сообщение и количество очков canvas.create_text(250, 120, text='Вы проиграли', font=('Courier', 30), fill='red') # если было касание платформы if self.hit_paddle(pos) == True: # отправляем шарик наверх self.y = -2 # если коснулись левой стенки if pos[0] = self.canvas_width: # движемся влево self.x = -2 # Описываем класс Paddle, который отвечает за платформы class Paddle: # конструктор def __init__(self, canvas, color): # canvas означает, что платформа будет нарисована на нашем изначальном холсте self.canvas = canvas # создаём прямоугольную платформу 10 на 100 пикселей, закрашиваем выбранным цветом и получаем её внутреннее имя self.id = canvas.create_rectangle(0, 0, 100, 10, fill=color) # задаём список возможных стартовых положений платформы start_1 = [40, 60, 90, 120, 150, 180, 200] # перемешиваем их random.shuffle(start_1) # выбираем первое из перемешанных self.starting_point_x = start_1[0] # перемещаем платформу в стартовое положение self.canvas.move(self.id, self.starting_point_x, 300) # пока платформа никуда не движется, поэтому изменений по оси х нет self.x = 0 # платформа узнаёт свою ширину self.canvas_width = self.canvas.winfo_width() # задаём обработчик нажатий # если нажата стрелка вправо — выполняется метод turn_right() self.canvas.bind_all('', self.turn_right) # если стрелка влево — turn_left() self.canvas.bind_all('', self.turn_left) # пока платформа не двигается, поэтому ждём self.started = False # как только игрок нажмёт Enter — всё стартует self.canvas.bind_all('', self.start_game) # движемся вправо def turn_right(self, event): # будем смещаться правее на 2 пикселя по оси х self.x = 2 # движемся влево def turn_left(self, event): # будем смещаться левее на 2 пикселя по оси х self.x = -2 # игра начинается def start_game(self, event): # меняем значение переменной, которая отвечает за старт движения платформы self.started = True # метод, который отвечает за движение платформы def draw(self): # сдвигаем нашу платформу на заданное количество пикселей self.canvas.move(self.id, self.x, 0) # получаем координаты холста pos = self.canvas.coords(self.id) # если мы упёрлись в левую границу if pos[0] = self.canvas_width: # останавливаемся self.x = 0 # Описываем класс Score, который отвечает за отображение счетов class Score: # конструктор def __init__(self, canvas, color): # в самом начале счёт равен нулю self.score = 0 # будем использовать наш холст self.canvas = canvas # создаём надпись, которая показывает текущий счёт, делаем его нужно цвета и запоминаем внутреннее имя этой надписи self.id = canvas.create_text(450, 10, text=self.score, font=('Courier', 15), fill=color) # обрабатываем касание платформы def hit(self): # увеличиваем счёт на единицу self.score += 1 # пишем новое значение счёта self.canvas.itemconfig(self.id, text=self.score) # создаём объект — зелёный счёт score = Score(canvas, 'green') # создаём объект — белую платформу paddle = Paddle(canvas, 'White') # создаём объект — красный шарик ball = Ball(canvas, paddle, score, 'red') # пока шарик не коснулся дна while not ball.hit_bottom: # если игра началась и платформа может двигаться if paddle.started == True: # двигаем шарик ball.draw() # двигаем платформу paddle.draw() # обновляем наше игровое поле, чтобы всё, что нужно, закончило рисоваться tk.update_idletasks() # обновляем игровое поле и смотрим за тем, чтобы всё, что должно было быть сделано — было сделано tk.update() # замираем на одну сотую секунды, чтобы движение элементов выглядело плавно time.sleep(0.01) # если программа дошла досюда, значит, шарик коснулся дна. Ждём 3 секунды, пока игрок прочитает финальную надпись, и завершаем игру time.sleep(3)

Выводы

Это одна из самых простых игр, где уже можно ощутить всю мощь объектно-ориентированного программирования. Смотрите сами:

  • мы сделали класс «шарик», который уже при создании получает нужные размеры и цвет;
  • внутри этого класса мы прописываем логику поведения;
  • эта логика умеет взаимодействовать с другими сущностями в коде, используя значения их каких-то свойств, например, координат и размеров площадки;
  • для площадки мы также сделали новый класс со своей логикой — в ней уже есть всё, что нам нужно от площадки;
  • когда есть классы, то на их основе мы можем создавать любое количество объектов, которые будут уметь делать то же самое, что и основной класс;
  • благодаря ООП мы можем разделить внутренние значения с внешними параметрами, которые доступны извне.

А вот что ещё можно почитать по ООП:

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

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