Как змея запускать: Воздушные змеи — статья из серии «Детский отдых»

Запуск воздушного змея — PROKITE

Фестиваль воздушных змеев в городе Червия (Италия)

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

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

Сила ветра

Чудес не бывает: без ветра подавляющее большинство воздушных змеев летать не может, если только вы не чемпион мира по бегу. Поэтому перед тем, как решить запускать своего змея, убедитесь, что ветра достаточно. Трава под ногами заметно шевелится, как и тонкие ветки деревьев (если шевелятся только листья — ветра не достаточно), флаги полощатся, рябь на воде. По всем этим признакам можно оценить, что погода подходит для запуска. Когда ветер слишком сильный, возникает опасность сломать воздушного змея, так что если вам некомфортно, когда ветер дует в лицо, то скорее всего запускать не стоит.

Направление ветра

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

Техника запуска

Обычный запуск

(сила ветра любая, два человека, любой змей)

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

Запуск с рук

(нормальный или сильный ветер, один человек, змей с короткой уздечкой или без уздечки)

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

Запуск “Подтянуть — отпустить”

(слабый или неровный ветер, маленькое пространство для запуска, 1–2 человека)

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

Безопасность

Запуск змея — одна из самых безопасных игр, но при некоторых условиях.

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

Змей не взлетает?

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

Фестивали — это круто!

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

Как запускать воздушного змея?

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

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

Воздушный разведчик

Коробчатый змей

Этажерочный змей

Простой воздушный змей

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

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

Лучшее условие для запуска – скорость ветра от 6 метров в секунду. Нужно поймать нужный ветер, отпустить веревочки и поднять его на минимальную высоту, потому как возле земли ветер переменчивый из-за ландшафта. Чуть повыше – метров в 5-10 от земли ветер уже более-менее стабильный. Чем выше он будет находиться, тем больше шансов, что змей будет стабильно летать. Так как более-менее профессиональные воздушные змеи достаточно большие, важно не пренебрегать системой управления.

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

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

Каркасные змеи могут взлетать в не ветреную погоду. Для запуска достаточно ветра силой до 4 метров в секунду. Пилотируемые змеи поднимаются ввысь максимум на 50 метров. Чтобы его покорить, нужно много терпения и времени, не хитрые движения доводятся до автоматизма. Если нижние стропы опускать вверх, то змей, соответственно, поднимается вверх, когда ручки опускаются стропами вниз, он опускается вниз. Если опускать одну сторону, он поворачивается.

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

Читать: Воздушные змеи, смотреть фото Воздушных змеев

Фото Воздушных змеев

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

Интересные факты про воздушного змея

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

Змеиная игра на Python | Программа Snake Game с использованием Pygame

Стать сертифицированным профессионалом

Да, я знаю, что вы все играли в Snake Game и определенно никогда не хотели проиграть. В детстве мы все любили искать читы, чтобы никогда не увидеть сообщение «Игра окончена», но, как технари, я знаю, что вы хотели бы, чтобы эта «Змея» танцевала под ваши биты. Это то, что я покажу вам всем в этой статье об игре Snake на Python.

Хотите повысить свою квалификацию, чтобы продвинуться по карьерной лестнице? Проверьте или присоединяйтесь к нашему курсу Data Science with Python.
Прежде чем двигаться дальше, давайте кратко рассмотрим все части, которые создают игру Snake на Python:

1. Установка Pygame
2. Создание экрана
3. Создание змейки
4. Перемещение змейки
90 015 Игра окончена, когда Змейка достигает границ
5. Добавление еды
6. Увеличение длины змейки
7. Отображение счета

Установка Pygame:

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

pip install pygame

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

Функция	Описание
init()	Инициализирует все импортированные модули Pygame (возвращает кортеж, указывающий на успех или неудачу инициализации)
display.set_mode() 9 0048	Принимает кортеж или список в качестве своего параметр для создания поверхности (предпочтительно кортеж)
update()	Обновляет экран
quit()	Используется для деинициализации всего
set_caption()	Устанавливает текст заголовка вверху экрана
event.get()	Возвращает список всех события
Surface.fill( )	Зальет поверхность сплошным цветом
time.Clock()	Помогает отслеживать время time
font.SysF ont()	Создаст шрифт Pygame из системы шрифтовые ресурсы

Создание экрана:

Чтобы создать экран с помощью Pygame, вам потребуется использовать функцию display. set_mode()

. Кроме того, вам придется использовать методы init() и quit() для инициализации и деинициализации всего в начале и в конце кода. Метод update() используется для обновления любых изменений, сделанных на экране. Существует еще один метод, например, flip() , который работает аналогично функции update(). Разница в том, что метод update() обновляет только сделанные изменения (однако, если параметры не переданы, обновляется весь экран), а метод flip() снова переделывает весь экран.

КОД:

 импорт pygame
pygame.init()
дис=pygame.display.set_mode((400,300))
pygame.display.update()
pygame.выйти()
quit() 

ВЫВОД:

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

 import pygame
pygame.  init()
дис=pygame.display.set_mode((400,300))
pygame.display.update()
pygame.display.set_caption('Змейка от Edureka')
game_over = Ложь
пока не game_over:
    для события в pygame.event.get():
        print(event) #распечатывает все действия, происходящие на экране
pygame.выйти()
выйти() 

Когда вы запустите этот код, вы увидите, что экран, который вы видели ранее, не закрывается, а также он возвращает все действия, которые происходят над ним. Я сделал это, используя функцию event.get() . Кроме того, я назвал экран «Snake Game by Edureka», используя функцию display.set_caption() .

