Wie implementiert man einen Abkühlmechanismus, um übermäßiges Abfeuern von Kugeln zu verhindern?

So verhindern Sie, dass mehrere Kugeln gleichzeitig abgefeuert werden

Im ursprünglichen Code wurden mehrere Kugeln gleichzeitig abgefeuert, da das Pygame Die Funktion .key.get_pressed() gibt „True“ zurück, solange eine Taste gedrückt wird. Dieses Verhalten eignet sich zur Steuerung der Spielerbewegung, jedoch nicht zum Abfeuern von Kugeln, bei denen bei jedem Tastendruck nur eine Kugel abgefeuert werden soll.

Um dieses Problem zu beheben, können wir pygame.KEYDOWN nutzen Ereignis, das nur einmal auftritt, wenn eine Taste zum ersten Mal gedrückt wird. Durch die Verwendung dieses Ereignisses anstelle von pygame.key.get_pressed() können wir sicherstellen, dass nur eine Kugel abgefeuert wird, wenn die Leertaste gedrückt wird.

Zusätzlich können wir einen einfachen Abklingmechanismus implementieren, um ein schnelles Abfeuern der Kugel zu verhindern Schießen. Dies kann durch die Einführung einer Variablen namens next_bullet_threshold erreicht werden, die den frühesten Zeitpunkt angibt, zu dem die nächste Kugel abgefeuert werden kann. Jedes Mal, wenn eine Kugel abgefeuert wird, aktualisieren wir next_bullet_threshold auf die aktuelle Zeit plus die gewünschte Abklingzeit. Indem wir prüfen, ob die aktuelle Zeit größer als next_bullet_threshold ist, können wir verhindern, dass Kugeln außerhalb der gewünschten Abklingzeit abgefeuert werden.

Hier ist der geänderte Code mit dem implementierten Abklingmechanismus:

<code class="python">import pygame
pygame.init()

red = 255,0,0
blue = 0,0,255
black = 0,0,0

screenWidth = 800
screenHeight = 600

gameDisplay = pygame.display.set_mode((screenWidth,screenHeight))        ## screen width and height
pygame.display.set_caption('JUST SOME BLOCKS')       ## set my title of the window

clock = pygame.time.Clock()

class player():       ## has all of my attributes for player 1
    def __init__(self,x,y,width,height):
        self.x = x
        self.y = y
        self.height = height
        self.width = width
        self.vel = 5
        self.left = False
        self.right = False
        self.up = False
        self.down = False

class projectile():     ## projectile attributes
    def __init__(self,x,y,radius,colour,facing):
        self.x = x
        self.y = y
        self.radius = radius
        self.facing = facing
        self.colour = colour
        self.vel = 8 * facing       # speed of bullet * the direction (-1 or 1)

    def draw(self,gameDisplay):
        pygame.draw.circle(gameDisplay, self.colour , (self.x,self.y),self.radius)      ## put a 1 after that to make it so the circle is just an outline

def redrawGameWindow():
    for bullet in bullets:      ## draw bullets
        bullet.draw(gameDisplay)

    pygame.display.update()   

#mainloop

player1 = player(300,410,50,70)     # moves the stuff from the class (when variables are user use player1.var)
bullets = []

run = True
next_bullet_threshold = 0  # Initialize the cooldown threshold
bullet_cooldown = 500  # Set the desired cooldown period in milliseconds
while run == True:
    clock.tick(27)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            run = False

    for bullet in bullets:
        if bullet.x < screenWidth and bullet.x > 0 and bullet.y < screenHeight and bullet.y > 0: ## makes sure bullet does not go off screen
            bullet.x += bullet.vel
        else:
            bullets.pop(bullets.index(bullet))


    keys = pygame.key.get_pressed()     ## check if a key has been pressed

    ## red player movement   
    if keys[pygame.K_w] and player1.y > player1.vel:    ## check if that key has been pressed down (this will check for w)     and checks for boundry
        player1.y -= player1.vel            ## move the shape in a direction
        player1.up = True
        player1.down = False

    if keys[pygame.K_a] and player1.x > player1.vel:      ### this is for a 
        player1.x -= player1.vel
        player1.left = True
        player1.right = False

    if keys[pygame.K_s] and player1.y < screenHeight - player1.height - player1.vel: ## this is for s
        player1.y += player1.vel
        player1.down = True
        player1.up = False

    if keys[pygame.K_d] and player1.x < screenWidth - player1.width - player1.vel:   ## this is for d                          
        player1.x += player1.vel
        player1.right = True
        player1.left = False

    if keys[pygame.K_SPACE]:     # shooting with the space bar
        current_time = pygame.time.get_ticks()
        if current_time >= next_bullet_threshold:  # Check the cooldown timer
            if player1.left == True:   ## handles the direction of the bullet
                facing = -1
            else:
                facing = 1  

            if len(bullets) < 5:    ## max amounts of bullets on screen
                bullets.append(projectile(player1.x + player1.width //2 ,player1.y + player1.height//2,6,black,facing))   ##just like calling upon a function
                next_bullet_threshold = current_time + bullet_cooldown  # Update cooldown timer


    ## level


    gameDisplay.fill((0,255,0))        ### will stop the shape from spreading around and will have a background
    pygame.draw.rect(gameDisplay,(red),(player1.x,player1.y,player1.width,player1.height))  ## draw player
    pygame.display.update()
    redrawGameWindow()

pygame.quit()</code>

Das obige ist der detaillierte Inhalt vonWie implementiert man einen Abkühlmechanismus, um übermäßiges Abfeuern von Kugeln zu verhindern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!