Erstellen Sie eine Radarscan-Animation mit Pygame in Python

Pygame ist eine Reihe plattformübergreifender Python-Module, die zum Schreiben von Videospielen entwickelt wurden. Es umfasst Computergrafik- und Soundbibliotheken, die für die Verwendung mit der Programmiersprache Python entwickelt wurden. Pygame ist keine Spieleentwicklungs-Engine, sondern eine Reihe von Tools und Bibliotheken, die es Entwicklern ermöglichen, 2D-Spiele mit Python zu erstellen.

Pygame bietet eine Vielzahl von Funktionen und Klassen, die Entwicklern beim Erstellen von Spielen helfen, darunter das Laden und Bearbeiten von Bildern, die Wiedergabe und Aufnahme von Ton, die Verarbeitung von Tastatur- und Mauseingaben, die Sprite- und Gruppenverwaltung sowie die Kollisionserkennung. Es umfasst außerdem integrierte Unterstützung für gängige Spieleentwicklungsaufgaben wie Animation, Scrollen und kachelbasierte Karten.

Pygame ist Open Source und kostenlos nutzbar und läuft auf Windows, macOS, Linux und anderen Plattformen. Es wird häufig im Bildungsbereich als Einführung in die Spieleentwicklung oder als Hilfsmittel zum Vermitteln von Programmierkonzepten verwendet.

Komponenten für die Radarscan-Animation

Eine einfache Radarscan-Animation besteht aus den folgenden Teilen:

• Radarkreis – Dies ist der Kreis, der die Radarreichweite darstellt. Es ist auf den Ursprung zentriert und hat einen festen Radius.

• Radarscan – Dies ist eine Linie, die sich um den Mittelpunkt eines Kreises dreht. Es stellt den vom Radar ausgesendeten Strahl mit einem Scanbereich von 360 Grad dar.

• Radarziele – Dies sind die Objekte, die wir mit Radar erkennen möchten. Sie werden als Punkte auf dem Bildschirm dargestellt.

Da wir nun die Komponenten einer Radarscan-Animation kennen, tauchen wir in die Implementierung mit Pygame ein.

Voraussetzungen

Bevor wir uns mit der Aufgabe befassen, müssen einige Dinge auf Ihrem

installiert werden

System-

Liste der empfohlenen Einstellungen -

• pip installiert Numpy, Pygame und Math

• Es wird erwartet, dass Benutzer auf jede eigenständige IDE wie VSCode, PyCharm, Atom oder Sublime Text zugreifen können.

• Sie können sogar Online-Python-Compiler wie Kaggle.com, Google Cloud Platform oder jede andere Plattform verwenden.

• Aktualisierte Python-Version. Zum jetzigen Zeitpunkt verwende ich Version 3.10.9.

• Erfahren Sie mehr über die Verwendung von Jupyter Notebook.

• Kenntnisse und Anwendung virtueller Umgebungen wären von Vorteil, aber nicht zwingend erforderlich.

• Erwarten Sie außerdem, dass die Person über gute Kenntnisse in Statistik und Mathematik verfügt.

Implementierungsdetails

Bibliotheken importieren – Wir beginnen mit dem Import der erforderlichen Bibliotheken – Pygame, NumPy und Math.

import pygame
import math
import random

Spielfenster initialisieren – Wir werden die Pygame-Bibliothek verwenden, um das Spielfenster mit der erforderlichen Breite und Höhe zu initialisieren.

WIDTH = 800
HEIGHT = 600
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Radar Sweep Animation")
clock = pygame.time.Clock()

Spielumgebung einrichten – Wir richten die Spielumgebung ein, indem wir die Farbe, den Hintergrund und die Bildrate der Animation definieren.

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

Stellen Sie die Bildrate der Animation ein

Radarkreis definieren - Wir definieren den Radarkreis mit dem gewünschten Radius und den gewünschten Mittelpunktskoordinaten. Außerdem legen wir die Farbe und Linienstärke des Kreises fest.

radar_circle_radius = 200
radar_circle_center_x = int(WIDTH / 2)
radar_circle_center_y = int(HEIGHT / 2)

Radarscan definieren – Wir definieren den Radarscan, indem wir den Anfangswinkel auf 0 Grad setzen und ihn bei jedem Frame erhöhen, sodass er 360 Grad scannt. Wir werden auch die Farbe und Dicke der Scanlinien festlegen.

Radarscan definieren

radar_sweep_angle = 0
radar_sweep_length = radar_circle_radius + 50
def update():
   # Increment the angle in each frame
   global radar_sweep_angle
   radar_sweep_angle += 1
# Draw the radar sweep line
def draw_radar_sweep():
   x = radar_circle_center_x + radar_sweep_length *
math.sin(math.radians(radar_sweep_angle))
   y = radar_circle_center_y + radar_sweep_length *