ВЫВОД:

Теперь у вас есть экран для игры в змейку, но когда вы пытаетесь нажать кнопку закрытия, экран не закрывается. Это потому, что вы не указали, что ваш экран должен закрыться, когда вы нажмете эту кнопку закрытия. Для этого Pygame предоставляет событие под названием «ВЫХОД», и его следует использовать следующим образом:0004

  импорт pygame
pygame. init()
дис=pygame.display.set_mode((400,300))
pygame.display.update()
pygame.display.set_caption('Змейка от Edureka')
game_over = Ложь
пока не game_over:
    для события в pygame.event.get():
        если event.type==pygame.ВЫЙТИ:
            game_over = Истина
pygame.выйти()
quit() 

Итак, теперь ваш экран готов. Следующая часть — нарисовать нашу змею на экране, что рассматривается в следующем разделе.

Создайте змею:

Чтобы создать змею, я сначала инициализирую несколько цветовых переменных, чтобы раскрасить змею, еду, экран и т. д. Цветовая схема, используемая в Pygame, — это RGB, т. е. «Красный Зеленый Синий» . Если вы установите все это на 0, цвет будет черным, а все 255 будут белыми. Так что наша змея на самом деле будет прямоугольником. Чтобы рисовать прямоугольники в Pygame, вы можете использовать функцию с именем 9.0008 draw.rect() 

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

 импорт pygame
pygame. init()
дис=pygame.display.set_mode((400,300))
pygame.display.set_caption('Змейка от Edureka')
синий = (0,0,255)
красный=(255,0,0)
game_over = Ложь
пока не game_over:
    для события в pygame.event.get():
        если event.type==pygame.ВЫЙТИ:
            game_over = Истина
    pygame.draw.rect(dis,синий,[200,150,10,10])
    pygame.display.update()
pygame.выйти()
выйти() 

ВЫВОД:

Как видите, змееголов создан в виде синего прямоугольника. Следующий шаг — заставить вашу змею двигаться.

Перемещение змеи:

Чтобы переместить змею, вам нужно будет использовать ключевые события, присутствующие в классе KEYDOWN Pygame. Здесь используются события K_UP, K_DOWN, K_LEFT и K_RIGHT, чтобы заставить змею двигаться вверх, вниз, влево и вправо соответственно. Кроме того, экран дисплея меняется с черного по умолчанию на белый с помощью кнопки 9.0008 метод fill()

.

Я создал новые переменные x1_change и y1_change для хранения обновленных значений координат x и y.

 импорт pygame
pygame.init()
белый = (255, 255, 255)
черный = (0, 0, 0)
красный = (255, 0, 0)
dis = pygame.display.set_mode((800, 600))
pygame.display.set_caption('Змейка от Edureka')
game_over = Ложь
х1 = 300
у1 = 300
х1_изменить = 0
у1_изменить = 0
часы = pygame.time.Clock()
пока не game_over:
    для события в pygame.event.get():
        если event.type == pygame.ВЫЙТИ:
            game_over = Истина
        если event.type == pygame.KEYDOWN:
            если event.key == pygame.K_LEFT:
                x1_change = -10
                у1_изменить = 0
            elif event.key == pygame.K_RIGHT:
                х1_изменить = 10
                у1_изменить = 0
            Элиф event.key == pygame.K_UP:
                y1_change = -10
                х1_изменить = 0
            Элиф event.key == pygame.K_DOWN:
                у1_изменить = 10
                х1_изменить = 0
    x1 += x1_change
    y1 += y1_change
    дис.заполнение(белый)
    pygame.draw.rect(dis, черный, [x1, y1, 10, 10])
    pygame.  display.update()
    часы.тик(30)
pygame.выйти()
выйти() 

ВЫВОД:

Игра окончена, когда Змея достигает границ:

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

 импорт pygame
время импорта
pygame.init()
белый = (255, 255, 255)
черный = (0, 0, 0)
красный = (255, 0, 0)
dis_width = 800
dis_height = 600
dis = pygame.display.set_mode((dis_width, dis_width))
pygame.display.set_caption('Змейка от Edureka')
game_over = Ложь
x1 = ширина_ширины/2
у1 = высота_высоты/2
змея_блок = 10
х1_изменить = 0
у1_изменить = 0
часы = pygame.time.Clock()
змея_скорость=30
font_style = pygame. font.SysFont (нет, 50)
сообщение защиты (сообщение, цвет):
    сообщение = стиль_шрифта.рендер (сообщение, Истина, цвет)
    dis.blit(mesg, [dis_width/2, dis_height/2])
пока не game_over:
    для события в pygame.event.get():
        если event.type == pygame.ВЫЙТИ:
            game_over = Истина
        если event.type == pygame.KEYDOWN:
            если event.key == pygame.K_LEFT:
                x1_change = -snake_block
                у1_изменить = 0
            elif event.key == pygame.K_RIGHT:
                x1_change = змеиный_блок
                у1_изменить = 0
            Элиф event.key == pygame.K_UP:
                y1_change = -snake_block
                х1_изменить = 0
            Элиф event.key == pygame.K_DOWN:
                y1_change = змеиный_блок
                х1_изменить = 0
    если x1 > = dis_width или x1 < 0 или y1 >= dis_height или y1 < 0:
        game_over = Истина
    x1 += x1_change
    y1 += y1_change
    дис.заполнение(белый)
    pygame.draw.rect(dis, черный, [x1, y1, змея_блок, змея_блок])
    pygame. display.update()
    часы.тик (snake_speed)
