Introduction à la classe Polygone de Pymunk : Création d'objets physiques polygonaux

Création de Formes Polygonales en Pymunk : La Classe Polygone

La classe de formes Polygone en Pymunk représente une forme polygonale. Elle peut être utilisée pour créer des objets tels que des murs, des sols, des obstacles et des objets de jeu.

Définition

La classe Polygone est définie dans le module pymunk.shapes. Elle hérite de la classe Shape, qui représente une forme physique en général.

Exemple

Exemple :      Copier le code

 
from pymunk import Body, Poly, Space

space = Space()
# Créer un corps
body = Body(mass=1, moment=1)

# Créer un polygone, ici il s’agit d'un carré 
sommets = [(10, 10), (50, 10), (50, 50), (10, 50)]
polygon = Poly(body, sommets, radius=1)

# Attacher la forme au corps
space.add(body, polygon)

Explication du code ligne par ligne :

1. Importation des modules nécessaires depuis la bibliothèque Pymunk :

    
   from pymunk import Body, Poly, Space
   

2. Création de l'espace Pymunk où les objets physiques seront simulés :

    
   space = Space()
   

3. Création d'un corps Pymunk pour représenter un objet physique :

    
   body = Body(mass=1, moment=1)
   

4. • mass est la masse du corps.
   • moment est le moment d'inertie du corps, qui affecte la façon dont le corps réagit à la rotation.
