在 pygame 中处理多个玩家键输入的最有效方法是什么？

Question

I'm programming a game with pygame and was wandering what is the best way to handle multiple players key inputs in it, like in a pong game where you can handle key inputs from the 'w, s' keys for one player and the arrow keys for the other.

The way I'm doing it now is by using a variable called 'control_type' in my Player class that is assigned when each player is initialized. Then inside the Player class I check if the variable is equal to 'wasd' or 'arrows' and then check the key inputs accordingly. It works, but sometimes it seems to lag and skip some frames. Is this a good way to do it or is there a better way to handle it?

Answer 1

You can do this, but if you say

but sometimes it seems to lag and skip some frames

remember one thing (because that's a common mistake):

Only ever call pygame.event.get() once per frame. If a key is pressed and the event is added to the queue, and you call pygame.event.get() and don't handle that event, it is lost, and another call to pygame.event.get() will not recieve it.

A common pattern I use is to store all events of a frame in a list, and use that list in multiple places to check for events that the current piece of code is interested in. When using the Sprite class, you can simple pass that list to your Group to pass it down to the sprites.

Simplified example:

...
sprites = pygame.sprite.Group()

while True:
    events = pygame.event.get()
    for e in events:
        ... handle "global" events like QUIT

    sprites.update(events) # pass events to all sprites

Then in a sprite class

class Foo(pygame.sprite.Sprite):
   ...
   def update(self, events):
       for e in events:
           ... handle other events

Another thing to note: in a game like Pong, where you move by holding a key, you're probably not interested in the individual key events, but rather the current state of the key (is it pressed or not?). So you want to call pygame.key.get_pressed() to get the state of the keyboard. Calling pygame.key.get_pressed() multiple times is fine.

Another simplified pseudo example:

class Paddle(pygame.sprite.Sprite):
    def __init__(self, pos, up_key, down_key, *grps):
        super().__init__(*grps)
        self.image = ...
        self.rect = ...
        self.up_key = up_key
        self.down_key = down_key

    def update(self):
        pressed = pygame.key.get_pressed()
        if pressed[self.up_key]:  self.rect.move_ip(0, -1)
        if pressed[self.up_down]: self.rect.move_ip(0,  1)

and initialize multiple players like:

sprites = pygame.sprite.Group()
Player(p1, pygame.K_w, pygame.K_s, sprites)
Player(p2, pygame.K_UP, pygame.K_DOWN, sprites)

Answer 2

A method I've used successfully is whenever a call to pygame.event.get() is made, if the event pulled is needed elsewhere, just put it back on the queue. For example

for event in pygame.event.get():
    if event.type == pygame.KEYDOWN:
        if event.key == pygame.K_UP:
            handle_up()
        # Check for all your other relevant keys...

        elif event.key == pygame.K_w: # Or any key you need elsewhere
            pygame.event.post(event) # Put it back on the queue

You'll need to be careful about this as putting too many things back on the queue can cause the queue to fill up. But if everything you put back on the queue is definitely going to be used elsewhere, then you're good.