сообщение("Вы потеряли",красный)
pygame.display.update()
время сна(2)
pygame.выйти()
выйти() 

ВЫВОД:

Добавление еды:

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

 импорт pygame
время импорта
импортировать случайный
pygame.init()
белый = (255, 255, 255)
черный = (0, 0, 0)
красный = (255, 0, 0)
синий = (0, 0, 255)
dis_width = 800
dis_height = 600
dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Змейка от Edureka')
часы = pygame.time.Clock()
змея_блок = 10
змея_скорость = 30
font_style = pygame.font.SysFont (нет, 30)
сообщение def (msg, цвет):
    сообщение = стиль_шрифта.рендер (сообщение, Истина, цвет)
    dis.blit(mesg, [dis_width/3, dis_height/3])
def gameLoop(): # создание функции
    game_over = Ложь
    game_close = Ложь
    x1 = ширина_расширения / 2
    у1 = высота_высоты / 2
    х1_изменить = 0
    у1_изменить = 0
    foodx = round(random. randrange(0, dis_width - змея_блок) / 10,0) * 10,0
    foody = round(random.randrange(0, dis_width - змея_блок) / 10.0) * 10.0
    пока не game_over:
        в то время как game_close == Истина:
            дис.заполнение(белый)
            message("Вы проиграли! Нажмите Q-Quit или C-Play еще раз", красный)
            pygame.display.update()
            для события в pygame.event.get():
                если event.type == pygame.KEYDOWN:
                    если event.key == pygame.K_q:
                        game_over = Истина
                        game_close = Ложь
                    если event.key == pygame.K_c:
                        игровой цикл()
        для события в pygame.event.get():
            если event.type == pygame.ВЫЙТИ:
                game_over = Истина
            если event.type == pygame.KEYDOWN:
                если event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    у1_изменить = 0
                elif event.key == pygame. K_RIGHT:
                    x1_change = змеиный_блок
                    у1_изменить = 0
                Элиф event.key == pygame.K_UP:
                    y1_change = -snake_block
                    х1_изменить = 0
                Элиф event.key == pygame.K_DOWN:
                    y1_change = змеиный_блок
                    х1_изменить = 0
        если x1 >= dis_width или x1 < 0 или y1 >= dis_height или y1 < 0:
            game_close = Истина
        x1 += x1_change
        y1 += y1_change
        дис.заполнение(белый)
        pygame.draw.rect(dis, blue, [foodx, foody, змея_блок, змея_блок])
        pygame.draw.rect(dis, черный, [x1, y1, змея_блок, змея_блок])
        pygame.display.update()
        если x1 == foodx и y1 == foody:
            print("Вкусняшка!!")
        часы.тик (snake_speed)
    pygame.выйти()
    покидать()
игровой цикл() 

ВЫХОД:

Терминал:

Увеличение длины змейки: 9 0002 Следующий код увеличит размер нашего саке, когда он съест еду. Кроме того, если змея сталкивается со своим телом, игра окончена, и вы увидите сообщение «Вы проиграли! Нажмите Q-Quit или C-Play еще раз». Длина змеи в основном содержится в списке, а начальный размер, указанный в следующем коде, равен одному блоку.

 импорт pygame
время импорта
импортировать случайный
pygame.init()
белый = (255, 255, 255)
желтый = (255, 255, 102)
черный = (0, 0, 0)
красный = (213, 50, 80)
зеленый = (0, 255, 0)
синий = (50, 153, 213)
dis_width = 600
dis_height = 400
dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Змейка от Edureka')
часы = pygame.time.Clock()
змея_блок = 10
змея_скорость = 15
font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
def our_snake (змеиный_блок, змеиный_список):
    для x в змее_списке:
        pygame.draw.rect (dis, черный, [x [0], x [1], змея_блок, змея_блок])
сообщение def (msg, цвет):
    сообщение = стиль_шрифта.рендер (сообщение, Истина, цвет)
    dis. blit(mesg, [dis_width / 6, dis_height / 3])
определение игрового цикла():
    game_over = Ложь
    game_close = Ложь
    x1 = ширина_расширения / 2
    у1 = высота_высоты / 2
    х1_изменить = 0
    у1_изменить = 0
    змея_Список = []
    Длина_змеи = 1
    foodx = round(random.randrange(0, dis_width - змея_блок) / 10,0) * 10,0
    foody = round(random.randrange(0, dis_height - змея_блок) / 10.0) * 10.0
    пока не game_over:
        в то время как game_close == Истина:
            dis.fill (синий)
            message("Вы проиграли! Нажмите C-Play еще раз или Q-Quit", красный)
            pygame.display.update()
            для события в pygame.event.get():
                если event.type == pygame.KEYDOWN:
                    если event.key == pygame.K_q:
                        game_over = Истина
                        game_close = Ложь
                    если event.key == pygame.K_c:
                        игровой цикл()
        для события в pygame.event.get():
            если event. type == pygame.ВЫЙТИ:
                game_over = Истина
            если event.type == pygame.KEYDOWN:
                если event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    у1_изменить = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = змеиный_блок
                    у1_изменить = 0
                Элиф event.key == pygame.K_UP:
                    y1_change = -snake_block
                    х1_изменить = 0
                Элиф event.key == pygame.K_DOWN:
                    y1_change = змеиный_блок
                    х1_изменить = 0
        если x1 >= dis_width или x1 < 0 или y1 >= dis_height или y1 < 0:
            game_close = Истина
        x1 += x1_change
        y1 += y1_change
        dis.fill (синий)
        pygame.draw.rect(dis, green, [foodx, foody, змея_блок, змея_блок])
        змея_голова = []
        змея_Head.append (x1)
        змея_Head.append(y1)
        змея_List.append (snake_Head)
        если len(snake_List) > Length_of_snake:
            список_змей[0]
        для x в змее_List[:-1]:
            если х == змея_голова:
                game_close = Истина
        наша_змея (змея_блок, змея_список)
        pygame. display.update()
        если x1 == foodx и y1 == foody:
            foodx = round(random.randrange(0, dis_width - змея_блок) / 10,0) * 10,0
            foody = round(random.randrange(0, dis_height - змея_блок) / 10.0) * 10.0
            Длина_змеи += 1
        часы.тик (snake_speed)
    pygame.выйти()
    покидать()
