Gestion des entrées clavier dans les jeux Python de la bibliothèque Arcade

La saisie au clavier est une partie essentielle du développement d’un jeu, et il est crucial de la gérer efficacement pour offrir une bonne expérience à l’utilisateur. La bibliothèque Arcade offre un moyen simple et efficace de gérer les entrées clavier dans vos jeux Python.

Créer un jeu simple avec un joueur

Avant d’aborder la gestion des entrées clavier, assurez-vous que pip est installé sur votre appareil. Utilisez cette commande pour installer la bibliothèque arcade :

 pip install arcade 

Ensuite, créez le squelette d’un jeu simple :

 import arcade

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

class MyGame(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height, "My Game")
        arcade.set_background_color(arcade.color.WHITE)

    def on_draw(self):
        arcade.start_render()

    def update(self, delta_time):
        pass

MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
arcade.run() 

Cela crée une fenêtre avec un fond blanc. Ensuite, ajoutez un joueur à votre jeu :

 class Player:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.speed = 5
        self.radius = 20

    def draw(self):
        arcade.draw_circle_filled(self.x, self.y, self.radius, arcade.color.BLUE)

    def move_left(self):
        self.x -= self.speed

    def move_right(self):
        self.x += self.speed

    def move_up(self):
        self.y += self.speed

    def move_down(self):
        self.y -= self.speed 

Ceci crée un joueur simple avec un cercle bleu. Vous pouvez ajouter ce joueur à votre jeu en modifiant le fichier MonJeu classe :

 import arcade

SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480

class MyGame(arcade.Window):
    def __init__(self, width, height):
        super().__init__(width, height, "My Game")
        arcade.set_background_color(arcade.color.WHITE)
        self.player = Player(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)

    def on_draw(self):
        arcade.start_render()
        self.player.draw()

    def update(self, delta_time):
        pass

def main():
    MyGame(SCREEN_WIDTH, SCREEN_HEIGHT)
    arcade.run()

if __name__ == "__main__":
    main() 

Vous avez maintenant un joueur dans votre jeu que vous pouvez dessiner à l’écran.

Réagir aux pressions et aux relâchements de touches

Pour répondre à l’entrée de l’utilisateur dans votre jeu, vous devez gérer les pressions et relâchements de touches. La bibliothèque Arcade propose deux méthodes pour gérer ces événements : on_key_press et sur_la_libération_de_la_clé.

Pour utiliser ces méthodes, vous devez les définir dans votre fichier arcade.Window sous-classe. Lorsque le joueur appuie ou relâche une touche, arcade exécute la méthode correspondante, en lui passant deux arguments : la touche et les modificateurs. touche est un nombre entier représentant le code de la touche enfoncée ou relâchée. modificateurs est un champ de bits représentant toutes les touches de modification sur lesquelles le joueur a également appuyé, comme Shift ou Control.

Voici un exemple de réponse à une pression de touche dans votre jeu :

 class MyGame(arcade.Window):
    def on_key_press(self, key, modifiers):
        if key == arcade.key.LEFT:
            # Move player left
        elif key == arcade.key.RIGHT:
            # Move player right
        elif key == arcade.key.UP:
            # Move player up
        elif key == arcade.key.DOWN:
            # Move player down 

Pour répondre aux relâchements de touches, vous pouvez définir la fonction on_key_release de la même manière :

 class MyGame(arcade.Window):
    def on_key_release(self, key, modifiers):
        if key == arcade.key.LEFT:
            # Stop moving player left
        elif key == arcade.key.RIGHT:
            # Stop moving player right
        elif key == arcade.key.UP:
            # Stop moving player up
        elif key == arcade.key.DOWN:
            # Stop moving player down 

Il est important de noter que la capture de l’entrée de l’utilisateur dans pygame nécessite une vérification manuelle des événements dans votre boucle de jeu. D’un autre côté, la bibliothèque Arcade invoque automatiquement les méthodes pertinentes lorsque le joueur appuie ou relâche une touche. Cela signifie que vous n’avez pas besoin de vérifier manuellement les événements liés aux touches dans votre boucle de jeu, ce qui vous évite un surcroît de code.

Personnaliser la gestion des entrées clavier pour répondre aux besoins de votre jeu

La bibliothèque Arcade offre de nombreuses possibilités de personnaliser la saisie au clavier. Il se peut que vous souhaitiez modifier les combinaisons de touches de votre jeu ou permettre au joueur de personnaliser ses propres combinaisons de touches.

Vous pouvez le faire en définissant un dictionnaire carte_clé qui associe chaque touche à la méthode correspondante de l’objet joueur. Pour permettre au joueur de personnaliser ses combinaisons de touches, vous pouvez ajouter un menu de configuration qui modifie le fichier key_map dictionnaire basé sur les préférences du joueur.

Voici un exemple :

 class MyGame(arcade.Window):
    def __init__(self, width, height, title):
        super().__init__(width, height, title)
        self.player = Player(100, 100)

        self.key_map = {
            arcade.key.LEFT: self.player.move_left,
            arcade.key.RIGHT: self.player.move_right,
            arcade.key.UP: self.player.move_up,
            arcade.key.DOWN: self.player.move_down
        }

    def on_key_press(self, key, modifiers):
        if key in self.key_map:
            self.key_map[key]()

    def on_key_release(self, key, modifiers):
        if key in self.key_map:
            self.key_map[key + 1]() 

Répondre aux commentaires des utilisateurs en temps réel

Répondre aux saisies de l’utilisateur en temps réel est un aspect essentiel de la création d’un jeu attrayant. En prenant le temps de gérer correctement les saisies au clavier dans votre jeu, vous pouvez créer une expérience plus attrayante et immersive pour vos joueurs et, en fin de compte, faire en sorte que votre jeu se démarque sur un marché très encombré.