Home-theater-designers
Pygame ofereix diverses funcions integrades per detectar col·lisions entre objectes del joc. Són inestimables perquè esbrinar exactament quan i com es superposen els objectes en moviment pot ser una tasca complicada.
Apreneu a afegir la física bàsica i les col·lisions al vostre joc mitjançant el mòdul pygame.
Funcions de detecció de col·lisions integrades de Pygame
La funció de detecció de col·lisions integrada més bàsica és spritecollide. Admet un sprite, un grup de sprites i un valor booleà que indica si els sprites haurien de 'morir' o no (ser eliminats) quan xoquen. Aquesta funció retorna una llista dels sprites que han xocat. Aquí teniu un exemple de com utilitzar-lo:
collided_sprites = pygame.sprite.spritecollide(sprite1, sprite_group, True)Una altra funció útil de detecció de col·lisions és groupcollide, que inclou dos grups de sprites i també un valor booleà. Aquesta funció retorna un diccionari amb els sprites xocats com a claus i els sprites amb els quals xoquen com a valors. Aquí teniu un exemple de com utilitzar-lo:
no pot accedir a uefi bios windows 10
collision_dict = pygame.sprite.groupcollide(group1, group2, True, True)Creació d'un joc bàsic de plataformes utilitzant la funció spritecollide
Per crear un joc de plataformes bàsic amb Pygame, haureu de crear un sprite de jugador que l'usuari pugui controlar i un sprite de plataforma per al jugador. Podeu utilitzar la funció spritecollide per detectar quan el sprite del jugador xoca amb el sprite de la plataforma i evitar que el jugador caigui per la plataforma.
Començar, instal·leu el mòdul pygame amb pip :
pip install pygameDesprés d'això, crear classes senzilles per al jugador i la plataforma, tots dos haurien d'heretar de la classe Sprite de Pygame. La classe Player hauria de tenir un mètode d'actualització per gestionar la posició del jugador en funció de la velocitat. A més, hauria de tenir una variable y_velocity per aplicar l'efecte de la gravetat. La classe Platform hauria de tenir un mètode __init__ que prengui les coordenades de la plataforma i creï una superfície amb aquesta mida.
Classe de jugadors
Podeu crear una classe de jugador mitjançant el mòdul pygame.sprite.Sprite. Aquesta classe inicialitzarà el jugador amb unes coordenades x i y donades. Aleshores, el mètode d'actualització actualitzarà la posició del reproductor augmentant el valor y_velocity.
import pygame
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocityClasse de plataforma
La classe Platform també utilitza el mòdul pygame.sprite.Sprite. Aquesta classe inicialitzarà la plataforma amb les coordenades x i y donades, així com una amplada i una alçada.
class Platform(pygame.sprite.Sprite):
def __init__(self, x, y, width, height):
super().__init__()
self.image = pygame.Surface((width, height))
self.rect = self.image.get_rect(topleft=(x, y))El bucle de joc
El bucle del joc us permetrà crear una finestra amb una mida de 640x480. Aleshores, executarà un bucle que comprovarà si hi ha esdeveniments, com ara una ordre de sortida. També comprovarà si hi ha col·lisions entre el jugador i la plataforma. Finalment, omplirà la pantalla amb un color blanc, dibuixarà el reproductor i la plataforma, i després girarà la pantalla.
player = Player(100, 300)
player_group = pygame.sprite.Group()
player_group.add(player)
platform = Platform(50, 400, 100, 20)
platform_group = pygame.sprite.Group()
platform_group.add(platform)
# Initialize pygame and create window
pygame.init()
screen = pygame.display.set_mode((640, 480))
# Main game loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
player_group.update()
collided = pygame.sprite.spritecollide(player, platform_group, False)
if collided:
player.y_velocity = 0
screen.fill((255, 255, 255))
player_group.draw(screen)
platform_group.draw(screen)
pygame.display.flip()
pygame.quit()A continuació es mostra la sortida:
Implementació de la gravetat i el comportament de salt
Per implementar la gravetat i el comportament de salt al vostre joc de plataformes, haureu d'afegir una velocitat y al vostre sprite del jugador i actualitzar-ne la posició y a cada fotograma. Per fer-ho, podeu utilitzar el mètode d'actualització dins de la classe Player i afegir el següent fragment de codi:
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocityAra, cada vegada que truqueu al mètode d'actualització, actualitzarà la posició del jugador segons la seva velocitat i gravetat.
Per fer saltar el sprite del jugador, podeu vincular l'acció de salt a una tecla o botó específic i actualitzar la velocitat y del jugador amb un valor negatiu. El següent fragment de codi és un exemple de com saltar quan un jugador prem la barra espaiadora.
JUMP_VELOCITY = -10
# inside the game loop
if event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
player.y_velocity = JUMP_VELOCITYTingueu en compte que haureu de comprovar event.type per assegurar-vos que l'esdeveniment és un esdeveniment KEYDOWN abans de comprovar el valor de la clau.
Afegint física bàsica com ara la fricció i l'acceleració
Per afegir la física bàsica com ara la fricció i l'acceleració al vostre joc de plataformes, haureu d'actualitzar la velocitat x del vostre sprite del jugador a cada fotograma. Podeu afegir la velocitat x a la classe de reproductor i actualitzar-la de la mateixa manera que la velocitat y. Per implementar la fricció, podeu reduir la velocitat x del sprite del jugador en una petita quantitat a cada fotograma. Per exemple, podeu afegir el fragment de codi següent dins del mètode d'actualització de la classe Player:
com moure l'aplicació a la targeta sd
FRICTION = 0.9
class Player(pygame.sprite.Sprite):
def __init__(self, x, y):
super().__init__()
self.image = pygame.Surface((32, 32))
self.rect = self.image.get_rect(topleft=(x, y))
self.y_velocity = 0
self.x_velocity = 0
def update(self):
self.rect.y += self.y_velocity
self.rect.x += self.x_velocity
self.y_velocity += GRAVITY # Apply gravity to y velocity
self.x_velocity *= FRICTION # Apply friction to x velocityPer implementar l'acceleració, podeu establir una variable, player_movement, per al moviment horitzontal i actualitzar la velocitat x del sprite del jugador segons el valor player_movement. Podeu fer-ho lligant el moviment a tecles o botons específics i actualitzant la velocitat x del jugador al bucle d'esdeveniments, per exemple:
ACCELERATION = 0.5
player_movement = 0
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
player_movement = -1
elif event.key == pygame.K_RIGHT:
player_movement = 1
elif event.type == pygame.KEYUP:
if event.key in (pygame.K_LEFT, pygame.K_RIGHT):
player_movement = 0
player.x_velocity += player_movement * ACCELERATIONMitjançant aquestes tècniques, podeu crear un joc de plataformes senzill però divertit mitjançant les funcions de detecció de col·lisions integrades i la física bàsica de Pygame. Amb una mica de creativitat i experimentació, podeu utilitzar aquestes tècniques per crear una varietat de jocs i mecàniques de joc diferents.
Podeu trobar el codi complet a la pàgina Repositori GitHub .
A continuació es mostra la sortida:
Millorar la implicació dels usuaris amb les col·lisions
Molts jocs requereixen algun tipus de detecció de col·lisions. Podeu utilitzar les col·lisions per crear una àmplia gamma de mecàniques de joc, des de simples jocs de plataformes fins a simulacions complexes basades en la física.
La implementació de la física bàsica com la gravetat, la fricció i l'acceleració també pot millorar molt la implicació de l'usuari, afegint realisme i sensació de pes als objectes del joc.