有没有办法限制一个函数在PyGame中可以被调用多少次？

Question

我正在为一个学校项目编写目标射击游戏。在游戏中，您单击鼠标，子弹就会从玩家精灵飞到您的光标处。我目前已经编写了目标绘图、玩家精灵绘图和子弹功能，但是我想限制玩家每秒可以射击的次数。这在一定程度上是为了避免垃圾邮件破坏游戏的性能，并使其比在任何地方快速左键点击更具挑战性。我假设我可以使用 'pygame_clock' 命令，但我不太确定如何使用。下面是代码：

import pygame

#Setting window dimensions and caption. (Module 1)

pygame.init()
window = pygame.display.set_mode((800, 575))
pygame.display.set_caption("TARGET PRACTICE")

#Colour variables. (Module 1)

BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (200, 0, 0)
GREEN = (0, 200, 0)
BLUE = (0, 0, 200)

#py_clock tracks framerate of program for other 'pygame.time' commands. (Module 8)

py_clock = pygame.time.Clock()

#Target class created. (Module 5)

class Target:
  def __init__(self, x, y, h, w, v):
    self.x = x
    self.y = y
    self.h = h
    self.w = w
    self.v = v


#Instantiation of targets. (Module 5)

target_1 = Target(0, 80, 60, 40, 0.5)
target_2 = Target(0, 100, 60, 40, 0.5)
target_3 = Target(0, 50, 60, 40, 0.5)
target_4 = Target(0, 75, 60, 40, 0.5)
target_5 = Target(0, 45, 60, 40, 0.5)
target_6 = Target(0, 85, 60, 40, 0.5)


#Declaring variables to be used in the while loop. (Module 5)

clock = 0

target_2_threshold = 500
target_3_threshold = 1000
target_4_threshold = 1500
target_5_threshold = 2000
target_6_threshold = 2500


#Setting player sprite dimension variables. (Module 6)

player_sprite_x = 357.5
player_sprite_y = 450
player_sprite_h = 125
player_sprite_w = 85

#all_bullets list to store bullets made by function inside loop. (Module7)

all_bullets = []

exec = True

while exec:
  for event in pygame.event.get():
    if event.type == pygame.QUIT:
      exec = False

    #'IF' statement to trigger the shooting function. (Module 7)

    if event.type == pygame.MOUSEBUTTONDOWN:
        if event.button == 1:
            dx = event.pos[0] - (player_sprite_x+ player_sprite_w//2)
            dy = event.pos[1] - player_sprite_y
            direction = pygame.math.Vector2(dx, dy).normalize()
            bullet = {'x': player_sprite_x+42, 'y': player_sprite_y, 'direction': direction}
            all_bullets.append(bullet)

  #Defines movement of targets and sets delay between drawings. (Module 5)   

  clock += 1
  target_1.x += target_1.v
  if clock > target_2_threshold:
        target_2.x += target_2.v
  if clock > target_3_threshold:
        target_3.x += target_3.v
  if clock > target_4_threshold:
        target_4.x += target_4.v
  if clock > target_5_threshold:
        target_5.x += target_5.v
  if clock > target_6_threshold:
        target_6.x += target_6.v

  #all_bullets_keep list combined with FOR loop retains only bullets in the arena. (Module 7)

  all_bullets_keep = []

  for item in all_bullets:
    item['x'] += item['direction'][0] # item['direction'][0] * 2
    item['y'] += item['direction'][1] # item['direction'][1] * 2

    if 0 < item['x'] < 800 and 0 < item['y'] < 575:
          all_bullets_keep.append(item)

  all_bullets = all_bullets_keep

  #Fill the background (Module 5)

  window.fill(RED)

  #Redraw each target in every frame. (Module 5)

  pygame.draw.rect(window, BLUE, (target_1.x, target_1.y, target_1.h, target_1.w))
  if clock > target_2_threshold:
      pygame.draw.rect(window, BLUE, (target_2.x, target_2.y, target_2.h, target_2.w)) 
  if clock > target_3_threshold:
      pygame.draw.rect(window, BLUE, (target_3.x, target_3.y, target_3.h, target_3.w))
  if clock > target_4_threshold:
      pygame.draw.rect(window, BLUE, (target_4.x, target_4.y, target_4.h, target_4.w))
  if clock > target_5_threshold:
      pygame.draw.rect(window, BLUE, (target_5.x, target_5.y, target_5.h, target_5.w))
  if clock > target_6_threshold:
      pygame.draw.rect(window, BLUE, (target_6.x, target_6.y, target_6.h, target_6.w))

  #Draw the player sprite. (Module 6)

  pygame.draw.rect(window, BLUE, (player_sprite_x, player_sprite_y, player_sprite_w, player_sprite_h))

  #Draw each item in all_bullets. (Module 7)

  for item in all_bullets:
    pygame.draw.rect(window, BLUE, (item['x']-5, item['y']-5, 10, 10))

  pygame.display.update()

  #tick_busy_loop limits number of times the game can refresh per second. (Module 8)

  py_clock.tick_busy_loop(120)

pygame.quit()

Answer 1

一种可能是限制子弹数量。例如：

if event.button == 1 and len(all_bullets) < 5:
    dx = event.pos[0] - (player_sprite_x+ player_sprite_w//2)
    dy = event.pos[1] - player_sprite_y
    direction = pygame.math.Vector2(dx, dy).normalize()
    bullet = {'x': player_sprite_x+42, 'y': player_sprite_y, 'direction': direction}
    all_bullets.append(bullet)

另一种选择是确保两次点击之间有一定的时间间隔。使用 pygame.time.get_ticks() 获取当前时间（以毫秒为单位）。生成新子弹后，计算允许生成下一颗子弹的时间。定义 2 颗子弹之间的最短生成时间，并将第 1 颗子弹的时间点初始化为 0:

bullet_delay = 500 # 0.5 seconds
next_bullet_time = 0

在应用程序循环中获取当前时间：

current_time = pygame.time.get_ticks()

点击时，验证当前时间大于next_bullet_time。如果满足条件，则生成子弹并计算下一颗子弹的时间点：

if event.button == 1 and current_time > next_bullet_time:
    next_bullet_time = current_time + bullet_delay

例如：

bullet_delay = 500 # 0.5 seconds
next_bullet_time = 0

while exec:
    current_time = pygame.time.get_ticks()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exec = False

        if event.type == pygame.MOUSEBUTTONDOWN:

            if event.button == 1 and current_time > next_bullet_time:
                next_bullet_time = current_time + bullet_delay

                dx = event.pos[0] - (player_sprite_x+ player_sprite_w//2)
                dy = event.pos[1] - player_sprite_y
                direction = pygame.math.Vector2(dx, dy).normalize()
                bullet = {'x': player_sprite_x+42, 'y': player_sprite_y, 'direction': direction}
                all_bullets.append(bullet)

有没有办法限制一个函数在PyGame中可以被调用多少次？

Is there a way to limit how many times a function can be called in PyGame?

python

oop

pygame

function

bullet