игровой цикл() 

ВЫВОД:

Отображение счета:

И последнее, но не менее важное: вам нужно будет отображать счет игрока. Для этого я создал новую функцию «Your_score». Эта функция будет отображать длину змеи за вычетом 1, потому что это начальный размер змеи.

 импорт pygame
время импорта
импортировать случайный
pygame.init()
белый = (255, 255, 255)
желтый = (255, 255, 102)
черный = (0, 0, 0)
красный = (213, 50, 80)
зеленый = (0, 255, 0)
синий = (50, 153, 213)
dis_width = 600
dis_height = 400
dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('Змейка от Edureka')
часы = pygame. time.Clock()
змея_блок = 10
змея_скорость = 15
font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
Def Your_score(счет):
    value = score_font.render("Ваша оценка: " + str(score), True, желтый)
    dis.blit(значение, [0, 0])
def our_snake (змеиный_блок, змеиный_список):
    для x в змее_списке:
        pygame.draw.rect (dis, черный, [x [0], x [1], змея_блок, змея_блок])
сообщение def (msg, цвет):
    сообщение = стиль_шрифта.рендер (сообщение, Истина, цвет)
    dis.blit(mesg, [dis_width / 6, dis_height / 3])
определение игрового цикла():
    game_over = Ложь
    game_close = Ложь
    x1 = ширина_расширения / 2
    у1 = высота_высоты / 2
    х1_изменить = 0
    у1_изменить = 0
    змея_Список = []
    Длина_змеи = 1
    foodx = round(random.randrange(0, dis_width - змея_блок) / 10,0) * 10,0
    foody = round(random.randrange(0, dis_height - змея_блок) / 10.0) * 10.0
    пока не game_over:
        в то время как game_close == Истина:
            dis. fill (синий)
            message("Вы проиграли! Нажмите C-Play еще раз или Q-Quit", красный)
            Your_score(Length_of_snake - 1)
            pygame.display.update()
            для события в pygame.event.get():
                если event.type == pygame.KEYDOWN:
                    если event.key == pygame.K_q:
                        game_over = Истина
                        game_close = Ложь
                    если event.key == pygame.K_c:
                        игровой цикл()
        для события в pygame.event.get():
            если event.type == pygame.ВЫЙТИ:
                game_over = Истина
            если event.type == pygame.KEYDOWN:
                если event.key == pygame.K_LEFT:
                    x1_change = -snake_block
                    у1_изменить = 0
                elif event.key == pygame.K_RIGHT:
                    x1_change = змеиный_блок
                    у1_изменить = 0
                Элиф event.key == pygame.K_UP:
                    y1_change = -snake_block
                    х1_изменить = 0
                Элиф event. key == pygame.K_DOWN:
                    y1_change = змеиный_блок
                    х1_изменить = 0
        если x1 >= dis_width или x1 < 0 или y1 >= dis_height или y1 < 0:
            game_close = Истина
        x1 += x1_change
        y1 += y1_change
        dis.fill (синий)
        pygame.draw.rect(dis, green, [foodx, foody, змея_блок, змея_блок])
        змея_голова = []
        змея_Head.append (x1)
        змея_Head.append(y1)
        змея_List.append (snake_Head)
        если len(snake_List) > Length_of_snake:
            список_змей[0]
        для x в змее_List[:-1]:
            если х == змея_голова:
                game_close = Истина
        наша_змея (змея_блок, змея_список)
        Your_score(Length_of_snake - 1)
        pygame.display.update()
        если x1 == foodx и y1 == foody:
            foodx = round(random.randrange(0, dis_width - змея_блок) / 10,0) * 10,0
            foody = round(random.randrange(0, dis_height - змея_блок) / 10.0) * 10.0
            Длина_змеи += 1
        часы. тик (snake_speed)
    pygame.выйти()
    покидать()
игровой цикл()
 

ВЫВОД:

На этом мы подошли к концу этой статьи об игре «Змейка» на Python. Я надеюсь, что вы поняли все, что было сказано в этой статье. Убедитесь, что вы тренируетесь как можно больше и возвращаете свой опыт.   

Есть к нам вопрос? Пожалуйста, укажите это в разделе комментариев этого блога «Snake Game in Python», и мы свяжемся с вами как можно скорее.

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

Змейка с PyGame | Replit Docs

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

В этом уроке мы реализуем самую простую форму Змеи в pygame 9.0004

Мы будем использовать веб-IDE Replit для создания нашей версии Snake.

Давайте немного подумаем, что нам нужно сделать. Змея в своей основной форме представляет собой серию блоков, представляющих змею, движущуюся по сетке, направление которой контролирует игрок. Также в ней есть простые правила — когда змея касается сторон экрана, она умирает. Если змея перекрестится, она тоже погибнет. Если змея съест немного еды (блок другого типа), она вырастет на 1 блок. Затем еда снова появляется в другом случайном месте на экране.

