[PYTHON] Ballonaufteilungsspiel mit Pygame

Einführung

In Letzter Beitrag habe ich mit tkinter ein rundenbasiertes Drei-Augen-Array erstellt, daher habe ich dieses Mal Pygame verwendet, um den Bildschirm ständig zu aktualisieren. Ich habe versucht zu machen. Ich habe es als Ballon-Splitting-Spiel im Titel geschrieben, aber es ist nicht so spielerisch. Lol Kann es jedoch in Zukunft für Spiele verwendet werden? Ich frage mich, ob ich die Verarbeitung lernen könnte. .. .. Ich denke. Wie üblich handelt es sich um einen chimären Code mit allen gewünschten Funktionen, sodass die Lesbarkeit ein zukünftiges Problem darstellt.

Dieses fertige Produkt
balloon_game.gif

Ganz am Ende wird das gesamte Bild dieses Codes veröffentlicht.

Bildschirmerstellung anzeigen

Zuallererst ist es die Erstellung des Grundbildschirms.

import pygame

pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Game")

Pygame trotzdem importieren. Initialisieren Sie das Pygame-Modul mit pygame.init (). Wenn Sie an der Eröffnung schreiben, kann es gut sein, die übliche Zauberstufe zu erkennen. Wenn Sie eine große Anzahl von Modulen verwenden, sollten Sie die nicht verwendeten Module initialisieren. Vielleicht kommt der Tag mitten im Prozess?

pygame.display.set_mode ist die Bildschirmgröße, -breite und -höhe. set_caption ist der Name, der in der Titelleiste angezeigt wird.

Bildschirmaktualisierungsprozess

import time

FPSCLOCK = pygame.time.Clock()
FPS = 15

class CanonGame():
    def __init__(self):

        while True:
            pygame.display.update()
            FPSCLOCK.tick(FPS)

def main():
    CanonGame()

if __name__ == '__main__':
    main()

Die Hauptrolle. Nach dem Reflektieren der Bildschirmzeichnung mit pygame.display.update () wird die Verarbeitung mit pygame.time.Clock.tick (Frames) mit einer Geschwindigkeit ausgeführt, die (Frames) pro Sekunde nicht überschreitet. Wenn Sie die Anzahl der Frames erhöhen, können Sie eine reibungslose Bewegung implementieren, die Verarbeitung wird jedoch umfangreich. Stellen Sie außerdem Dinge, die ständig aktualisiert werden, in den Bereich von while True :.

Schlüsselereignis abrufen

from pygame.locals import *

pygame.key.set_repeat(5, 5)

class CanonGame():
        while True:
            for event in pygame.event.get():
                if event.type == QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_SPACE:
                        self.bullet_shot = True
                    elif event.key == K_UP and self.cannon_radian < 89:
                        self.cannon_radian += 1
                    elif event.key == K_DOWN and self.cannon_radian > 0:
                        self.cannon_radian -= 1

Wenn es um Spiele geht, möchten Sie es trotzdem bedienen, oder? Ruft die Art der Operation ab, die von event.get () ausgeführt wird. Wenn event.type QUIT ist (x-Schaltfläche oben rechts auf dem Bildschirm), beenden Sie alles. Wenn es KEYDOWN (Tastendruck) ist, wird event.key erfasst und jeder gedrückten Taste wird eine Verarbeitung zugewiesen. Feuern Sie diesmal den Ball mit der Leertaste ab. Ich habe die Ausrichtung mit den Auf- und Ab-Tasten angepasst. Wenn Sie key.set_repeat festlegen, reagiert es auch dann, wenn Sie die Taste gedrückt halten.

Bildanzeige, Drehung


class CanonGame():
    def __init__(self):
        bullet_image = pygame.image.load("bullet.png ")
        self.cannon_image = pygame.image.load("cannon.png ")

            screen.fill((255, 255, 255))
            screen.blit(bullet_image, (self.bullet_x, self.bullet_y))

            rotate_cannon = pygame.transform.rotate(self.cannon_image, self.cannon_radian - 45)
            cannon_rect = rotate_cannon.get_rect()
            cannon_rect.center = (84, 536)
            screen.blit(rotate_cannon, cannon_rect)

Laden Sie das Bild mit pygame.image.load ("Bildname"). Das Bild wird an derselben Stelle gespeichert, an der die ausführbare Datei gespeichert ist. screen.fill (Rot, Grün, Blau) ist die Hintergrundfarbe. Ich habe dieses Mal kein Hintergrundbild vorbereitet, daher male ich den Hintergrund jedes Mal neu und lösche die vorherigen Bilder. Ohne dies bleiben die vorherigen Prozesse unverändert. screen.blit (Bild, (x, y)): Beim Anordnen der Bilder muss darauf geachtet werden, dass oben links auf dem Bildschirm x: 0, y: 0 angezeigt wird. Die x- und y-Werte erhöhen sich unten rechts auf dem Bildschirm.

