Créer une animation de balayage radar à l'aide de Pygame en Python

Pygame est un ensemble de modules Python multiplateformes conçus pour écrire des jeux vidéo. Il comprend des bibliothèques d'infographies et de sons conçues pour être utilisées avec le langage de programmation Python. Pygame n'est pas un moteur de développement de jeux, mais un ensemble d'outils et de bibliothèques permettant aux développeurs de créer des jeux 2D à l'aide de Python.

Pygame fournit une variété de fonctions et de classes pour aider les développeurs à créer des jeux, notamment le chargement et la manipulation d'images, la lecture et l'enregistrement du son, la gestion des entrées au clavier et à la souris, la gestion des sprites et des groupes et la détection des collisions. Il inclut également une prise en charge intégrée des tâches courantes de développement de jeux telles que l'animation, le défilement et les cartes basées sur des tuiles.

Pygame est open source et gratuit, et il fonctionne sur Windows, macOS, Linux et d'autres plates-formes. Il est souvent utilisé dans des contextes éducatifs comme introduction au développement de jeux ou comme outil pour enseigner les concepts de programmation.

Composants pour l'animation du balayage radar

Une animation de base de balayage radar comprend les parties suivantes : 

• Radar Circle - C'est le cercle qui représente la portée du radar. Il est centré sur l'origine et possède un rayon fixe.

• Radar Scan - Il s'agit d'une ligne tournant autour du centre d'un cercle. Il représente le faisceau émis par le radar avec une portée de balayage de 360 ​​degrés.

• Cibles radar - Ce sont les objets que nous voulons détecter à l'aide du radar. Ils sont représentés sous forme de points sur l'écran.

Maintenant que nous connaissons les composants d'une animation de balayage radar, plongeons-nous dans l'implémentation à l'aide de Pygame.

Prérequis

Avant de nous lancer dans cette tâche, quelques éléments doivent être installés sur votre

Système-

Liste des paramètres recommandés -

• pip installe Numpy, pygame et Math

• Il est prévu que les utilisateurs puissent accéder à n'importe quel IDE autonome tel que VSCode, PyCharm, Atom ou Sublime Text.

• Vous pouvez même utiliser des compilateurs Python en ligne comme Kaggle.com, Google Cloud Platform ou toute autre plateforme.

• Version Python mise à jour. Au moment d'écrire ces lignes, j'utilise la version 3.10.9.

• Découvrez l'utilisation de Jupyter Notebook.

• La connaissance et l'application des environnements virtuels seraient bénéfiques mais pas obligatoires.

• Attendez-vous également à ce que la personne ait une bonne compréhension des statistiques et des mathématiques.

Détails de mise en œuvre

Importer des bibliothèques - Nous commencerons par importer les bibliothèques nécessaires - Pygame, NumPy et Math.

import pygame
import math
import random

Initialiser la fenêtre de jeu - Nous utiliserons la bibliothèque Pygame pour initialiser la fenêtre de jeu avec la largeur et la hauteur requises.

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

Configurer l'environnement de jeu - Nous configurerons l'environnement de jeu en définissant la couleur, l'arrière-plan et la fréquence d'images de l'animation.

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

Définissez la fréquence d'images de l'animation

Définir le cercle radar - Nous définirons le cercle radar avec le rayon et les coordonnées centrales souhaités. Nous définirons également la couleur du cercle et l’épaisseur du trait.

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

Définir le balayage radar - Nous définirons le balayage radar en réglant l'angle initial à 0 degré et en l'incrémentant à chaque image pour qu'il balaye à 360 degrés. Nous définirons également la couleur et l’épaisseur des lignes de numérisation.

Définir le balayage radar

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)

Définir les cibles radar - Nous définirons les cibles radar en utilisant des coordonnées x et y aléatoires dans le cercle radar. Nous définirons également la couleur et le rayon de la cible.

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]))

Exécuter le jeu - Nous exécuterons le jeu en créant une fenêtre pygame, en configurant les gestionnaires d'événements nécessaires et en exécutant la boucle de jeu.

# 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()

Programme final, 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()

Nous pouvons voir la sortie du programme et observer l'animation du jeu.

Conclusion

Dans ce document, nous explorons comment créer une animation de balayage radar à l'aide de Pygame en Python. Nous avons découvert les composants d'une animation de balayage radar et parcouru les détails de mise en œuvre à l'aide d'extraits de code et d'exemples pratiques. Pygame fournit une API conviviale pour le développement de jeux et constitue un excellent choix pour créer des jeux vidéo et des animations 2D. Avec les connaissances acquises grâce à ce document, vous devriez maintenant être en mesure de créer votre propre animation de balayage radar à l'aide de Pygame.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!