Нам нужно построить несколько компонентов:

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

Есть над чем подумать! Давайте начнем и создадим проект в Replit.

Перейдите к Replit и создайте новый repl. Выберите Python в качестве языка. Теперь дайте этой реплике имя, например «snake-pygame».

После загрузки repl вы должны увидеть файл main.py . Здесь мы начнем кодировать.

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

Мы можем импортировать его в наш проект, добавив следующую строку в наш файл main.py :

 import pygame 
 

Чтобы запустить инфраструктуру pygame, нам нужно добавить код инициализации: ()
bounds = (300,300)
window = pygame. display.set_mode(bounds)
pygame.display.set_caption("Snake")

Строка 1 этого кода запускает систему pygame, инициализируя ее модули (например, код шрифта, звука или графики). Строка 2 создает новый кортеж с именем bounds . Этот кортеж содержит размеры окна, в котором мы будем запускать нашу игру про змейку. Строка 3 создает новое окно для отображения нашей игры. Строка 4 дает окну заголовок или заголовок. Это может быть все, что вы хотели бы назвать игрой.

Если вы запустите проект с помощью кнопки « Run > » вверху в центре реплики, вы увидите небольшое пустое окно. Это означает, что все инициализировано и работает до сих пор.

Теперь, когда у нас есть основная структура, давайте создадим класс для моделирования нашей змеи. У этого класса будут следующие обязанности:

1. Следить за тем, где находится змея.
2. Отслеживание длины змеи.
3. Позволить змее расти.
4. Проверка на коллизии с границами окна.
5. Проверка того, не пересекла ли змея («укусила») себя
6. Отслеживание направления движения змеи.

Давайте начнем с создания нового файла с именем змея.py . Добавьте следующий код:

 из enum import Enum 
 class Direction(Enum): 
 UP = 0 
 DOWN = 1 
 LEFT = 2 
 RIGHT = 3 
 
 class Snake: 
 length = None 
 direction = None 9001 2 тела = None 
 block_size = None 
 color = (0,0,255) 
 bounds = None 
 
 def __init__(self, block_size, bounds): 
 self.block_size = block_size 
 self.bounds = bounds 
 self.respawn() 
 
 def respawn(self): 
 self.length = 3 
 self.body = [(20,20),(20,40),(20,60)] 
 self.direction = направление .DOWN 
 
 

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

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

Затем у нас есть метод инициализации в строке, начинающейся с def __init__ . Когда мы создаем экземпляр нашего класса Snake , мы передаем block_size , который должен быть целым числом с размером каждого блока, составляющего нашу сетку. Это используется для размера каждого сегмента змейки, а также для позиционирования и перемещения змейки на доске. Мы также проходим в ограничивает , который представляет собой набор целых чисел с шириной и высотой игровой области (того же размера, что и область экрана). Так мы можем проверить, вышла ли змея за границы. В методе инициализатора мы назначаем эти входные данные инициализатора нашим внутренним переменным, чтобы позже мы могли использовать их в других методах. Затем мы вызываем наш внутренний метод respawn , который содержит настройку по умолчанию для длины змеи, определения начального сегмента тела и начального направления. Мы также позвоним возрождается всякий раз, когда змея падает или умирает другими способами, чтобы сбросить игру.

Давайте немного посмотрим на переменную body . Это список Python, содержащий кортежи (или пары) координат. Каждая из этих координат описывает верхние левые x и y положения экрана сегмента тела или блока. Мы будем добавлять (дополнять) этот список по мере роста змеи. Мы также используем этот список при рисовании змеи.

Теперь, когда у нас есть основы Класс Snake и его код инициализации запущены, давайте добавим метод для рисования змеи на экране. Добавьте это к классу Snake :

 def draw(self, game, window): 
 для сегмента в self.body: 
 game.draw.rect(window, self.color, (segment[0],segment[ 1],self. block_size, self.block_size)) 
 

Этот метод принимает экземпляр pygame, game и окно (или поверхность в общей терминологии pygame) для рисования. Затем он перебирает каждый из кортежей в body и использует pygame, встроенный в метод draw.rect , для рисования прямоугольника для каждого блока или сегмента змеи в списке body. Мы также используем наш параметр block_size для установки ширины и высоты нарисованного прямоугольника.

Давайте попробуем то, что у нас есть. Мы просто увидим несколько статических блоков на экране, но это хороший тест, чтобы увидеть, все ли на правильном пути. Чтобы это заработало, давайте импортируем и создадим новый объект Snake и настроим первую часть нашего игрового цикла в main.py .

Добавьте код для импорта классов в файл snake.py вверху файла main.py , сразу под строкой import pygame : следующий код прямо под строкой pygame. display.set_caption("Snake") :

 block_size = 20 
 змея = Snake(block_size, bounds) 
 

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

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

Добавьте следующее в файл main.py , чтобы настроить игровой цикл:

 run = True 
 while run: 
 pygame.time.delay(100) 
 для события в pygame.event.get(): 
 if event.type == pygame.QUIT: 
 run = False 
 
 window. fill ((0,0,0)) 
 snake.draw(pygame, window) 
 pygame.display.flip() 
 
 