Verschiedene Verhaltensweisen

In Bezug auf das Verhalten im Spiel werde ich einige aufgreifen und es erklären.

from random import randint

self.balloon_x = randint(500, 700)

Randint (Minimum, Maximum). Dadurch wird die x-Koordinate, an der der Ballon erscheint, zufällig angezeigt. Da es int ist, wird es zufällig aus den ganzen Zahlen im eingestellten Wert ausgewählt.

import sys

sysfont = pygame.font.SysFont(None, 36)

        while True:
            score_image = sysfont.render("score : {}".format(self.score), True, (0, 0, 255))
            screen.blit(score_image, (10, 20))

Ausgabe von Zeichen. Sie können pygame.font.Sysfont (Name, Größe, Fettdruck, Kursivschrift) und 4 Parameter ändern. format () ist in {} von sysfont.render enthalten.

    def set_balloon(self):
        now_time = time.time()
        if self.is_collision:
            if now_time - self.balloon_break > 1:
                self.is_collision = False
        if self.is_collision is False:
            if self.is_balloon:
                self.balloon_y = self.balloon_y - 12
                self.balloon_alive = time.time()
                if self.balloon_alive - self.balloon_create > 4:
                    self.is_balloon = False
                else:
                    self.collision_check()
            else:
                self.balloon_image = pygame.image.load("balloon-red.png ")
                self.balloon_x = randint(500, 700)
                self.balloon_y = 600
                self.is_balloon = True
                self.balloon_create = time.time()

Außerdem verwendet die Funktion set_balloon, die ich schreibe, hier das Zeitmodul. Wenn ein Ballon angezeigt wird, wird die aktuelle Zeit als balloon_create erfasst, und danach wird die als balloon_alive bezeichnete Zeit kontinuierlich erfasst. Wenn die Differenz 4 Sekunden oder mehr beträgt, wird der Ballon erneut angezeigt. Übrigens wird now_time auch gemessen, sodass der Ballon eine Sekunde später erscheint, wenn der Ballon zerbricht.

Wenn Sie nach n Sekunden überprüfen, ob der Vorgang ausgeführt werden soll, wird der Ruhezustand angezeigt. Beachten Sie jedoch, dass der gesamte Vorgang dadurch gestoppt wird.

import math

    def bullet(self):
        gravity = 9.8
        if self.bullet_shot:
            bullet_speed_x = self.bullet_speed * math.cos(math.radians(self.cannon_radian))
            bullet_speed_y = (self.bullet_speed * math.sin(math.radians(self.cannon_radian)))
            self.bullet_x = self.bullet_x + bullet_speed_x
            self.bullet_y = self.bullet_y - bullet_speed_y + gravity * self.time
            self.time += 0.2

            if self.bullet_x > 800 or self.bullet_y > 600:
                self.bullet_shot = False
                self.set_bullet()

Das Verhalten des abgefeuerten Balls ist ähnlich wie bei Sinus-Cosinus im Abschusswinkel. Ich habe mich gefragt, ob ich eine richtige physikalische Formel verwenden soll, aber es wurde eine solche Bewegung, also Yoshi!

Der nächste Ball wird erst abgefeuert, wenn der Ball vom Bildschirm verschwindet.

    def collision_check(self):
        distance_y = ((self.balloon_y + 15) - (self.bullet_y + 16))**2
        distance_x = ((self.balloon_x + 20) - (self.bullet_x + 16))**2
        distance = (distance_x + distance_y)**(1/2)
        if distance < 31:
            self.pang_image = pygame.image.load("pang.png ")
            self.pang_rect = self.pang_image.get_rect()
            self.pang_rect.center = (self.balloon_x + 20, self.balloon_y + 15)
            self.is_collision = True
            self.is_balloon = False
            self.total_score(100)
            self.balloon_break = time.time()

Kollisionsurteil. Dieses Mal wird der Absolutwert vom ungefähren Mittelpunkt der Kugel und des Ballons berechnet. Es ist lange her und ich habe den Drei-Quadrat-Satz gegoogelt. Es ist einfach, wenn die Trefferbox ein Kreis ist! (Berechnen Sie im Fall eines Quadrats den absoluten Wert der Differenz zwischen der x-Achse und der y-Achse und verwenden Sie und.) Wenn Sie kollidieren, erhalten Sie 100 Punkte.

Am Ende

