I can't Sprite Sheet an image (bugged)

Question

Hello I have an image of dimension 3840x1572 where there are 10 sequences on 2 lines so 5 sequences per line and I would like to had an animation, an explosion but that doesn’t work at all the image is buggythe image i want to sprite sheet in order to make an explosion

Basically i want that when a laser touch my character an explosion happen and that work but i get something like these: what i get here my code :

# Charger l'image contenant toutes les séquences de l'explosion
explosion_sheet = pygame.image.load("assets/img/explosion/explosion_sheet.png")
# Dimensions de l'image complète
sheet_width = 3840
sheet_height = 1572
# Nombre de séquences en largeur et en hauteur
sequences_per_row = 2
sequences_per_column = 5
# Dimensions d'une seule séquence de l'explosion
sequence_width = sheet_width // sequences_per_row
sequence_height = sheet_height // sequences_per_column
# Nouvelles dimensions  pour chaque séquence
new_sequence_width = 150
new_sequence_height = 150
# Créer une liste pour stocker les sous-images de chaque séquence
explosion_sequences = []
# Parcourir l'image et découper chaque séquence en une sous-image
for j in range(sequences_per_column):
    for i in range(sequences_per_row):
        x = i * sequence_width
        y = j * sequence_height
        sub_image = explosion_sheet.subsurface(pygame.Rect(x, y, sequence_width, sequence_height))
        resized_sub_image = pygame.transform.scale(sub_image, (new_sequence_width, new_sequence_height))
        explosion_sequences.append(resized_sub_image)