Этот код устанавливает цикл, который повторяется каждые 100 мс, пока из окна не будет получен сигнал выхода. . Это запускается, когда игрок нажимает кнопку «Закрыть окно» в верхней части окна. Pygame имеет концепцию очереди событий, в которую он записывает различные инициированные события. Мы можем читать эту очередь событий каждый раз, когда мы зацикливаемся в нашем игровом цикле, и проверять, не было ли какое-либо из событий числом 9.0331 Сигнал ВЫЙТИ . Затем мы можем установить условие для запуска цикла на False , и в следующий раз, когда цикл будет повторяться, наше условие while больше не будет истинным, и игра завершится.

Наш цикл также очищает окно в каждом раунде, готовясь к отрисовке обновленного состояния игры. Вы можете видеть это в строке window.fill((0,0,0)) . Это заполняет все окно черным цветом, указанным в кортеже цвета RGB (0,0,0) . Теперь, когда у нас есть чистый лист, мы можем назвать нарисуйте метод на нашем объекте-змее. Мы передаем объекты pygame и Window, чтобы Snake мог рисовать на них. Когда мы визуализируем нашу еду, мы будем называть ее после этой строки.

Наконец, мы делаем окончательный рендеринг на экран, вызывая pygame.display.flip() . Это берет все наши обновления и «переворачивает» их из оконного буфера на экран.

Чтобы проверить, что игровой цикл и отрисовка работают, запустите программу, нажав большую кнопку « Run > » в верхней части repl. В правом верхнем углу изображения вы должны увидеть черное окно с несколькими блоками, изображающими змею.

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

Чтобы сделать это, добавьте этот метод в класс Snake в файле snap. py :

 def move(self): 
 curr_head = self.body[-1] 
 if self.direction == Direction .DOWN: 
 next_head = (curr_head[0], curr_head[1] + self.block_size) 
 self.body.append(next_head) 
 elif self.direction == Direction.UP: 
 next_head = (curr_head[0], curr_head[1] - self.block_size) 
 self.body.append(next_head) 
 elif self .direction == Direction.RIGHT: 
 next_head = (curr_head[0] + self.block_size, curr_head[1]) 
 self.body.append(next_head) 
 elif self.direction == Direction.LEFT: 
 next_head = ( curr_head[0] - self.block_size, curr_head[1]) 
 self.body.append(next_head) 
, если self.length < len(self.body): 
 self.body.pop(0) 
 
 

Этот метод получает «голову» змеи, которая является последним элементом нашего списка body . Python имеет удобную функцию отрицательных индексов. Это означает, что индекс -1 возвращает последний элемент в списке, -2 возвращает предпоследний и так далее. Это позволяет нам легко получить последний элемент или переднюю часть змеи в нашем списке тел, используя код curr_head = self.body[-1] .

После того, как мы получили голову змеи, мы проверяем, в каком направлении движется змея. Если она движется вверх или вниз, мы добавляем новый блок, копируя координату x текущей головы и добавляя или вычитая (в зависимости от того, идет ли змейка вверх или вниз) одна сетка block_size на координату y. Точно так же, если змея движется влево или вправо, мы добавляем новый блок в список body , используя координату y текущей головы, но изменяя координату x на единицу block_size .

Как только это будет сделано, мы удалим блок в хвостовой части змеи, используя код self.body.pop(0) . Однако перед этим у нас есть условие: if self.length < len(self.body) . Это важно, когда мы доберемся до того, как змея ест или растет. Каждый раз, когда змея ест, мы увеличиваем длина свойство змеи. Затем мы можем использовать это свойство length , чтобы определить, должны ли мы на самом деле удалять хвостовой сегмент змеи, когда она движется.

Теперь давайте добавим вызов этого метода move в наш игровой цикл. В файле main.py измените игровой цикл, чтобы вызвать этот метод:

 run = True 
 while run: 
 pygame.time.delay(100) 
 для события в pygame.event.get(): 
 if event.type == pygame.QUIT: 
 run = False 
 
 змейка.move() 
 window.fill((0,0,0)) 
 змейка.draw(pygame, окно) 
 pygame.display.update() 
 
 

Обратите внимание, что мы добавили строку змея.move() . Это вызовет наш метод move , который мы добавляли к нашей змейке в каждом цикле. Это создаст впечатление, что змея плавно движется по экрану. Проверьте это, нажав кнопку « Run > » в верхней центральной части repl. Змея должна начинаться в левом верхнем углу окна и двигаться вниз по экрану, пока не исчезнет за пределами окна.

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

 def steer(self, direction): 
 if self.direction == Direction.DOWN and direction != Direction. ВВЕРХ: 
 self.direction = направление 
 elif self.direction == Direction.UP и направление != Direction.DOWN: 
 self.direction = направление 
 elif self.direction == Direction.LEFT и direction != Direction.RIGHT: 
 self.direction = direction 
 elif self.direction == Direction.RIGHT и direction != Direction.LEFT: 
 self.direction = direction 
 

Этот метод работает, принимая аргумент direction , который должен быть одним из наших Значения перечисления Direction , которые мы определили ранее. Затем мы делаем проверку для каждого возможного направления, чтобы убедиться, что новое введенное направление не является полностью противоположным направлением, в котором в данный момент движется змея — это потому, что мы не хотим допускать реверсирования змеи в нашей игре. Если входное направление является допустимым ходом, мы обновляем 9 змеи.0331 направление им. Как вы помните из нашего метода move , это свойство используется для определения того, как обновить свойство list body змеи, чтобы создать движение змеи.