5. Définition des sommets du polygone en spécifiant leurs coordonnées (en mètres) dans une liste sommets. Dans cet exemple, un carré est créé avec des sommets aux coordonnées (10, 10), (50, 10), (50, 50) et (10, 50) :

    
   sommets = [((10, 10), (50, 10), (50, 50), (10, 50)]
   

6. Création d'une forme polygonale Pymunk associée au corps créé précédemment. Le paramètre radius détermine le rayon de l'arrondi des coins du polygone :

    
   polygon = Poly(body, sommets, radius=1)
   

7. Ajout du corps et de la forme polygonale à l'espace Pymunk. Cela permet à l'espace de prendre en charge la simulation du polygone :

    
   space.add(body, polygon)
   

Le code global crée un espace Pymunk, un corps Pymunk, un polygone à quatre sommets (un carré), attache le polygone au corps, puis ajoute le corps et la forme polygonale à l'espace pour permettre la simulation physique du carré.

Pour l'affichage du résultat du code précédent, vous pouvez utiliser Pygame ou toute autre bibliothèque graphique de votre choix.

Code utilisant la bibliothèque Pygame :

Exemple :      Copier le code

 
import pygame
from pygame.locals import *
from pymunk.pygame_util import DrawOptions

# Initialisation de Pygame
pygame.init()

# Dimensions de la fenêtre
window_width = 400
window_height = 200

# Création de la fenêtre Pygame
screen = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("Affichage Pymunk avec Pygame")

# Options d'affichage pour Pymunk
draw_options = DrawOptions(screen)

# Boucle principale
running = True
while running:
    for event in pygame.event.get():
        if event.type == QUIT:
            running = False

    # Efface l'écran
    screen.fill((255, 255, 255))

    # Affiche le polygone avec les options Pymunk
    space.debug_draw(draw_options)

    # Mise à jour de l'affichage
    pygame.display.flip()

    # Met à jour l'espace Pymunk
    space.step(1 / 60.0)  # Ajustez cette valeur selon la fréquence de rafraîchissement souhaitée

# Quitte Pygame
pygame.quit()

Approche orientée objet: Utilisation des classes

Comme nous l'avons toujour fait dans les chapitres précédents, nous allons utiliser les classes que nous metons dans le fichier 'classeForme.py'

Nous allons donc ajouter dans le fichier 'classeForme.py' une classe polygon dont voici le code:

Exemple :      Copier le code

class Polygon:
    def __init__(self, pos, sommets):
        self.body = pymunk.Body(1, 100)
        self.body.position = pos

        shape = pymunk.Poly(self.body, sommets)
        shape.density = 0.1
        shape.elasticity = 1
        space.add(self.body, shape)

On va ajouter aussi une classe rectangle dont le code est le suivant:

Exemple :      Copier le code

class Rectangle:
    def __init__(self, pos, size=(80, 50)):
        self.body = pymunk.Body()
        self.body.position = pos

        shape = pymunk.Poly.create_box(self.body, size)
        shape.density = 0.1
        shape.elasticity = 1
        shape.friction = 1
        space.add(self.body, shape)

Télécharger le fichier classeForme.py

Maintenant pour utiliser les classes du fichier 'classeForme.py' il suffit d'importer les classes voulues à partir de ce fichier comme le montre le code suivant

Exemple :      Copier le code

 from classeForme import pymunk, space, App, Box, Polygon

Box()

sommets = [(10, 10), (50, 10), (50, 50), (10, 50)]
Polygon((100, 150), sommets )

App().run()

Explication du code:

  
from classeForme import pymunk, space, App, Box, Polygon

Cette ligne importe plusieurs classes et objets du module classeForme pour être utilisés dans le code principal.

  
Box()

Crée une instance de la classe Box du module classeForme, ce qui signifie qu'un mur (rectangle statique) est créé.

  
sommets = [(10, 10), (50, 10), (50, 50), (10, 50)]
Polygon((100, 150), sommets)

Ces lignes créent un polygone en utilisant la classe Polygon du module classeForme. Le polygone est défini par une liste de sommets sommets. Les sommets spécifient les coordonnées (x, y) des coins du polygone. Le polygone est créé avec un centre en (100, 150) et les sommets spécifiés.

  
App().run()

Cela crée une instance de la classe App du module classeForme et exécute la méthode run. Cette méthode initialise une fenêtre Pygame, gère les événements, affiche la simulation physique, et exécute la boucle principale de la simulation jusqu'à ce que l'utilisateur ferme la fenêtre.

En résumé, le code crée une simulation physique simple avec une boîte statique (mur) et un polygone en utilisant Pymunk et Pygame. La classe App gère la simulation et l'interface utilisateur, tandis que les classes Box et Polygon définissent les objets physiques à simuler.

Création d'un Triangle Mobile

Le code suivant crée un triangle mobile

Exemple :      Copier le code

 
from classeForme import pymunk, space, App, Box, Polygon

Box()

sommets = [(100, 10), (150, 110), (80, 150)]
Polygon((100, 50), sommets )

App().run()

Le code fourni ici est très similaire à celui que nous avons présenté précédemment, mais cette fois, il crée un triangle mobile au lieu d'un carré. Voici une explication du code :

1. Tout d'abord, le code importe plusieurs classes et objets du module classeForme, y compris pymunk, space, App, Box, et Polygon.
2. Ensuite, il crée une instance de la classe Box(). Cette classe est responsable de la création d'un mur statique (rectangle) dans la simulation, comme expliqué précédemment.
3. La variable sommets est définie comme une liste de coordonnées de points (x, y) qui forment un triangle. Les points (100, 10), (150, 110), et (80, 150) définissent un triangle.
4. Ensuite, le code crée une instance de la classe Polygon avec le centre à (100, 50) et les sommets spécifiés dans la variable sommets. Cela crée un triangle mobile dans la simulation. Contrairement au rectangle statique, le triangle est mobile, ce qui signifie qu'il réagira aux forces et aux collisions.
5. Enfin, App().run() est appelé pour exécuter la simulation. La classe App gère l'interface utilisateur et la boucle principale de la simulation, comme expliqué précédemment. La simulation affichera le triangle mobile, qui pourra être affecté par la gravité ou d'autres forces définies dans l'environnement de la simulation.

En résumé, ce code crée une simulation physique avec un mur statique (boîte) et un triangle mobile en utilisant la bibliothèque Pymunk pour la simulation physique et Pygame pour l'interface utilisateur. Le triangle mobile réagira aux forces et aux collisions, ce qui lui permettra de bouger dans la simulation.

Création d'une courroie transporteuse

Le code crée une simulation d'une bande transporteuse avec deux segments ayant des vitesses de surface opposées. Un rectangle mobile est placé sur la bande, et sa dynamique est influencée par la friction et la vitesse de surface de la bande transporteuse. La simulation permet de visualiser comment les objets réagissent à ces paramètres physiques.

Exemple :      Copier le code

 
from classeForme import pymunk, space, App, Rectangle

space.gravity = (0, 1000)  # Exemple de gravité
b0 = space.static_body
shape = pymunk.Segment(b0, (20, 70), (500, 70), 10)
shape1 = pymunk.Segment(b0, (10, 120), (650, 100), 10)

shape.friction = 1000
shape1.friction = 1000
shape.surface_velocity = (10, 10)
shape1.surface_velocity = (-10, 10)
space.add(shape, shape1)

Rectangle((50, 20), (80, 10))

App().run()

Voici une explication du code :

1. Tout d'abord, le code importe des classes et des objets nécessaires depuis le module classeForme.
2. Il définit la gravité de l'environnement de la simulation à (0, 1000), ce qui signifie que les objets auront une force gravitationnelle vers le bas. Cela simule un exemple de gravité.
3. Un objet statique b0 est créé pour servir de base pour la bande transporteuse. Ensuite, deux segments tapi et tapi1 sont créés à partir du corps statique b0. Ces segments représentent la bande transporteuse elle-même. Le premier segment va de (20, 70) à (500, 70), et le deuxième va de (10, 120) à (650, 100). Les segments ont une largeur de 10 unités.
4. Les propriétés de friction des segments sont définies avec des valeurs élevées (friction = 1000), ce qui signifie qu'ils ont une forte friction pour les objets qui se déplacent sur eux.
5. La vitesse de surface (surface_velocity) des segments est également définie. Le segment tapi a une vitesse de surface de (10, 10) (déplacement vers la droite et vers le haut), tandis que tapi1 a une vitesse de surface de (-10, 10) (déplacement vers la gauche et vers le haut).
6. Les segments tapi et tapi1 sont ajoutés à l'espace de simulation.
7. Enfin, un rectangle mobile est créé à la position (50, 20) avec une taille de (80, 10) et ajouté à l'espace de simulation. Ce rectangle sera placé sur la bande transporteuse et réagira aux propriétés de la bande, notamment la vitesse de surface et la friction.
8. La classe App est utilisée pour exécuter la simulation. La boucle principale de la simulation gère l'interface utilisateur, les événements, la mise à jour de la physique et l'affichage de la simulation.

Création d'une articulation pivotante

Le code crée une simulation où un cercle est connecté à un point d'ancrage par une articulation pivotante, permettant ainsi au cercle de tourner autour du point d'ancrage en réponse à la simulation de la physique.

Exemple :      Copier le code

# articulation pivotante
from classeForme import pymunk, space, App, Box
Box()
b0 = space.static_body

body = pymunk.Body(mass=1, moment=10)
body.position = (100, 200)
cercle = pymunk.Circle(body, radius=25)

joint = pymunk.PivotJoint(b0, body, (200, 150))
space.add(body, cercle, joint)

App().run()

Ressort amorti

Le code crée une simulation où un cercle est attaché à un point d'ancrage par un ressort amorti. Le ressort essaie de maintenir sa longueur de repos, ce qui entraîne des oscillations du cercle autour du point d'ancrage en réponse à la simulation de la physique.

Exemple :      Copier le code

# articulation pivotante
from classeForme import pymunk, space, App, Box, Rectangle

b0 = space.static_body
p0 = 100, 200

body = pymunk.Body(mass=1, moment=10)
body.position = (100, 50)
circle = pymunk.Circle(body, radius=30)

joint = pymunk.DampedSpring(b0, body, p0, (0, 0), 100, 100, 0)
space.add(body, circle, joint)

App().run()

Cette fois-ci, au lieu d'une articulation pivotante simple, un "Damped Spring" (ressort amorti) est utilisé comme articulation. Il est créé avec les paramètres suivants :

• b0 : Le corps statique servant de point d'ancrage.
• body : Le corps dynamique auquel le ressort est attaché.
• p0 : La position du point d'ancrage sur le corps dynamique ((100, 200)).
• (0, 0) : La position du point d'ancrage sur le corps statique (point d'ancrage fixe).
• stiffness (100) : La raideur du ressort.
• damping (100) : L'amortissement du ressort.
• rest_length (0) : La longueur de repos du ressort (0 signifie qu'il essaie de maintenir sa longueur d'origine).