def show_explosion(x, y):
    for explosion_sequence in explosion_sequences:
        # Effacer l'écran avant d'afficher la nouvelle séquence  # Remplir l'écran avec du noir

        # Ajuster les coordonnées pour centrer l'explosion sur la grenouille
        explosion_x = x - (new_sequence_width // 2)
        explosion_y = y - (new_sequence_height // 2)
        SCREEN.blit(explosion_sequence, (explosion_x, explosion_y))
        pygame.display.update()
        pygame.time.delay(100)  # Délai de 100 millisecondes (0.1 seconde) entre chaque séquence

and if you need my entire code :

# Importation des modules nécessaires
import pygame
import sys
import time
import random

# Initialisation de Pygame
pygame.init()
pygame.font.init()

# Fonction pour réinitialiser le jeu
def reset_game():
    global X_POSITION, Y_POSITION, jumping, Y_VELOCITY, start_time, rocks, last_rock_time, current_level
    rocks = []  # Réinitialiser la liste des pierres
    last_rock_time = 0  # Réinitialiser le temps de la dernière pierre
    current_level = 0  # Réinitialiser le niveau actuel
    start_time = 0  # Réinitialiser le temps de départ

    X_POSITION, Y_POSITION = 200, 440  # Réinitialiser la position de la grenouille
    jumping = False  # Réinitialiser l'état de saut
    Y_VELOCITY = JUMP_HEIGHT  # Réinitialiser la vélocité verticale

# Initialisation de la police d'écriture et de l'horloge
my_font = pygame.font.SysFont('Comic Sans MS', 30)
CLOCK = pygame.time.Clock()

# Création de la fenêtre de jeu
SCREEN = pygame.display.set_mode((900, 550))

# Chargement et redimensionnement des images
start_bg = pygame.transform.scale(pygame.image.load("assets/img/background/start_bg.png"), (900, 550))
rock_img = pygame.transform.scale(pygame.image.load("assets/img/obstacle/rock.png"), (120, 120))
rock_img = pygame.transform.rotate(rock_img, 90)  # Rotation initiale de l'image de 90 degrés
snowball_img = pygame.transform.scale(pygame.image.load("assets/img/obstacle/snowball.png"), (120, 120))
snowball_img = pygame.transform.rotate(snowball_img, 90)  # Rotation initiale de l'image de 90 degrés
log_img = pygame.transform.scale(pygame.image.load("assets/img/obstacle/log.png"), (120, 120))
log_img = pygame.transform.rotate(log_img, 90)  # Rotation initiale de l'image de 90 degrés
laser_purple = pygame.transform.scale(pygame.image.load("assets/img/obstacle/laser-purple.png"), (220, 180))

# Chargement et redimensionnement des images de la grenouille
STANDING_SURFACE = pygame.transform.scale(pygame.image.load("assets/img/character/frog_run.png"), (48, 64))
JUMPING_SURFACE = pygame.transform.scale(pygame.image.load("assets/img/character/frog_jump.png"), (48, 64))

# Retournement des images de la grenouille
STANDING_SURFACE = pygame.transform.flip(STANDING_SURFACE, True, False)
JUMPING_SURFACE = pygame.transform.flip(JUMPING_SURFACE, True, False)

# Charger l'image contenant toutes les séquences de l'explosion
explosion_sheet = pygame.image.load("assets/img/explosion/explosion_sheet.png")
# Dimensions de l'image complète
sheet_width = 3840
sheet_height = 1572
# Nombre de séquences en largeur et en hauteur
sequences_per_row = 2
sequences_per_column = 5
# Dimensions d'une seule séquence de l'explosion
sequence_width = sheet_width // sequences_per_row
sequence_height = sheet_height // sequences_per_column
# Nouvelles dimensions  pour chaque séquence
new_sequence_width = 150
new_sequence_height = 150
# Créer une liste pour stocker les sous-images de chaque séquence
explosion_sequences = []
# Parcourir l'image et découper chaque séquence en une sous-image
for j in range(sequences_per_column):
    for i in range(sequences_per_row):
        x = i * sequence_width
        y = j * sequence_height
        sub_image = explosion_sheet.subsurface(pygame.Rect(x, y, sequence_width, sequence_height))
        resized_sub_image = pygame.transform.scale(sub_image, (new_sequence_width, new_sequence_height))
        explosion_sequences.append(resized_sub_image)
def show_explosion(x, y):
    for explosion_sequence in explosion_sequences:
        # Effacer l'écran avant d'afficher la nouvelle séquence  # Remplir l'écran avec du noir

        # Ajuster les coordonnées pour centrer l'explosion sur la grenouille
        explosion_x = x - (new_sequence_width // 2)
        explosion_y = y - (new_sequence_height // 2)
        SCREEN.blit(explosion_sequence, (explosion_x, explosion_y))
        pygame.display.update()
        pygame.time.delay(100)  # Délai de 100 millisecondes (0.1 seconde) entre chaque séquence
# Redimensionnement final des images de la grenouille
STANDING_SURFACE = pygame.transform.scale(STANDING_SURFACE, (70, 70))
JUMPING_SURFACE = pygame.transform.scale(JUMPING_SURFACE, (70, 70))

#initalisation 
rocks = []  # Liste des pierres
X_POSITION, Y_POSITION = 200, 440  # Position initiale de la grenouille
frog_size = (70, 70)  # Taille de la grenouille
jumping = False  # État initial de saut
game_started = False  # État initial du jeu
Y_GRAVITY = 0.6  # Gravité
JUMP_HEIGHT = 15.0  # Hauteur de saut
Y_VELOCITY = JUMP_HEIGHT  # Vélocité verticale initiale
frog_rect = STANDING_SURFACE.get_rect(center=(X_POSITION, Y_POSITION))  # Rectangle de la grenouille
score = 0  # Score initial
start_time = 0  # Temps de départ
pygame.display.set_caption("Froggy Hoop | Accueil")
last_rock_time = 0  # Temps de la dernière apparition d'une pierre
ROCK_DELAY = 850  # Délai en millisecondes entre chaque apparition de pierre
current_level = 0  # Niveau de départ
LEVEL_TIME = 3  # Temps en secondes pour passer au niveau suivant
OBSTACLE_IMAGES = [rock_img, rock_img, log_img, snowball_img, laser_purple]  # Ajoutez d'autres images si nécessaire

# Chargement des images de fond pour chaque niveau
BACKGROUND_IMAGES = [
    pygame.transform.scale(pygame.image.load("assets/img/background/background.jpg").convert(), (900, 550)),
    pygame.transform.scale(pygame.image.load("assets/img/background/background.jpg").convert(), (900, 550)),
    pygame.transform.scale(pygame.image.load("assets/img/background/background_forest.jpg").convert(), (900, 550)),
    pygame.transform.scale(pygame.image.load("assets/img/background/snowymountains.png").convert(), (900, 550)),
    pygame.transform.scale(pygame.image.load("assets/img/background/purple_background.png").convert(), (900, 550)),
]

# Boucle principale du jeu
while True:

    # Gestion des événements
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()

        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_SPACE:
                if not game_started:
                    game_started = True
                    start_time = time.time()

    keys_pressed = pygame.key.get_pressed()

    # Logique du jeu
    if game_started:

        # Génération aléatoire des obstacles
        current_time = pygame.time.get_ticks()
        if current_time - last_rock_time > ROCK_DELAY:
            if random.randint(1, 35) == 1:
                obstacle_img = OBSTACLE_IMAGES[current_level]  # Sélection de l'image d'obstacle correspondante
                if obstacle_img == laser_purple:
                   rock_x = 900  # Position initiale à droite de l'écran
                   rock_y = 320  # Position initiale sur le sol
                   rocks.append([rock_x, rock_y, obstacle_img])  # Ajout de l'image d'obstacle à la liste des roches
                   last_rock_time = current_time  # Mise à jour du temps de la dernière apparition
                else:
                 rock_x = 900  # Position initiale à droite de l'écran
                 rock_y = 350  # Position initiale sur le sol
                 obstacle_img = OBSTACLE_IMAGES[current_level]  # Sélection de l'image d'obstacle correspondante
                 rocks.append([rock_x, rock_y, obstacle_img])  # Ajout de l'image d'obstacle à la liste des roches
                 last_rock_time = current_time  # Mise à jour du temps de la dernière apparition

        # Déplacement des obstacles
        rocks_to_remove = []
        for i, rock in enumerate(rocks):
            rock_x, rock_y, obstacle_img = rock
            if obstacle_img == laser_purple:
                rock_x -= 13
            else:
                rock_x -= 10  # Déplacement horizontal vers la gauche

            rocks[i] = [rock_x, rock_y, obstacle_img]

            # Ajouter les obstacles à supprimer à la liste temporaire
            if rock_x < -100:
                rocks_to_remove.append(rock)

        # Suppression des obstacles sorties de l'ecran
        for rock in rocks:
            if rocks[0][0] == -150:
                rocks.remove(rock)

        # Détection des collisions avec les obstacles
        for rock in rocks:
            rock_x, rock_y, obstacle_img = rock
            if frog_rect.colliderect(obstacle_img.get_rect(topleft=(rock_x, rock_y))):
                if obstacle_img == laser_purple:
                    for rock in rocks:
                     rocks.remove(rock)
                    # Obtenir les coordonnées de la grenouille
                    frog_x = frog_rect.x
                    frog_y = frog_rect.y
                    show_explosion(frog_x, frog_y)  # Appel de la fonction d'explosion avec les coordonnées de la grenouille
                game_started = False
                print("Collision avec un obstacle !")
                reset_game()

        # Calcul du temps écoulé
        elapsed_time = int(time.time() - start_time)
        time_text = my_font.render("Temps Ecouler : " + str(elapsed_time) + " s", True, (0, 255, 0))

        # Vérification du changement de niveau
        if elapsed_time >= current_level * LEVEL_TIME:
            if elapsed_time >= current_level * LEVEL_TIME:
                current_level = min(current_level + 1, len(BACKGROUND_IMAGES) - 1)

        # Affichage du titre de la fenêtre de jeu
        if game_started:
            pygame.display.set_caption("Froggy Hoop | Jeux en cours : " + str(elapsed_time) + " s")
        if game_started == False:
            pygame.display.set_caption("Froggy Hoop | Accueil")

        # Gestion du saut
        if keys_pressed[pygame.K_SPACE]:
            jumping = True

        # Affichage des éléments
        SCREEN.blit(BACKGROUND_IMAGES[current_level], (0, 0))

        if jumping:
            Y_POSITION -= Y_VELOCITY
            Y_VELOCITY -= Y_GRAVITY
            if Y_VELOCITY < -JUMP_HEIGHT:
                jumping = False
                Y_VELOCITY = JUMP_HEIGHT
                Y_POSITION = 440
            frog_rect = JUMPING_SURFACE.get_rect(center=(X_POSITION, Y_POSITION))
            SCREEN.blit(JUMPING_SURFACE, frog_rect)
        else:
            frog_rect = STANDING_SURFACE.get_rect(center=(X_POSITION, Y_POSITION))
            SCREEN.blit(STANDING_SURFACE, frog_rect)

        SCREEN.blit(time_text, (10, 10))

        # Affichage des obstacles
        for rock in rocks:
            rock_x, rock_y, obstacle_img = rock
            if obstacle_img == laser_purple:
                SCREEN.blit(obstacle_img, (rock_x, rock_y))
            else:
                rotated_obstacle_img = pygame.transform.rotate(obstacle_img, -rock[0] % 255)
                SCREEN.blit(rotated_obstacle_img, (rock_x, rock_y))

    # Affichage de l'écran de démarrage
    else:
        SCREEN.blit(start_bg, (0, 0))

    # Mise à jour de l'affichage
    pygame.display.update()
    CLOCK.tick(60)