Теперь, когда мы можем обновить направление змеи с помощью управляющей команды, нам нужно получить информацию от игрока. В Pygame есть полезный метод key.get_pressed() , который возвращает список, содержащий логический элемент для каждой клавиши на клавиатуре. Это позволяет нам определить, какую клавишу нажимает игрок, просматривая значение по правильному индексу в этом списке клавиш. К счастью, нам не нужно запоминать правильный индекс для каждого ключа, поскольку в pygame есть удобочитаемые имена, определенные как константы, которые мы можем использовать. Например, чтобы узнать, нажата ли стрелка вверх, мы можем вызвать keys = pygame.key.get_pressed() , чтобы получить список статусов для всех ключей. Затем мы можем найти состояние клавиши «Стрелка вверх», просмотрев запись для этой клавиши с кодом keys[pygame.K_UP] . Если клавиша нажата, она будет иметь значение True ; если не нажимать, его значение будет False .

Давайте добавим код в наш игровой цикл, чтобы проверить, нажаты ли клавиши со стрелками «Вверх», «Вниз», «Влево» или «Вправо». Затем, в зависимости от нажатой клавиши, мы можем вызвать нашу метод рулевого управления с обновленной командой направления. Добавьте следующий код над строкой snake.move() в игровом цикле в файле main.py : .steer(Direction.LEFT)
клавиш elif[pygame.K_RIGHT]:
змейка.steer(Direction.RIGHT)
клавиш elif[pygame.K_UP]:
змея.steer(Direction.UP)
клавиш elif[pygame.K_DOWN ]:
змея.управлять(Направление.ВНИЗ)

Давайте проверим это. Нажмите кнопку « Run > » в верхней центральной части repl. Чтобы Pygame получал ввод с клавиатуры, вам нужно сначала быстро щелкнуть в окне игры, когда игра запускается. Теперь вы сможете использовать клавиши управления курсором, чтобы управлять змеей по экрану! У нас пока нет проверки границ, поэтому змея может исчезнуть за краем окна.

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

Мы создадим еду так же, как создали змею. Создайте новый файл с именем food.py . В этом файле мы создадим класс Food для управления положением и отрисовкой еды на сетке.

В игре «Змейка» после того, как пищевой блок съеден, в случайном месте сетки появляется еще один. Это означает, что нам понадобится генератор случайных чисел, чтобы определить местонахождение еды. В Python для этого есть модуль random . У этого есть функция под названием randint , который мы можем использовать, чтобы найти случайную позицию на экране для размещения еды. Начнем с добавления ссылки на модуль random в файл food. py . Затем мы добавим класс Food .

 случайный импорт 
 класс Еда: 
 block_size = None 
 color = (0,255,0) 
 x = 0; 
 г = 0; 
 bounds = None 
 
 def __init__(self, block_size, bounds): 
 self.block_size = block_size 
 self.bounds = bounds 
 
 def draw(self, game, window): 
 game.draw.rect(window, self.color, (self.x, self.y, self.block_size, self.block_size)) 
 
 def respawn(self): 
 blocks_in_x = (self.bounds[0])/self.block_size; 
 blocks_in_y = (self.bounds[1])/self.block_size; 
 self.x = random.randint(0, blocks_in_x - 1) * self.block_size 
 self.y = random.randint(0, blocks_in_y - 1) * self.block_size 
 
 

Обратите внимание на сходство с Snake сорт. У обоих метод рисования и метод возрождения . Как правило, в играх большинство объектов имеют эту функциональность.

Класс Food также имеет сходные свойства с классом Snake. Он имеет block_size , что означает размер каждого блока в нашей виртуальной сетке. У него есть кортеж цвета , который мы будем использовать при рисовании еды. Он также имеет запись о границах окна, чтобы мы не рисовали еду за пределами видимого окна. Однако, поскольку еда состоит только из 1 блока, нам не нужны 9 блоков.Массив 0331 body похож на класс змеи. Мы можем отслеживать его положение с помощью координатных переменных x и y.

Метод draw представляет собой упрощенную версию метода в классе змей. Это потому, что нам нужно нарисовать только 1 блок.

Метод возрождения интересен. Нам нужно выровнять нашу еду с нашей виртуальной сеткой, определяемой block_size . Однако, если мы просто вызовем random.randint , чтобы найти положение еды по осям x и y, она может оказаться на полпути через блок в сетке. Это сделает странным пытаться прицелиться змеей, так как змея не будет выровнена с едой.

Чтобы все было выровнено, нам нужно взять нашу информацию о размере окна, инкапсулированную в нашем свойстве bounds , и наши знания о block_size нашей сетки, чтобы вычислить размер окна с точки зрения блоки. Так, например, если размер нашего окна или границ составляет 300×300 пикселей, а размер блока равен 20 пикселей, то в каждом измерении 300 пикселей/20 пикселей = 15 блоков. Затем мы можем выбрать случайную позицию с точки зрения размеров блока, то есть выбрать число от 1 до 15, в которое поместить еду. Чтобы получить фактические экранные координаты x и y для рисования блока, мы можем просто умножить номер нашего блока на 9.0331 размер_блока .

В первых 2 строках метода respawn находим количество блоков в каждом измерении, как описано выше. Затем следующие 2 строки находят случайный блок и переводят этот блок в координаты x и y. Вы можете заметить, что вместо того, чтобы найти случайное число между 1 и количеством блоков в измерении, мы находим число между 0 и количеством блоков минус 1. Это связано с тем, что окна x и y начинаются с 0, а не с 1, поэтому нам нужно сдвинуть диапазон на 1, чтобы компенсировать.

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

Сначала нам нужно добавить ссылку на файл food.py и импортировать класс Food . В файле main.py сразу после строки import pygame добавьте следующее:

 from food import Food 
 

