Читатели като вас помагат в подкрепа на MUO. Когато правите покупка чрез връзки на нашия сайт, ние може да спечелим комисионна за партньор. Прочетете още.

Pygame предоставя няколко вградени функции за откриване на сблъсъци между игрови обекти. Те са безценни, защото определянето кога точно и как се припокриват движещи се обекти може да бъде сложна задача.

Научете как да добавяте основна физика и сблъсъци във вашата игра с помощта на модула pygame.

Вградените функции на Pygame за откриване на сблъсък

Най-основната вградена функция за откриване на сблъсък е spritecollide. Той приема спрайт, група спрайтове и булева стойност, показваща дали спрайтовете трябва да "умрат" (да бъдат премахнати), когато се сблъскат. Тази функция връща списък със спрайтове, които са се сблъскали. Ето пример как да го използвате:

collided_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, Вярно)

Друга полезна функция за откриване на сблъсъци е groupcollide, която приема две групи спрайтове и също така булева стойност. Тази функция връща речник със сблъсканите спрайтове като ключове и спрайтовете, с които са се сблъскали като стойности. Ето пример как да го използвате:

instagram viewer 

collision_dict = pygame.sprite.groupcollide (група1, група2, Вярно, Вярно)

Създаване на базова платформинг игра с помощта на функцията spritecollide

За да създадете основна игра на платформинг с помощта на Pygame, ще трябва да създадете спрайт на играч, който потребителят може да контролира, и спрайт на платформа, на който играчът да стои. Можете да използвате функцията spritecollide, за да откриете, когато спрайтът на играча се сблъска със спрайта на платформата и да предотвратите падането на играча през платформата.

Да започна, инсталирайте модула pygame с помощта на pip:

pip инсталирайте pygame

След това, създавайте прости класове за плейъра и платформата, като и двата трябва да наследят от класа Sprite на Pygame. Класът Player трябва да има метод за актуализиране, за да управлява позицията на играча въз основа на скоростта. Освен това трябва да има променлива y_velocity, за да приложи ефекта на гравитацията. Класът Platform трябва да има метод __init__, който взема координатите на платформата и създава повърхност с този размер.

Клас играч

Можете да създадете клас Player с помощта на pygame.sprite. Спрайт модул. Този клас ще инициализира играча с дадени x и y координати. След това методът за актуализиране ще актуализира позицията на играча чрез увеличаване на стойността на y_velocity.

импортиране pygame
класИграч(pygame.sprite. спрайт):
деф__в него__(себе си, x, y):
 супер().__init__()
 self.image = pygame. Повърхност((32, 32))
 self.rect = self.image.get_rect (горе вляво=(x, y))
 self.y_velocity = 0
дефактуализация(себе си):
 self.rect.y += self.y_скорост

Клас платформа

Класът Platform също използва pygame.sprite. Спрайт модул. Този клас ще инициализира платформата с дадени координати x и y, както и ширина и височина.

класПлатформа(pygame.sprite. спрайт):
деф__в него__(сам, x, y, ширина, височина):
 супер().__init__()
 self.image = pygame. Повърхност ((ширина, височина))
 self.rect = self.image.get_rect (горе вляво=(x, y))

The Game Loop

Цикълът на играта ще ви позволи да създадете прозорец с размер 640x480. След това ще изпълни цикъл, който ще провери за всякакви събития, като например команда за излизане. Той също така ще провери за сблъсъци между играча и платформата. Накрая ще запълни екрана с бял цвят, ще нарисува играча и платформата и след това ще обърне дисплея.

играч = играч(100, 300)
играч_група = pygame.sprite. Група()
player_group.add (играч)
платформа = Платформа(50, 400, 100, 20)
platform_group = pygame.sprite. Група()
platform_group.add (платформа)


# Инициализирайте pygame и създайте прозорец
pygame.init()
екран = pygame.display.set_mode((640, 480))


# Основен цикъл на играта
бягане = Вярно


докато работи:
за събитие в pygame.event.get():
ако event.type == pygame. ИЗХОД:
 бягане = Невярно

 player_group.update()
 collided = pygame.sprite.spritecollide (играч, platform_group, Невярно)


ако сблъскаха се:
 player.y_velocity = 0
 screen.fill((255, 255, 255))
 player_group.draw (екран)
 platform_group.draw (екран)
 pygame.display.flip()
