Próbuję więc wdrożyć wykrywanie kolizji w małej grze Pygame, które robię. Jednak mój kod nie działa dobrze. Albo prawdopodobnie nie wiem, jak go wdrożyć. W tej grze muszę uzyskać player do princess bez biegania do goblin. Wszystko działa w prawo, ale nie mogę wydawać się wdrażania wykrywania kolizji między player i goblin. Idealnie, chciałbym wrócić do pozycji wyjściowej, jeśli trafi do goblin. Możesz zobaczyć, że mam funkcję isCollision, ale kiedy próbuję go zadzwonić, dostaję "Nazwa: Nazwa" PlayerX "nie jest zdefiniowany"

import pygame
import math

# Initialize the pygame
pygame.init()

# Setting up the screen and background
screen = pygame.display.set_mode((800,600))

# Title and Icon of window
pygame.display.set_caption("Get Princess")

icon = pygame.image.load('knight.png')
pygame.display.set_icon(icon)


#Princess Image
princessImg = pygame.image.load('princess.png')
princessImg = pygame.transform.scale(princessImg, (50,50))
princessX = 360
princessY = 20
princessX_change = 0
princessY_change = 0


class player():
    def __init__(self, playerX, playerY, playerX_change, playerY_change):
        self.playerX = playerX
        self.playerY = playerY
        self.playerX_change = playerX_change
        self.playerY_change = playerY
        self.playerImg = pygame.image.load('knight.png')
        self.playerImg = pygame.transform.scale(self.playerImg, (50,50))
        self.rect = pygame.Rect(32,32,16,16)
        

    def pdraw(self):
        screen.blit(self.playerImg, (self.playerX, self.playerY))
            

    def pmovement(self):
        self.playerX += self.playerX_change
        self.playerY += self.playerY_change
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP:
                self.playerY_change = -0.4
            if event.key == pygame.K_DOWN:
                self.playerY_change = 0.4
            if event.key == pygame.K_LEFT:
                self.playerX_change = -0.4
            if event.key == pygame.K_RIGHT:
                self.playerX_change = 0.4
        if event.type == pygame.KEYUP:
            if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                self.playerX_change = 0
            elif event.key == pygame.K_UP or event.key == pygame.K_DOWN:
                self.playerY_change = 0

        if self.playerX <= 0:
            self.playerX = 0
        elif self.playerX >= 750:
            self.playerX = 750
        if self.playerY <= 0:
            self.playerY = 0
        elif self.playerY >= 550:
            self.playerY = 550


class goblin():
    def __init__(self, goblinX, goblinY, goblinX_change):
        self.goblinX = goblinX
        self.goblinY = goblinY
        self.goblinX_change = goblinX_change
        self.goblinImg = pygame.image.load('goblin.png')
        self.goblinImg = pygame.transform.scale(self.goblinImg,(50,50))
    
    def draw(self):
        screen.blit(self.goblinImg, (self.goblinX, self.goblinY))
        
    
    def movement(self):
        self.goblinX += self.goblinX_change
        if self.goblinX <= 0 or self.goblinX >= 750:
            self.goblinX_change = self.goblinX_change * -1


def princess(x,y):
    screen.blit(princessImg, (x, y))

p = player(360, 520, 0, 0)
g = goblin(360,250, 0.10)
g1 = goblin(360, 280, 0.5)
g2 = goblin(360, 200, 0.7)
g3 = goblin(360, 160, 0.4)
goblinlist = [g, g1, g2, g3]

def isCollision(playerX, playerY, goblinX, goblinY):
    dx = playerX - goblinY
    dy = playerY - goblinY
    distance = math.sqrt(math.pow(dx,2) + math.pow(dy,2))
    if distance < 27:
        p = player(360, 520, 0,0)


running = True
while running:

    screen.fill((50,0,0))

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
                    
    princess(princessX, princessY)
    
    g.movement()
    g.draw()
    
    g1.movement()
    g1.draw()

    g2.movement()
    g2.draw()

    g3.movement()
    g3.draw()

    p.pmovement()
    p.pdraw()

    isCollision(p.playerX, p.playerY, g1.goblinX, g1.goblinY)
    
    pygame.display.update()
1
NickA 16 październik 2020, 20:44

1 odpowiedź

Najlepsza odpowiedź

isCollision jest funkcją i playerX, playerY, goblinX, goblinY są argumentami funkcji. Nie masz argumentu self. Zwykle self jest obiektem w Metody.
.. Usuń wszystkie self. Formularz funkcji isCollision:

def isCollision(playerX, playerY, goblinX, goblinY):
    dx = playerX - goblinX
    dy = playerY - goblinY
    distance = math.sqrt(math.pow(dx, 2) + math.pow(dy, 2))
    return distance < 27

Podaj współrzędne odtwarzacza (p) i goblin (g, g1, g2 lub g3) do funkcji:

Na przykład:

if isCollision(p.playerX, p.playerY, g.goblinX, g.goblinY):
    #  do something
    # [...]  

Uwaga, możesz utworzyć listę goblinów i wykonać test kolizji w pętli:

goblin_list = [g, g1, g2, g3]
for gob in goblin_list: 
    if isCollision(p.playerX, p.playerY, gob.goblinX, gob.goblinY):
        # [...] 

Możesz nawet poruszać się i narysować gobliny w pętli:

for gob in goblin_list:
    gob.movement()
    gob.draw()

Musisz użyć {{x0 }} Oświadczenie, jeśli chcesz zmienić zmienną w globalnej przestrzeni nazw:

def isCollision(playerX, playerY, goblinX, goblinY):

    global p

    dx = playerX - goblinX
    dy = playerY - goblinY
    distance = math.sqrt(math.pow(dx, 2) + math.pow(dy,2))
    if distance < 27:
        p = player(360, 520, 0,0)
1
Rabbid76 19 październik 2020, 15:39