Der beste Weg, um verschiedene Verhaltensweisen zu lernen, besteht darin, sie zu berühren. Wenn Sie die Elemente dieser Zeit kombinieren, können Sie meiner Meinung nach fast ein einfaches Spiel machen. Außerdem möchte ich Illustrationen zeichnen können ...

Der ganze Code

import math
import sys
import pygame
from pygame.locals import *
from random import randint
import time

pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("Game")
sysfont = pygame.font.SysFont(None, 36)
pygame.key.set_repeat(5, 5)
FPSCLOCK = pygame.time.Clock()
FPS = 15


class CanonGame():
    def __init__(self):
        bullet_image = pygame.image.load("bullet.png ")
        self.set_cannon()
        self.set_bullet()
        self.bullet_shot = False
        self.is_balloon = False
        self.is_collision = False
        self.score = 0

        while True:
            for event in pygame.event.get():
                if event.type == QUIT:
                    pygame.quit()
                    sys.exit()
                elif event.type == KEYDOWN:
                    if event.key == K_SPACE:
                        self.bullet_shot = True
                    elif event.key == K_UP and self.cannon_radian < 89:
                        self.cannon_radian += 1
                    elif event.key == K_DOWN and self.cannon_radian > 0:
                        self.cannon_radian -= 1

            self.set_balloon()
            self.bullet()

            screen.fill((255, 255, 255))
            screen.blit(bullet_image, (self.bullet_x, self.bullet_y))
            if not self.is_collision:
                screen.blit(self.balloon_image, (self.balloon_x, self.balloon_y))
            elif self.is_collision:
                screen.blit(self.pang_image, self.pang_rect)
            rotate_cannon = pygame.transform.rotate(self.cannon_image, self.cannon_radian - 45)
            cannon_rect = rotate_cannon.get_rect()
            cannon_rect.center = (84, 536)
            screen.blit(rotate_cannon, cannon_rect)
            score_image = sysfont.render("score : {}".format(self.score), True, (0, 0, 255))
            screen.blit(score_image, (10, 20))

            pygame.display.update()
            FPSCLOCK.tick(FPS)

    def set_bullet(self):
        self.bullet_x = 68
        self.bullet_y = 520
        self.bullet_speed = 50
        self.time = 0

    def set_cannon(self):
        self.cannon_image = pygame.image.load("cannon.png ")
        self.cannon_radian = 45

    def set_balloon(self):
        now_time = time.time()
        if self.is_collision:
            if now_time - self.balloon_break > 1:
                self.is_collision = False
        if self.is_collision is False:
            if self.is_balloon:
                self.balloon_y = self.balloon_y - 12
                self.balloon_alive = time.time()
                if self.balloon_alive - self.balloon_create > 4:
                    self.is_balloon = False
                else:
                    self.collision_check()
            else:
                self.balloon_image = pygame.image.load("balloon-red.png ")
                self.balloon_x = randint(500, 700)
                self.balloon_y = 600
                self.is_balloon = True
                self.balloon_create = time.time()

    def bullet(self):
        gravity = 9.8
        if self.bullet_shot:
            bullet_speed_x = self.bullet_speed * math.cos(math.radians(self.cannon_radian))
            bullet_speed_y = (self.bullet_speed * math.sin(math.radians(self.cannon_radian)))
            self.bullet_x = self.bullet_x + bullet_speed_x
            self.bullet_y = self.bullet_y - bullet_speed_y + gravity * self.time
            self.time += 0.2

            if self.bullet_x > 800 or self.bullet_y > 600:
                self.bullet_shot = False
                self.set_bullet()

    def collision_check(self):
        distance_y = ((self.balloon_y + 15) - (self.bullet_y + 16))**2
        distance_x = ((self.balloon_x + 20) - (self.bullet_x + 16))**2
        distance = (distance_x + distance_y)**(1/2)
        if distance < 31:
            self.pang_image = pygame.image.load("pang.png ")
            self.pang_rect = self.pang_image.get_rect()
            self.pang_rect.center = (self.balloon_x + 20, self.balloon_y + 15)
            self.is_collision = True
            self.is_balloon = False
            self.total_score(100)
            self.balloon_break = time.time()

    def total_score(self, score):
        self.score = self.score + score


def main():
    CanonGame()


if __name__ == '__main__':
    main()

Recommended Posts

Ballonaufteilungsspiel mit Pygame
Erstelle mit pygame2 eine neue Benutzeroberfläche!
Programmier-Lernspiel mit SenseHAT
Einfaches Tippspiel mit DragonRuby
Othello-Spieleentwicklung mit Python
Lebensspiel mit Python! (Conways Spiel des Lebens)
Spieltheorie mit Kombinationsoptimierung lösen
Sugoroku-Spiel und Zusatzspiel mit Python