pygame.quit()

По-долу е резултатът:

Внедряване на гравитация и поведение при скачане

За да приложите поведение на гравитация и скачане във вашата платформинг игра, ще трябва да добавите y скорост към спрайта на вашия играч и да актуализирате неговата y позиция във всеки кадър. За да направите това, можете да използвате метода за актуализиране в класа Player и да добавите следния кодов фрагмент:

класИграч(pygame.sprite. спрайт):
деф__в него__(себе си, x, y):
 супер().__init__()
 self.image = pygame. Повърхност((32, 32))
 self.rect = self.image.get_rect (горе вляво=(x, y))
 self.y_velocity = 0
дефактуализация(себе си):
 self.rect.y += self.y_скорост
 self.y_velocity += ГРАВИТАЦИЯ # Приложете гравитацията към скоростта y

Сега всеки път, когато извикате метода за актуализиране, той ще актуализира позицията на играча според неговата скорост и гравитация.

За да накарате спрайта на играча да скочи, можете да свържете действието за скачане към конкретен клавиш или бутон и да актуализирате y скоростта на играча с отрицателна стойност. Следният кодов фрагмент е пример за това как да скочите, когато играч натисне клавиша за интервал.

JUMP_VELOCITY = -10
# вътре в цикъла на играта
ако event.type == pygame. KEYDOWN и event.key == pygame. K_SPACE:
 player.y_velocity = JUMP_VELOCITY

Имайте предвид, че ще трябва да проверите event.type, за да се уверите, че събитието е събитие KEYDOWN, преди да проверите стойността на ключа.

Добавяне на основна физика като триене и ускорение

За да добавите основна физика като триене и ускорение към вашата платформинг игра, ще трябва да актуализирате x скоростта на вашия спрайт на играча във всеки кадър. Можете да добавите x velocity към класа на играча и да го актуализирате по същия начин като y velocity. За да приложите триене, можете да намалите скоростта x на спрайта на играча с малко във всеки кадър. Например, можете да добавите следния кодов фрагмент в метода за актуализиране на класа Player:

ТРИЕНЕ = 0.9
класИграч(pygame.sprite. спрайт):
деф__в него__(себе си, x, y):
 супер().__init__()
 self.image = pygame. Повърхност((32, 32))
 self.rect = self.image.get_rect (горе вляво=(x, y))
 self.y_velocity = 0
 self.x_velocity = 0
дефактуализация(себе си):
 self.rect.y += self.y_скорост
 self.rect.x += self.x_velocity
 self.y_velocity += ГРАВИТАЦИЯ # Приложете гравитацията към скоростта y
 self.x_velocity *= ТРИЕНИЕ # Приложете триене към скоростта x

За да приложите ускорение, можете да зададете променлива, player_movement, за хоризонталното движение и да актуализирате скоростта x на спрайта на играча според стойността на player_movement. Можете да направите това, като обвържете движението с конкретни клавиши или бутони и актуализирате x скоростта на играча в цикъла на събитията, например:

УСКОРЕНИЕ = 0.5
играч_движение = 0
ако event.type == pygame. KEYDOWN:
ако event.key == pygame. K_НАЛЯВО:
 играч_движение = -1
елиф event.key == pygame. K_RIGHT:
 играч_движение = 1
елиф event.type == pygame. KEYUP:
ако събитие.ключ в (pygame. K_LEFT, pygame. K_RIGHT):
 играч_движение = 0

player.x_velocity += player_movement * АКСЕЛЕРАЦИЯ

Използвайки тези техники, можете да създадете проста, но забавна платформинг игра, като използвате вградените функции за откриване на сблъсък на Pygame и основна физика. С малко креативност и експериментиране можете да използвате тези техники, за да създадете разнообразие от различни игри и игрови механики.

Можете да намерите пълния код в GitHub хранилище.

По-долу е резултатът:

Подобрете ангажираността на потребителите със сблъсъци

Много игри изискват някаква форма на откриване на сблъсък. Можете да използвате сблъсъци, за да създадете широка гама от игрови механики, от прости платформинги до сложни базирани на физика симулации.

Прилагането на основна физика като гравитация, триене и ускорение също може значително да подобри ангажираността на потребителите, добавяйки реализъм и усещане за тежест към обектите в играта.