math.cos(math.radians(radar_sweep_angle))
   pygame.draw.line(screen, BLACK, (radar_circle_center_x,
radar_circle_center_y), (x, y), 3)

Radarziele definieren – Wir definieren Radarziele mithilfe zufälliger x- und y-Koordinaten innerhalb des Radarkreises. Außerdem legen wir die Farbe und den Radius des Ziels fest.

num_targets = 10
target_radius = 10
targets = []
for i in range(num_targets):
   x = random.randint(radar_circle_center_x - radar_circle_radius,
radar_circle_center_x + radar_circle_radius)
   y = random.randint(radar_circle_center_y - radar_circle_radius,
radar_circle_center_y + radar_circle_radius)
   targets.append((x, y))
   # Draw the radar targets
def draw_radar_targets():
   for target in targets:
      pygame.draw.circle(screen, BLUE, target, target_radius)
      distance_to_target = math.sqrt((target[0] - x) ** 2 + (target[1] - y) ** 2)
      if distance_to_target <= target_radius:
         pygame.draw.rect(screen, RED, (target[0], target[1], 60, 20))
         font = pygame.font.SysFont(None, 25)
         text = font.render("DETECTED", True, BLACK)
         screen.blit(text, (target[0], target[1]))

Führen Sie das Spiel aus – Wir führen das Spiel aus, indem wir ein Pygame-Fenster erstellen, die erforderlichen Ereignishandler einrichten und die Spielschleife ausführen.

# Main game loop
running = True
while running:
   for event in pygame.event.get():
      if event.type == pygame.QUIT:
         running = False
   screen.fill(WHITE)
   update()
   draw_radar_sweep()
   draw_radar_targets()
   pygame.display.update()
   clock.tick(FPS)
# Quit the game
pygame.quit()

Endgültiges Programm, Code

import pygame
import math
import random
# Initializing the Game Window:
WIDTH = 800
HEIGHT = 600
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Radar Sweep Animation")
clock = pygame.time.Clock()
# Defining colors:
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
# Set the frame rate of the animation
FPS = 60
# Defining the Radar Circle:
radar_circle_radius = 200
radar_circle_center_x = int(WIDTH / 2)
radar_circle_center_y = int(HEIGHT / 2)
# Define the radar sweep
radar_sweep_angle = 0
radar_sweep_length = radar_circle_radius + 50
# Define the radar targets
num_targets = 10
target_radius = 10
targets = []
for i in range(num_targets):
   x = random.randint(radar_circle_center_x - radar_circle_radius,
radar_circle_center_x + radar_circle_radius)
   y = random.randint(radar_circle_center_y - radar_circle_radius,
radar_circle_center_y + radar_circle_radius)
targets.append((x, y))
def update():
   # Increment the angle in each frame
   global radar_sweep_angle
   radar_sweep_angle += 1
# Draw the radar sweep line
def draw_radar_sweep():
   x = radar_circle_center_x + radar_sweep_length *
math.sin(math.radians(radar_sweep_angle))
   y = radar_circle_center_y + radar_sweep_length *
math.cos(math.radians(radar_sweep_angle))
   pygame.draw.line(screen, BLACK, (radar_circle_center_x,
radar_circle_center_y), (x, y), 3)
# Draw the radar targets
def draw_radar_targets():
   for target in targets:
      pygame.draw.circle(screen, BLUE, target, target_radius)
      distance_to_target = math.sqrt((target[0] - x) ** 2 + (target[1] - y)** 2)
      if distance_to_target <= target_radius:
         pygame.draw.rect(screen, RED, (target[0], target[1], 60, 20))
         font = pygame.font.SysFont(None, 25)
         text = font.render("DETECTED", True, BLACK)
         screen.blit(text, (target[0], target[1]))
# Main game loop
running = True
while running:
   for event in pygame.event.get():
      if event.type == pygame.QUIT:
         running = False
         screen.fill(WHITE)
         update()
         draw_radar_sweep()
         draw_radar_targets()
      pygame.display.update()
      clock.tick(FPS)
# Quit the game
pygame.quit()

Wir können die Ausgabe des Programms sehen und die Animation des Spiels beobachten.

Fazit

In diesem Dokument erfahren Sie, wie Sie mit Pygame in Python eine Radarscan-Animation erstellen. Wir lernten die Komponenten einer Radarscan-Animation kennen und gingen die Implementierungsdetails anhand von Codeausschnitten und praktischen Beispielen durch. Pygame bietet eine benutzerfreundliche API für die Spieleentwicklung und ist eine ausgezeichnete Wahl für die Erstellung von 2D-Videospielen und Animationen. Mit den Erkenntnissen aus diesem Dokument sollten Sie nun in der Lage sein, mit Pygame Ihre eigene Radarscan-Animation zu erstellen.

Das obige ist der detaillierte Inhalt vonErstellen Sie eine Radarscan-Animation mit Pygame in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!