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

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

С чего начать писать код игры?

Привет всем! Решил написать игру на Java. Идея пришла в голову еще месяц назад, но тада была практика, госы, се таке.. Мне честно говоря много разных идей-игр приходило в голову, но те как-то забывались, а эта зацепилась и не хочет вырываться. Суть игры в том, что есть вид сверху, и есть 3 вида юнитов: воины (квадратики), маги (кружочки) и лучники (треугольники) и насоздавать массу таких юнитов и столкнуть вместе, и посмотреть че будет)) Вообщем в Java я сам пока толком не мыслю, да и игры не создавал, поэтому спрашиваю.. С чего начать писать код? Всмысле, что начинать писать?

#1
13:28, 1 июля 2012
#2
13:47, 1 июля 2012

Jazzis
> насоздавать массу таких юнитов и столкнуть вместе, и посмотреть че будет))
Нече ни будит(( Извини.

#3
13:47, 1 июля 2012

сначала описываешь данные, можно в голове, потом описываешь трансформацию данных, можно в голове.

#4
13:57, 1 июля 2012

Jazzis
> С чего начать писать код?
void main() . как обычно.

#5
14:05, 1 июля 2012

_sz
> > С чего начать писать код?
> void main() . как обычно.

Jazzis
> Решил написать игру на Java

Jazzis начни с джика который может помещать юнитов на карту.

#6
14:26, 1 июля 2012

Начни с реализации класса Application и Log, добейся рабочего Hello World приложения:
Инициализация пустого окна, обработка событий окна, main loop, запись в лог Hello World, закрытие окна после нажатия крестика, отлов исключений и сообщение об ошибке в MessageBox ну и там по мелочи найдёшь ещё чем заняться: работа с файлами в логе ну и так далее.

Справишься ? Это тебе как минимум неделя работы. Плюс заодно поймёшь как функционирует оконная программа. Сформируешь стиль написания кода, попутно немного освоишь ООП. Месяц упорно помучаешься потом освоишься. Потоки заодно поклацаешь, если лог асинхронный.

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

Короче худо бедно 3 месяца должно хватить:
Application
Logging
Threading
File management
Timing
Error Handling
Installation
Code Styling
Java Language
Window Events
OOP
.

Потом можешь начинать пилить тетрис в своём окне.

ЗЫ: а при хороших условиях можно уложиться за неделю 🙂

#7
14:42, 1 июля 2012

HarradRush
>> насоздавать массу таких юнитов и столкнуть вместе, и посмотреть че будет))
> Нече ни будит(( Извини.
+1))

Jazzis
Долго будешь с Java возиться, всё таки это ООП. Берёшь Blitz3D (либо BlitzPlus) Basic и за вечер выведешь свои фигуры (а можешь и рисунки). Если что будет не понятно, пиши, подскажу.

#8
14:53, 1 июля 2012

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

#9
15:07, 1 июля 2012

AMM1AK
> Нече ни будит(( Извини.
эт я так жанр стратегии описал :DDD

#10
15:09, 1 июля 2012

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

• horizonOffset
• Постоялец

#11
15:11, 1 июля 2012

Jazzis
Бери LWJGL, посмотри статьи, туториалы по работе с OpenGL, напиши игру. Всё.
Но это не самый лучший выход.

Да и для такой задачи можно взять что-то попроще. Тот же Love2D более чем подходит.

• horizonOffset
• Постоялец

#12
15:14, 1 июля 2012

Есть ещё Pygame — библиотека для создания игр на Python.
Сам долгое время работал, лучшего средства для создания прототипа не найти.
Т.к. ты не знаешь Java, то один фиг тебе придётся что-то учить, а Python намного легче и удобнее богомерзкой явы.

#13
15:34, 1 июля 2012

horizonOffset
> Т.к. ты не знаешь Java, то один фиг тебе придётся что-то учить, а Python
> намного легче и удобнее богомерзкой явы.

С питоном я уже на ты, и знаю его давно, с java я тож работал, но ток сплошные проверки.. Поэтому хочу чего-то новенького. Недавно работал с паскалем (забыл его), вспоминая его)) От питона я устал, от его легкости.. поэтому и хочу писать на чего-нить новом))) Java еще и кроссплатформенная..

#14
15:37, 1 июля 2012

Jazzis
> Java еще и кроссплатформенная..
Python тоже.

Игровой код, который сам себя программирует

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

Для непосвящённых: Haxe — это язык программирования и кросс-компилятор. Это значит, что можно написать игру на Haxe, и она автоматически «переводится» на другой язык программирования, в зависимости от выбранной платформы (C++ для Windows, JavaScript для Web, и т.д.), и компилируется в нативную программу для той платформы.

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

Кстати, некоторые из этих функций есть и в других языках, но могут называться по-другому. Так что эти идеи могут пригодиться не только тем, кто пишет на Haxe.

Условная компиляция

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

Например, при разработке игр я всегда пользуюсь собственным редактором уровней, который встроен в саму игру. За исключением игры Speebot, этот редактор доступен только мне, и не включён в конечную сборку, которую запускает игрок. Это достигается «заворачиванием» всего кода, что связан с редактором, в условие, которое проверяет наличие флага «dev» при компиляции. Если флага нет — редактор «стирается» из исходного кода перед нативной компиляцией игры.

Эта функция также позволяет мне отделять ресурсы для «demo» и «prod» версий. Демо версии моих игр включают в себя несколько уровней игры, и я использую флаги компилятора, чтобы определить, какие уровни, файлы музыки и т.д. нужно включить в сборку. Так неиспользуемые ресурсы просто не попадают в демо версии.

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

Мета данные

В Haxe есть функции metadata, которые могут быть использованы для аннотации, чтения и манипуляции частей исходного кода, который обычно не доступен.

В моём случае, есть класс Settings, в котором есть набор переменных для опций, доступных игроку в меню Опции. Настройки пользователя хранятся в отдельном файле. Этот файл генерируется автоматически на основе класса Settings. Движок бежит по всем переменным класса, и сохраняет или загружает значения из файла. Для этого используется reflection API.

Не все переменные в Settings нужно сохранять в файле, так как там есть и константы, которые менять не нужно. Такие поля помечаются мета тэгом «@ignore(true)». Движок, видя эту аннотацию, не включает такое поле в файл.

Макро

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

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

Но самый большой плюс для меня — это возможность переместить код из run-time в compile-time.

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

Эта логика работает нормально до тех пор, пока не становится необходимо показать эту информацию для 200 уровней одновременно. Игре необходимо загрузить и обработать 200 файлов уровней, что использует много памяти и реально тормозит игру на несколько секунд.

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

Решение: написать макро, которое загружает все 200 уровней (у макро есть доступ к файловой системе), обрабатывает все необходимые данные, и сохраняет нужные числа в массивы. Игре больше не нужно ничего вычислять в run-time, потому что вся информация на этот момент уже жёстко прописана в исходном коде игры с помощью макро.

Такой же подход используется в игре Путь Фантома. Игрок может найти артефакт, который показывает количество пропущенных секретов, сокровищ, записок и т.д. в каждой области игры на карте. Вместо того, чтобы загружать и обрабатывать информацию всех областей игры в run-time, это происходит в момент компиляции с помощью макро.

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

• haxe
• metaprogramming
• программирование
• игры
• программирование игр
• разработка