Wie kann ich Pygame prüfen lassen, wenn zwei Bilder kollidieren?

Question

Ich habe alles versucht und kann nicht bekommen, wie ich überprüfe, ob meine zwei Blöcke kollidiert sind.

Hier ist mein Code:

import pygame 
import random 
pygame.init() 

display_width = 600 
display_height = 300 

class player:#Just info for player 
    width = 30 
    height = 30 
    x = display_width // 2 
    y = display_height - height - 5 
    a = x + 30 
    pic = 'SnakePart.png' 
    thing = pygame.image.load(pic) 
    def place(x,y):#function for placing player object 
     gameDisplay.blit(player.thing, (player.x,player.y)) 
class enemy:#enemy info class 
    width = 30 
    height = 30 
    x = random.randint(0,display_width - width) 
    y = 1 
    a = x + 30 
    pic = 'Apple.png' 
    thing = pygame.image.load(pic) 
    speed = 10#sets speed 
    def change_x(): 
     enemy.x = random.randint(0,display_width - enemy.width) 
    def change_y(): 
     enemy.y += enemy.speed 
    def make(x,y):#set up funtion 
     gameDisplay.blit(enemy.thing, (x,y)) 
    def respawn():#reseting enemy entity 
     enemy.y = 1 
     gameDisplay.blit(enemy.thing, (enemy.x,enemy.y)) 
player.thing#uses the variables in the classes to set up the images for use 
enemy.thing 

black = (0,0,0) 
white = (255,255,255) 


player_height = 30 
player_width = 30 

clock = pygame.time.Clock() 

x_change = 0#This is to make movment 

gameDisplay = pygame.display.set_mode((display_width,display_height)) 
pygame.display.set_caption('Bullet Hell.') 

dodged = 0#counter will be used in the more polished vesion. 

while True: 
    for event in pygame.event.get(): 
     if event.type == pygame.QUIT: 
      pygame.quit() 
      quit() 
     if event.type == pygame.KEYDOWN:#Checks for keypress, to make player entity move 
      if event.key == pygame.K_RIGHT: 
       x_change = 5 
      if event.key == pygame.K_LEFT: 
       x_change = -5 
     if event.type == pygame.KEYUP: 
      if event.key == pygame.K_RIGHT or pygame.K_LEFT: 
       x_change = 0 

    player.x += x_change 
    gameDisplay.fill(black) 
    enemy.make(enemy.x,enemy.y) 
    player.place(player.x,player.y) 
    enemy.change_y() 
    if enemy.y > display_height:#Brings enemy back to top once it has gotten to th bottom 
     enemy.change_x() 
     dodged += 1 
     enemy.respawn() 
    pygame.display.update() 
    clock.tick(60) 

Es ist alles wirklich die Kollision und ich glaube, ich gut sein werde. Oh ja, wenn ihr mir auch sagen könnt, wie man Text zeigt, der großartig wäre!

Answer 1

Werfen Sie einen Blick auf die pygame.Rect Klasse und ihre Kollisionserkennungsmethoden. Vergeben Sie Ihre Objekte als Attribute, die Sie erhalten, indem Sie die Methode .get_rect() der Bilder/Flächen aufrufen. Aktualisieren Sie die Koordinaten dieser Objekte in jedem Frame und rufen Sie in Ihrer Hauptschleife player.rect.colliderect(enemy.rect) auf, um zu prüfen, ob die beiden Objekte kollidieren.

import pygame 
import random 


pygame.init() 

BLACK = pygame.Color('black') 

display = pygame.display.set_mode((600, 300)) 
# Create a rect with the dimensions of the screen at coords (0, 0). 
display_rect = display.get_rect() 
clock = pygame.time.Clock() 

# SNAKE_IMAGE = pygame.image.load('SnakePart.png').convert_alpha() 
# APPLE_IMAGE = pygame.image.load('Apple.png').convert_alpha() 
# Replacement images. 
SNAKE_IMAGE = pygame.Surface((30, 30)) 
SNAKE_IMAGE.fill((30, 150, 0)) 
APPLE_IMAGE = pygame.Surface((30, 30)) 
APPLE_IMAGE.fill((150, 30, 0)) 


class Player: 

    def __init__(self): 
     self.x = display_rect.w // 2 
     self.y = display_rect.h - 30 - 5 
     self.image = SNAKE_IMAGE 
     # Create a rect with the size of the image at coords (0, 0). 
     self.rect = self.image.get_rect() 
     # Set the topleft coords of the rect. 
     self.rect.x = self.x 
     self.rect.y = self.y 
     self.x_change = 0 

    def update(self): 
     """Move the player.""" 
     self.x += self.x_change 
     # Always update the rect, because it's 
     # needed for the collision detection. 
     self.rect.x = self.x 

    def draw(self, display): 
     display.blit(self.image, self.rect) 


class Enemy: 

    def __init__(self): 
     self.x = random.randint(0, display_rect.w - 30) 
     self.y = 1 
     self.image = APPLE_IMAGE 
     # You can also pass the coords directly to `get_rect`. 
     self.rect = self.image.get_rect(topleft=(self.x, self.y)) 
     self.speed = 10 

    def change_x(self): 
     self.x = random.randint(0, display_rect.w - self.rect.w) 
     self.rect.x = self.x 

    def change_y(self): 
     self.y += self.speed 
     self.rect.y = self.y 

    def draw(self, display): 
     display.blit(self.image, self.rect) 

    def reset(self): 
     """Reset self.y position.""" 
     self.y = -30 


player = Player() 
enemy = Enemy() 
dodged = 0 
done = False 

while not done: 
    for event in pygame.event.get(): 
     if event.type == pygame.QUIT: 
      done = True 
     if event.type == pygame.KEYDOWN: 
      if event.key == pygame.K_RIGHT: 
       player.x_change = 5 
      if event.key == pygame.K_LEFT: 
       player.x_change = -5 
     if event.type == pygame.KEYUP: 
      if event.key == pygame.K_RIGHT or pygame.K_LEFT: 
       player.x_change = 0 

    # Game logic. 
    player.update() 
    enemy.change_y() 
    # Brings enemy back to top once it has gotten to th bottom 
    if enemy.y > display_rect.h: 
     enemy.change_x() 
     dodged += 1 
     enemy.reset() 

    # Check if the player and the rect collide. 
    if player.rect.colliderect(enemy.rect): 
     print('Collided!') 

    # Draw everything. 
    display.fill(BLACK) 
    enemy.draw(display) 
    player.draw(display) 

    pygame.display.update() 
    clock.tick(60) 

pygame.quit() 

Ich habe ein paar mehr Dinge geändert (btw, besser self.image nicht thing die Bilder nennen;)) vor allem in den Klassen:

Die Attribute der Klassen in __init__ Methoden sein sollten, sie Instanz zu machen Attribute anstelle von Klassenattributen (die von allen Instanzen geteilt werden). Überprüfen Sie außerdem, wie Instanzen Ihrer Klassen erstellt werden.

Die Methoden sollten alle self als ihren ersten Parameter haben (das ist ein Verweis auf die Instanz). Um auf die Attribute innerhalb der Klassen zuzugreifen, werden sie mit self, z.B. self.x += self.x_change.

Die player.x += x_change Linie paßt besser in der Player Klasse update Methode, so dass Sie nur die Position aktualisieren und andere Spieler-Attribute von player.update() aufrufen.

Es gibt eine Konvention, dass Klassennamen Großbuchstaben MyClass sein sollten, während Instanzen Kleinbuchstaben Namen my_instance haben sollten.