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

Без дона­тов!

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

Логика игры

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

Алгоритм

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Шарик

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

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

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

Платформа

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

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

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

Счёт

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

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

Игра

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

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

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

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

Что дальше

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

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

Подписывайтесь на наш канал, чтобы делать крутые проекты!