Как написать марио на питоне

Пишем игру на 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:

# Описываем класс 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)

Что дальше

На основе этого кода вы можете сделать свою модификацию игры:

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

Python-сообщество

Начало
» Python для новичков
» Mario на Python

#1 Июнь 19, 2018 01:38:32

KrisKreiss Зарегистрирован: 2018-06-19 Сообщения: 1 Репутация: 0 Профиль Отправить e-mail

Mario на Python

Здравствуйте! Подскажите, пожалуйста, как написать Mario на Python.

Создание 2D платформера на Python

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

Для реализации игр на Питон мы можем выбрать одну из нескольких библиотек. Можно работать с: Kivy, Tkinter, PyQt или же с любой другой библиотекой, что обеспечивает построение графического интерфейса через Python. Таких библиотек много, но мы возьмем библиотеку PyGame , которая даже своим названием говорит о её предназначении.

PyGame появился в 2000 году. С тех пор на его основе было сделано много интересных проектов . К сожалению, PyGame не универсален и разработка на нём ведется лишь под Андроид устройства.

Настройка проекта

Перед использованием PyGame его нужно установить через терминал. Прописываем команду:

pip install pygame

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

import pygame pygame.init() win = pygame.display.set_mode((500, 500)) # размеры X и Y pygame.display.set_caption("Название игры") while(True): pass

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

import pygame pygame.init() win = pygame.display.set_mode((500, 500)) # размеры X и Y pygame.display.set_caption("Название игры") run = True while(run): for event in pygame.event.get(): if event.type == pygame.QUIT: run = False pygame.quit()

Создание платформера

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

import pygame # Переменные для установки ширины и высоты окна SCREEN_WIDTH = 800 SCREEN_HEIGHT = 600 # Подключение фото для заднего фона # Здесь лишь создание переменной, вывод заднего фона ниже в коде bg = pygame.image.load('bg.jpg') # Класс, описывающий поведение главного игрока class Player(pygame.sprite.Sprite): # Изначально игрок смотрит вправо, поэтому эта переменная True right = True # Методы def __init__(self): # Стандартный конструктор класса # Нужно ещё вызывать конструктор родительского класса super().__init__() # Создаем изображение для игрока # Изображение находится в этой же папке проекта self.image = pygame.image.load('idle.png') # Установите ссылку на изображение прямоугольника self.rect = self.image.get_rect() # Задаем вектор скорости игрока self.change_x = 0 self.change_y = 0 def update(self): # В этой функции мы передвигаем игрока # Сперва устанавливаем для него гравитацию self.calc_grav() # Передвигаем его на право/лево # change_x будет меняться позже при нажатии на стрелочки клавиатуры self.rect.x += self.change_x # Следим ударяем ли мы какой-то другой объект, платформы, например block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) # Перебираем все возможные объекты, с которыми могли бы столкнуться for block in block_hit_list: # Если мы идем направо, # устанавливает нашу правую сторону на левой стороне предмета, которого мы ударили if self.change_x > 0: self.rect.right = block.rect.left elif self.change_x < 0: # В противном случае, если мы движемся влево, то делаем наоборот self.rect.left = block.rect.right # Передвигаемся вверх/вниз self.rect.y += self.change_y # То же самое, вот только уже для вверх/вниз block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) for block in block_hit_list: # Устанавливаем нашу позицию на основе верхней / нижней части объекта, на который мы попали if self.change_y >0: self.rect.bottom = block.rect.top elif self.change_y < 0: self.rect.top = block.rect.bottom # Останавливаем вертикальное движение self.change_y = 0 def calc_grav(self): # Здесь мы вычисляем как быстро объект будет # падать на землю под действием гравитации if self.change_y == 0: self.change_y = 1 else: self.change_y += .95 # Если уже на земле, то ставим позицию Y как 0 if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0: self.change_y = 0 self.rect.y = SCREEN_HEIGHT - self.rect.height def jump(self): # Обработка прыжка # Нам нужно проверять здесь, контактируем ли мы с чем-либо # или другими словами, не находимся ли мы в полете. # Для этого опускаемся на 10 единиц, проверем соприкосновение и далее поднимаемся обратно self.rect.y += 10 platform_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) self.rect.y -= 10 # Если все в порядке, прыгаем вверх if len(platform_hit_list) > 0 or self.rect.bottom >= SCREEN_HEIGHT: self.change_y = -16 # Передвижение игрока def go_left(self): # Сами функции будут вызваны позже из основного цикла self.change_x = -9 # Двигаем игрока по Х if(self.right): # Проверяем куда он смотрит и если что, то переворачиваем его self.flip() self.right = False def go_right(self): # то же самое, но вправо self.change_x = 9 if (not self.right): self.flip() self.right = True def stop(self): # вызываем этот метод, когда не нажимаем на клавиши self.change_x = 0 def flip(self): # переворот игрока (зеркальное отражение) self.image = pygame.transform.flip(self.image, True, False) # Класс для описания платформы class Platform(pygame.sprite.Sprite): def __init__(self, width, height): # Конструктор платформ super().__init__() # Также указываем фото платформы self.image = pygame.image.load('platform.png') # Установите ссылку на изображение прямоугольника self.rect = self.image.get_rect() # Класс для расстановки платформ на сцене class Level(object): def __init__(self, player): # Создаем группу спрайтов (поместим платформы различные сюда) self.platform_list = pygame.sprite.Group() # Ссылка на основного игрока self.player = player # Чтобы все рисовалось, то нужно обновлять экран # При вызове этого метода обновление будет происходить def update(self): self.platform_list.update() # Метод для рисования объектов на сцене def draw(self, screen): # Рисуем задний фон screen.blit(bg, (0, 0)) # Рисуем все платформы из группы спрайтов self.platform_list.draw(screen) # Класс, что описывает где будут находится все платформы # на определенном уровне игры class Level_01(Level): def __init__(self, player): # Вызываем родительский конструктор Level.__init__(self, player) # Массив с данными про платформы. Данные в таком формате: # ширина, высота, x и y позиция level = [ [210, 32, 500, 500], [210, 32, 200, 400], [210, 32, 600, 300], ] # Перебираем массив и добавляем каждую платформу в группу спрайтов - platform_list for platform in level: block = Platform(platform[0], platform[1]) block.rect.x = platform[2] block.rect.y = platform[3] block.player = self.player self.platform_list.add(block) # Основная функция прогарммы def main(): # Инициализация pygame.init() # Установка высоты и ширины size = [SCREEN_WIDTH, SCREEN_HEIGHT] screen = pygame.display.set_mode(size) # Название игры pygame.display.set_caption("Платформер") # Создаем игрока player = Player() # Создаем все уровни level_list = [] level_list.append(Level_01(player)) # Устанавливаем текущий уровень current_level_no = 0 current_level = level_list[current_level_no] active_sprite_list = pygame.sprite.Group() player.level = current_level player.rect.x = 340 player.rect.y = SCREEN_HEIGHT - player.rect.height active_sprite_list.add(player) # Цикл будет до тех пор, пока пользователь не нажмет кнопку закрытия done = False # Используется для управления скоростью обновления экрана clock = pygame.time.Clock() # Основной цикл программы while not done: # Отслеживание действий for event in pygame.event.get(): if event.type == pygame.QUIT: # Если закрыл программу, то останавливаем цикл done = True # Если нажали на стрелки клавиатуры, то двигаем объект if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: player.go_left() if event.key == pygame.K_RIGHT: player.go_right() if event.key == pygame.K_UP: player.jump() if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT and player.change_x < 0: player.stop() if event.key == pygame.K_RIGHT and player.change_x > 0: player.stop() # Обновляем игрока active_sprite_list.update() # Обновляем объекты на сцене current_level.update() # Если игрок приблизится к правой стороне, то дальше его не двигаем if player.rect.right > SCREEN_WIDTH: player.rect.right = SCREEN_WIDTH # Если игрок приблизится к левой стороне, то дальше его не двигаем if player.rect.left < 0: player.rect.left = 0 # Рисуем объекты на окне current_level.draw(screen) active_sprite_list.draw(screen) # Устанавливаем количество фреймов clock.tick(30) # Обновляем экран после рисования объектов pygame.display.flip() # Корректное закртытие программы pygame.quit()