В файле main.py после строки границ) , и непосредственно перед игровым циклом создайте новый Food объект, добавив строку:

 food = Food(block_size,bounds) 
 

В игровом цикле в main.py , сразу после строки snake.draw(pygame, window) , мы можем добавить линию, чтобы нарисовать еду. Добавьте следующую строку:

 food.draw(pygame, window) 
 

Отлично! Давайте проверим до этого момента, снова нажав кнопку « Run > ». Теперь вы должны увидеть змею, а также зеленый блок, представляющий еду.

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

Мы возложим ответственность за проверку столкновений на класс Snake . В snap.py , добавьте следующие два метода в класс Snake :

 def eat(self): 
 self.length += 1 
 # проверяет, находится ли голова змеи над едой 
 def check_for_food (self, food): 
 head = self.body[-1] 
 if head[0] == food.x and head[1] == food.y: 
 self.eat() 
 food.respawn() 
 
 

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

Затем у нас есть метод check_for_food . Это принимает объект food в качестве аргумента. В этой функции мы получаем самый передний блок змеи, или голову , обращаясь к последнему элементу в списке тело . Напомним, что мы можем использовать отрицательный индекс для доступа к последнему элементу. Затем, поскольку мы используем строгую систему сетки для нашей игровой схемы, нам нужно только проверить, равны ли координаты x и y головы змеи координатам x и y объекта еды. Если они есть, мы вызываем есть метод увеличения длины змеи. Мы также вызываем respawn на еде, чтобы она исчезла из своего текущего местоположения и снова появилась в другом месте.

В игровом цикле в файле main.py добавьте следующий код сразу после строки snake. move() :

 змея. метод обнаружения столкновений в каждом цикле игры сразу после того, как змея переместилась в новый блок. 
 
 Мы можем проверить это еще раз и посмотреть, растет ли теперь наша змея, когда мы едим немного еды. Нажмите кнопку « Run > » еще раз для проверки. 
 
 
 
 Теперь нам нужно добавить обнаружение столкновений, если змея пересекает саму себя. Это смертельный прием и один из способов достичь «Game Over» в Snake. Аналогично проверке, съела ли змея пищу, мы можем добавить метод к классу  Snake  в файле  snake.py , чтобы проверить, пересекла ли змея или укусила себя: 
 
 def check_tail_collision(self): 
 head = self.body[-1] 
 has_eaten_tail = False 
 for i in range(len(self.body) - 1): 
 segment = self.body[i] 
 if head [0] == segment[0] and head[1] == segment[1]: 
 has_eaten_tail = True 
 
 return has_eaten_tail 
 
 
 Этот метод получает  голову  змеи, как и раньше в нашем  check_for_food Метод . Затем мы устанавливаем переменную флага, чтобы определить, съела ли змея свой хвост, и инициализируем ее значением 9.0331 Ложь  .
 Следующая часть метода проходит через все сегменты, составляющие тело   змеи, за исключением последнего элемента списка  тела , так как этот элемент представляет голову змеи. Затем мы проверяем координаты x и y головы   и текущего сегмента. Если они совпадают, это означает, что голова змеи находится над сегментом тела, поэтому мы можем установить для нашего флага  has_eaten_tail  значение true.
 После проверки всех сегментов мы возвращаем значение  флаг has_eaten_tail .
 Последнее обнаружение, которое нам нужно добавить, — это перемещение змеи за пределы окна. Для этого мы можем добавить в класс  Snake  следующий метод:
 def check_bounds(self): 
 head = self.body[-1] 
 if head[0] >= self.bounds[0]: 
 вернуть True 
, если head[1] >= self. bounds[1]: 
 вернуть True 
, если head[0] < 0: 
 вернуть True 
, если head[1] < 0: 
 вернуть True 
 
 вернуть False 
 
 
 Этот код еще раз извлекает блок  head  змеи из конца списка  body . Затем он сверяет каждое измерение с границами окна. Если он выходит за пределы любой из этих границ, метод возвращает  True  . Если голова змеи все еще находится в пределах границ, возвращается  False  .
 Теперь, когда мы можем обнаруживать коллизии в конце игры, мы можем добавить код в игровой цикл для вызова этих методов и обработки конца игры. Когда игра заканчивается, мы должны показать игроку сообщение «Игра окончена» на секунду или две. Затем мы можем сбросить змею и еду, чтобы дать игроку еще один шанс.
 Чтобы добавить сообщение «Игра окончена», мы можем использовать модуль шрифта pygame. Основные шаги использования шрифта для вывода текста на экран:
 Создайте новый объект шрифта, указав тип шрифта, размер и параметры  жирный  /  курсив , используя метод конструктора  font. SysFont  .
 Отобразите желаемый текст на поверхности, используя метод  render  для объекта шрифта, созданного выше.
  blit  отображаемый текст на поверхность главного окна.
 Обновите отображение окна, чтобы показать это.
 Чтобы реализовать описанные выше действия, создайте новый объект  font , добавив следующий код в строку  food = Food(block_size,bounds)  в файле  main.py :
 font = pygame.font .SysFont('comicsans',60, True) 
 
 В игровом цикле нам нужно вызвать методы проверки столкновений, которые мы ранее добавили в класс змеи. Если обнаружено столкновение, мы можем отобразить наше сообщение «Игра окончена», приостановить и перезапустить игру. Добавьте следующий код под строку  snake.check_for_food(food)  в игровом цикле в файле  main.py :
 
 if змейка.check_bounds() == True или змейка.check_tail_collision() == True: 
 text = font.