diff --git a/test2.c b/test2.c
new file mode 100644
index 0000000..e7e2a8a
--- /dev/null
+++ b/test2.c
@@ -0,0 +1,240 @@
+#include<SDL/SDL.h>
+#include<SDL/SDL_ttf.h>
+#include"Graphique/libgraph.h"
+#include<stdbool.h>
+#include "main.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+static SDL_Surface *surface;
+
+int vaisseauID = -1;
+int envahisseurID = -1;
+int missileID = -1;
+int bombeID = -1;
+
+
+void initListe(listeEntites* liste) {
+    liste->tete = NULL;
+}
+
+
+void ajouterEntite(listeEntites* liste, int x, int y, int type, int etat) {
+    entite* nouvelleEntite = (entite*)malloc(sizeof(entite));
+    if (!nouvelleEntite) {
+        fprintf(stderr, "Erreur : impossible d'allouer la mémoire pour une nouvelle entité.\n");
+        exit(EXIT_FAILURE);
+    }
+    nouvelleEntite->x = x;
+    nouvelleEntite->y = y;
+    nouvelleEntite->type = type;
+    nouvelleEntite->etat = etat;
+    nouvelleEntite->suivante = liste->tete;
+    liste->tete = nouvelleEntite;
+    printf("Ajouté entité de type %d à (%d, %d)\n", type, x, y);
+}
+
+
+void initEnvahisseurs(listeEntites* liste, int nbEnvahisseurs, int y) {
+    for (int i = 0; i < nbEnvahisseurs; i++) {
+        ajouterEntite(liste, i * 40, y, 1, 1); // Type 1 pour envahisseur
+    }
+    printf("Initialisé %d envahisseurs à la position y = %d\n", nbEnvahisseurs, y);
+}
+
+
+void initVaisseau(entite* vaisseau, int x, int y) {
+    vaisseau->x = x;
+    vaisseau->y = y;
+    vaisseau->type = 0;
+    vaisseau->etat = 1;
+    vaisseau->suivante = NULL;
+    printf("Initialisé vaisseau à (%d, %d)\n", x, y);
+}
+
+
+void deplacerEnvahisseurs(listeEntites* envahisseurs, int largeurEcran, int* direction, bool* bordAtteint) {
+    entite* courant = envahisseurs->tete;
+    while (courant != NULL) {
+        courant->x += *direction * 10;
+
+
+        if (courant->x <= 0 || courant->x >= largeurEcran - 40) {
+            *bordAtteint = true;
+        }
+
+        courant = courant->suivante;
+    }
+
+
+    if (*bordAtteint) {
+        *direction = -*direction;
+        courant = envahisseurs->tete;
+        while (courant != NULL) {
+            courant->y += 10;
+            courant = courant->suivante;
+        }
+        *bordAtteint = false;
+        printf("Les envahisseurs ont changé de direction\n");
+    }
+}
+
+
+void gererEntrees(entite* vaisseau, listeEntites* missiles) {
+    const Uint8* etatClavier = SDL_GetKeyState(NULL);
+
+    if (etatClavier[SDLK_LEFT]) {
+        vaisseau->x -= 10;
+    }
+    if (etatClavier[SDLK_RIGHT]) {
+        vaisseau->x += 10;
+    }
+    if (etatClavier[SDLK_SPACE]) {
+
+        ajouterEntite(missiles, vaisseau->x + 20, vaisseau->y - 10, 2, 1);
+        printf("Missile tiré à (%d, %d)\n", vaisseau->x + 20, vaisseau->y - 10);
+    }
+}
+
+
+bool collision(entite* a, entite* b) {
+    return (a->x < b->x + 40 &&
+            a->x + 40 > b->x &&
+            a->y < b->y + 40 &&
+            a->y + 40 > b->y);
+}
+
+entite* collisionAvecListe(entite* ent, listeEntites* liste) {
+    entite* courant = liste->tete;
+    while (courant != NULL) {
+        if (collision(ent, courant)) {
+            return courant;
+        }
+        courant = courant->suivante;
+    }
+    return NULL;
+}
+
+
+int chargerSprites() {
+    vaisseauID = chargerLutin("invader_canon.bmp", 0);
+    envahisseurID = chargerLutin("invader_monstre1_1.bmp", 1);
+    missileID = chargerLutin("invader_missile.bmp", 2);
+    bombeID = chargerLutin("invader_bombe.bmp", 3);
+
+    if (vaisseauID < 0) {
+        fprintf(stderr, "Erreur : échec du chargement du lutin vaisseau.\n");
+        return 0;
+    }
+    if (envahisseurID < 0) {
+        fprintf(stderr, "Erreur : échec du chargement du lutin envahisseur.\n");
+        return 0;
+    }
+    if (missileID < 0) {
+        fprintf(stderr, "Erreur : échec du chargement du lutin missile.\n");
+        return 0;
+    }
+    if (bombeID < 0) {
+        fprintf(stderr, "Erreur : échec du chargement du lutin bombe.\n");
+        return 0;
+    }
+    printf("Sprites chargés avec succès\n");
+    return 1;
+}
+
+
+void afficherEntite(entite* ent) {
+    int lutinID;
+    switch (ent->type) {
+        case 0: lutinID = vaisseauID; break;
+        case 1: lutinID = envahisseurID; break;
+        case 2: lutinID = missileID; break;
+        case 3: lutinID = bombeID; break;
+        default:
+            fprintf(stderr, "Erreur : type de lutin inconnu %d.\n", ent->type);
+            return;
+    }
+    afficherLutin(lutinID, ent->x, ent->y);
+    printf("Affichage de l'entité de type %d à (%d, %d)\n", ent->type, ent->x, ent->y);
+}
+
+
+int main() {
+    if (!creerSurface(800, 600, "Space Invaders")) {
+        fprintf(stderr, "Erreur lors de la création de la surface graphique.\n");
+        return EXIT_FAILURE;
+    }
+
+    if (!chargerSprites()) {
+        fprintf(stderr, "Erreur lors du chargement des sprites.\n");
+        fermerSurface();
+        return EXIT_FAILURE;
+    }
+
+   listeEntites envahisseurs;
+   listeEntites missiles;
+    initListe(&envahisseurs);
+   initListe(&missiles);
+
+    entite vaisseau;
+    initVaisseau(&vaisseau, 380, 550);
+
+    initEnvahisseurs(&envahisseurs, 10, 50);
+
+    int direction = 1;
+    bool bordAtteint = false;
+
+
+
+while(!getchar())
+{
+    deplacerEnvahisseurs(&envahisseurs, 800, &direction, &bordAtteint);
+    entite* missile = missiles.tete;
+        while (missile != NULL) {
+            entite* cible = collisionAvecListe(missile, &envahisseurs);
+            if (cible != NULL) {
+                missile->etat = 0;
+                cible->etat = 0;
+                printf("Collision détectée entre missile et envahisseur\n");
+            }
+            missile = missile->suivante;
+        }
+
+
+
+
+
+
+        entite* courant = envahisseurs.tete;
+        while (courant != NULL) {
+            if (courant->etat == 1) {
+                afficherEntite(courant);
+            }
+            courant = courant->suivante;
+        }
+
+        if (vaisseau.etat == 1) {
+            afficherEntite(&vaisseau);
+        }
+
+        missile = missiles.tete;
+        while (missile != NULL) {
+            if (missile->etat == 1) {
+                afficherEntite(missile);
+            }
+            missile = missile->suivante;
+        }
+
+        SDL_Flip(surface);
+    }
+
+    fermerSurface();
+    return 0;
+
+
+}
+// calcul de collision entre l'ensemble des missiles et la liste d'entité
+
+
+
+
--
libgit2 0.21.2