Также для игры вам потребуются картинки игрока и платформы. Вы можете их скачать ниже.

(фото на задний фон)

Создание игры-платформера “Марио” на Python с нуля

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

Мы подготовили для вас увлекательнейший онлайн-тренинг по созданию игры-платформера “Марио”, который поможет легко и быстро познакомиться с разработкой на Python. Ноль теории, только практика. Смотри и делай!

Кому это будет полезно:

Новичкам. Никогда не программировали? Это не повод отказываться от нового крутого опыта. У вас есть шанс сделать свою собственную игру с графическим интерфейсом на Python и получить опыт практического применения данного языка программирования, а также попробовать себя в роли разработчика игр.
Начинающим Python разработчикам, которые желают систематизировать и углубить свои знания Python, следуя за опытным наставником.

Чему вы сможете научиться:

Писать простые программы с использованием языка Python.
Понимать основы алгоритмов.
Использовать типы данных и классы Python.
Ставить задачу и поэтапно выполнять её.
Использовать лучшие практики.
Понимать основы ООП и использовать данный подход при реализации программ на Python.

Формат тренинга

Вас ждёт прямой эфир с Владимиром Мзоковым с 10:00 до 12:00, общение в чате во время эфира и в специальном телеграм-канале вне эфира. Все примеры и исходные данные также будут в телеграм-канале, к которому Вы сможете присоединиться после регистрации.

Программа тренинга:

Знакомство с платформой разработки PyCharm и языком программирования Python.
Разбор основных типов и конструкций языка.
Создание игры-платформера «Марио» с графическим интерфейсом.
Объектно-ориентированный подход.
Создание первых объектов.
Создание геймплея.
Разбор ошибок.
Подведение итогов.

Учитесь вместе с друзьями

Регистрируйтесь на онлайн интенсив и поделитесь новостью с друзьями. Вместе учиться гораздо интереснее!

UPD: По техническим причинам вебинар пришлось разделить на две части. Вторая часть вебинара начнется 22 сентября в десять часов утра. Подписывайтесь на канал CodeUA, чтобы не пропустить!

Покупай подписку с доступом ко всем курсам и сервисам

Библиотека современных IT знаний в удобном формате

Выбирай свой вариант подписки в зависимости от задач, стоящих перед тобой. Но если нужно пройти полное обучение с нуля до уровня специалиста, то лучше выбирать Базовый или Премиум. А для того чтобы изучить 2-3 новые технологии, или повторить знания, готовясь к собеседованию, подойдет Пакет Стартовый.

Все видеокурсы на 3 месяца
Тестирование по 10 курсам
Проверка 5 домашних заданий
Консультация с тренером 30 мин

Все видеокурсы на 6 месяцев
Тестирование по 16 курсам
Проверка 10 домашних заданий
Консультация с тренером 60 мин

Все видеокурсы на 1 год
Тестирование по 24 курсам
Проверка 20 домашних заданий
Консультация с тренером 120 мин