Créez une interface utilisateur de jeu à partir de zéro avec pygame2!

Aperçu

Cet article est l'article du 14ème jour du Future Advent Calendar 2019. L'article d'hier était de @RuyPKG Même les nouveaux venus veulent s'amuser! ~ Préparation des minutes ~.

L'autre jour, lors d'une session d'étude en interne, @shibukawa a présenté le moteur de jeu, ce qui a motivé la rédaction de cet article. Je voulais une interface utilisateur de jeu de société implémentée en Python et il était difficile d'exprimer le mouvement avec des expressions HTML, j'ai donc décidé de toucher pygame, qui est un moteur de jeu Python.

Qu'est-ce que pygame

Un moteur de jeu multiplateforme qui peut être exécuté sur Python. Si vous pouvez écrire la partie graphique du jeu en Python, c'est très pratique car vous pouvez intégrer la logique du jeu écrite en Python telle quelle.

Concernant ce pygame, puisque le développement a été temporairement arrêté en 2009 et qu'il ne fonctionne plus depuis un moment, de nombreuses personnes qui connaissent pygame ont peut-être changé. Cependant, le développement de la sortie de pygame2 sera actif en 2019, et il est probable que cette version de pygame2 sortira au cours de l'année prochaine. À partir de 2.0.0.dev6, python3.8 est également pris en charge et je l'attends avec impatience. Je pense que cela attirera l'attention à l'avenir.

environnement

• pygame: 2.0.0.dev6
• python: 3.8.0

Environnement

Nous allons procéder à la construction de l'environnement en nous référant au pygame officiel Getting Started.

Installez pygame via pip. Pour le moment, si vous ne spécifiez pas la version, la dernière version stable 1.9.6 sera incluse, alors soyez prudent. (1.9.6 prend uniquement en charge jusqu'à python3.6)

pip install pygame==2.0.0.dev6

Essayez de déplacer l'échantillon

De nombreux exemples de jeux sont inclus dans pygame. Essayons-en un.

python -m pygame.examples.aliens

Quelque chose comme un jeu d'envahisseur a été lancé! Une liste d'échantillons et de quel type de jeu chacun peut être trouvé dans README of git example folder, il est donc intéressant d'essayer diverses choses.

Faites un échantillon à partir de 1

Lors du décodage de l'échantillon, je dessinerai le code moi-même. Cette fois, je viserai un échantillon qui n'écrit que des caractères en arrière-plan.

Flux de processus

Contrairement à l'écran statique, lors du dessin avec le moteur de jeu, il est nécessaire de mettre à jour l'écran à grande vitesse. Par conséquent, le processus est exécuté comme suit.

1. Initialisation du chargement d'image, etc.
2. Effacez l'écran et dessinez l'image d'arrière-plan
3. Mettez à jour la position et la valeur de l'objet affiché à l'écran et dessinez
4. Reflet des mises à jour d'écran
5. Revenir à 2

Dans le moteur de jeu, les objets affichés à l'écran sont dessinés à l'aide de sprites, ils sont donc dessinés au moment de l'implémentation à l'aide d'une classe qui hérite de la classe de sprite. Si vous êtes curieux de connaître les sprites, vérifiez-les. C'est intéressant car il y a un arrière-plan historique comme l'histoire d'implémentation matérielle pour accélérer le dessin, mais je pense qu'il n'y a pas de problème particulier même si vous ne le savez pas.

import os
import pygame as pg

# game constants
SCREENRECT = pg.Rect(0, 0, 640, 480)
SCORE = 0

main_dir = os.path.split(os.path.abspath(__file__))[0]


def load_image(file):
    """ loads an image, prepares it for play
    """
    file = os.path.join(main_dir, "data", file)
    try:
        surface = pg.image.load(file)
    except pg.error:
        raise SystemExit('Could not load image "%s" %s' % (file, pg.get_error()))
    return surface.convert()

class Score(pg.sprite.Sprite):
    """ to keep track of the score.
    """

    def __init__(self):
        pg.sprite.Sprite.__init__(self)
        self.font = pg.font.Font(None, 40)
        self.font.set_italic(1)
        self.color = pg.Color("white")
        self.lastscore = -1
        self.update()
        self.rect = self.image.get_rect().move(10, 450)

    def update(self):
        """ We only update the score in update() when it has changed.
        """
        if SCORE != self.lastscore:
            self.lastscore = SCORE
            msg = "Score: %d" % SCORE
            self.image = self.font.render(msg, 0, self.color)

def main(winstyle=0):
    pg.init()
    # Set the display mode
    winstyle = 0  # |FULLSCREEN
    bestdepth = pg.display.mode_ok(SCREENRECT.size, winstyle, 32)
    screen = pg.display.set_mode(SCREENRECT.size, winstyle, bestdepth)

    # create the background, tile the bgd image
    bgdtile = load_image("background.jpg ")
    background = pg.Surface(SCREENRECT.size)
    background.blit(bgdtile, (0, 0))
    screen.blit(bgdtile, (0, 0))
    pg.display.flip()

    # Initialize Game Groups
    all = pg.sprite.RenderUpdates()

    # Create Some Starting Values
    clock = pg.time.Clock()
    global SCORE
    if pg.font:
        all.add(Score())

    # Run our main loop whilst the player is alive.
    while True:
        all.clear(screen, background)
        SCORE += 123456789
        all.update()

        # draw the scene
        dirty = all.draw(screen)
        pg.display.update(dirty)

        # cap the framerate at 40fps. Also called 40HZ or 40 times per second.
        clock.tick(40)


if __name__ == "__main__":
    main()

Il est nécessaire de préparer une image de fond (background.jpg) sous data. C'est un peu long, mais si vous exécutez l'exemple ci-dessus, vous pouvez dessiner l'arrière-plan et afficher les caractères comme indiqué ci-dessous.

Les pièces uniques au moteur de jeu sont expliquées ci-dessous.

Regroupement de sprites

all = pg.sprite.RenderUpdates() #Créer un groupe Sprite
all.add(Score()) #Ajouter au groupe Sprite
all.update() #Mise à jour groupée du groupe Sprite
all.draw(screen) #Groupe Sprite de dessin

pygame a une fonctionnalité qui vous permet de regrouper les sprites afin que vous puissiez facilement mettre à jour et dessiner tous les éléments de l'écran ou les éléments d'un groupe spécifique (par exemple les personnages ennemis uniquement) en une seule fois. .. Il existe différents types de groupes de sprites, tels que des groupes ordonnés et des groupes pour des sprites uniques, et il est préférable de les utiliser en fonction de l'objectif. Vous pouvez consulter la liste dans Documents officiels.

Spécifiez le taux de rafraîchissement de l'écran

clock = pg.time.Clock() #Génération d'horloge
clock.tick(40) #Utilisation de l'horloge 1/Attendez le traitement jusqu'à ce que 40 secondes se soient écoulées

Lors du déplacement d'un objet, il faut attendre si le processus se termine trop tôt pour le déplacer à la même vitesse quel que soit le poids du processus. Pour ce faire, pygame utilise un objet Clock. Créez simplement un objet Clock et appelez clock.tick (), et il dormira pendant le temps en fonction de la fréquence d'images de l'appel précédent, ce qui est très pratique.

finalement

En plus de la fonction de dessin introduite cette fois, pygame

• Accepter l'entrée
• Lecture sonore
• Compatible avec Android et iOS

Il existe différentes fonctions telles que. C'est tellement pratique de pouvoir écrire une interface utilisateur qui se met à jour en temps réel en Python, j'ai donc hâte de voir la sortie officielle de pygame2!