Как написать код для игры

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

Что дальше

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

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

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

Что вы делаете, когда вы играете в какую-то игру и несколько раз не можете пройти одно и то же место? Можно просто найти уже готовое прохождение. Это, конечно, здорово, но что, если вы застряли в разработке игры? Какой гайд прочитать? Так пусть наша статья станет вашим пошаговым руководством к разработке вашей первой игры, если вы все еще не начали ее писать. Если уже начали, то вам все равно не помешает прочитать наши советы — быть может, увидите что-нибудь новое.

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

Это была самая первая игра, причем запрограммированная для калькулятора TI-83 Plus. Позднее она была переписана автором на Java во время обучения в старших классах. Примечательно, что игра так и не была закончена.

Ко всеобщему сожалению, не доводить игры до логического конца — одна из самых распространенных проблем начинающих разработчиков. Соответственно, возникает вопрос: как повысить свою продуктивность и все-таки закончить начатый проект? Ответ прост: прочтите наше «прохождение» разработки игры.

Основные этапы

Если вы разрабатываете игру сами (а начинающие программисты обычно пишут как раз в одиночку), то процесс написания можно разделить на 4 основных этапа (или уровня, как и в играх):

• планирование;
• прототипирование;
• программирование;
• релиз.

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

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

Уровень 1: Планирование

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

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

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

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

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

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

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

Уровень 2: Прототипирование

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

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

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

Вы помните секретные телепорты в игре Super Mario Bros? Игрок мог найти хорошо спрятанные трубы, прыгнув в которые можно было пропустить несколько уровней. Так и здесь. Правда, мы не полностью пропускаем прототипирование, а совмещаем его с планированием.

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

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

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

Уровень 3: Программирование

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

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

На самом деле эти два шага можно выполнить в обратном порядке. Имея какую-либо среду разработки (или язык программирования), вы можете проанализировать ее возможности и решить, что вы сможете написать.

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

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

Но вы не должны унывать! Лучшее решение этих проблем — отвлечься от проекта на несколько дней. Вы очистите ваш ум и позволите новым идеям посетить его. Также неоднократно замечено, что «утро вечера мудренее». Застряли? Не знаете как решить проблему? Ложитесь спать, а на завтрашнее утро вы, возможно, сразу поймете причину ваших неудач. Не работайте до изнеможения и не изнуряйте себя: работа над проектом должна быть в удовольствие.

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

Уровень 4: Релиз

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

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

А финальным боссом всего нашего путешествия будет являться ваша гордость. Вы сделали полноценную игру от начала и до конца! На самом деле, не все могут похвастаться этим.

И помните, дорога к успеху вымощена многократными неудачами. Никогда не сдавайтесь!

Вывод

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

А теперь соберитесь и напишите свою игру!

Перевод статьи «Making Your First Game: A Walkthrough for Game Developers»

Для создания игр на C++ достаточно знать всего 3 ключевых слова и двоеточие!

Почему-то принято считать, что программировать на C++ тяжело, и изучать язык тоже тяжело, у него много особенностей и так далее. Так вот, это все не совсем правда, и даже совсем не правда. Знать все особенности классно, но совершенно не нужно для того, чтобы делать игры…

Для того чтобы делать игры, достаточно знать о самом языке C++ что программы на C++ состоят из строчек, выполняющихся друг за другом. В строчке программы может стоять метка, и на такую метку можно перескочить из любого другого места в программе при помощи goto. А еще в программе могут быть целочисленные переменные, то есть именованные ячейки памяти в которые можно записать число. Ну и самая сложная из необходимых штука — условный оператор, проверяющий условие и выполняющий блок кода в фигурных скобках только если при проверке условия получилась «истина» или «не ноль». И все. Остальное в С++ можно не знать и при этом писать на С++ по несколько игр каждый день.

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

Итак, если взять хорошую библиотеку, то есть Arctic Engine, то игры на С++ можно делать используя только 3 ключевых слова. Наверное, в это никто не поверит, если я не покажу исходный код пары игр?

Следим за руками, краткий справочник по С++:

goto h;
Оператор безусловного перехода на строку с меткой h.

Создаём «Змейку» — первую игру на 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» Пола Винсента Крэйвена.

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