[C/SDL/SGDK] Le bouzin du Kane

[Top l'âne]

Comme souligné en rubrique présentation, je rejoins la communauté Gamopat à la faveur de cette section création/programmation qui a vivement
suscité mon intérêt. Des cours, des WIP, des passionnés, tout cela m'a paru fort attrayant.

En l'état je me suis lancé dans l'apprentissage du C dans le courant de l'été dernier par l'intermédiaire des cours disponibles sur OpenClassroom.
J'avais initialement en ligne de mire le développement sur Megadrive mais je décide de ne point trop brûler les étapes et commence simplement
par me forger des bases sous SDL, d'autant que mes compétences en informatique sont globalement sommaires.
J'ai cependant trempé dans plusieurs champs créatifs, quoi que toujours en amateur. Dessin, peinture, narration, musique, vidéo, stop-motion.
Autant d'acquis favorables à la création d'un jeu vidéo.


Ce topic aura pour vocation de présenter divers travaux réalisés dans le cadre de mon apprentissage. Une sorte de book en somme.
Une initiative pas du tout désintéressée puisque j'aimerai, concrètement, mettre la main sur une petite équipe de dév orientée rétro.
Je réside dans le 60.

Ceci étant dit, et vu que j'ai un peu de temps devant moi cette semaine, j'inaugure ce topic avec le premier programme de mon crû:





Il s'agit d'une courte aventure textuelle conçue sur les bases du C (outre l'usage du random) et donc en affichage console.
Je n'ai pas fourni d'effort particulier sur l'aspect narratif, ce qui est forcément un tort pour ce genre de soft, mais là n'était pas le propos.
J'avais été plutôt satisfait de parvenir à retranscrire plusieurs aspects du RPG.
-Une vingtaine de lieux à visiter agencés en structure de poupée russe.
-Des portes et des clés nécessitant la découverte de la map.
-Une fonction de combat sommaire, qui appelle un bestiaire pour random l'un des trois ennemis différents.
-et donc un système de PV et... un game over.
-Des PNJ qui dispensent infos ou soins.

La progression reste très directive puisque la seule interaction avec le joueur reste l'entrée d'une valeur par le biais d'un menu d'action.

Tout ça n'est sans doute pas bien folichon à regarder pour vous, mais vous comprendrez l'affection que je porte à ce petit programme, le tout premier à être intégralement sorti de ma caboche, et ce au bout de 18 jours de cours. Un résultat stimulant pour le noob que je suis.^^

[F.L]

hello citizen kane et bienvenue sur le forum et aussi dans le monde de la programmation !
c'est sympa de nous montrer ton premier programme : il n'y a pas de honte à avoir, c'est deja bien d'avoir fait quelque chose qui marche.
maintenant si tu veux aller crescendo, grace aux cours de openclassroom (j'ai du mal avec leur nouveau nom : j'aimais bien le site du zero moi ) essaye de faire un petit jeu genre pac man ou autre, ça fait deja un beau challenge
bon courage pour la suite

[Top l'âne]

Salut FL.

Je n'ai pas honte du tout... Je suis même vachement fier en fait.
Encore que je vous ai passé sous silence l'affreux bug qui survient si un user plus main que les autres décide d'entrer autre chose qu'un chiffre dans un menu.^^

Ce qui m'a motivé avec le cursus d'openclassroom c'est notamment la section "création d'un jeu 2D" et j'aurai là aussi deux petites choses à vous présenter.

Mais avant ça, une autre petite production et qui découle de ce premier essai. Une simple succession de combats. (sans bug celui là^^).

Une fois encore le bestiaire random un ennemi (avec cette fois une variation des pv en plus de la force).

Il s'agissait cette fois de simuler la gestion d'un inventaire (items de soins et d'attaque).
A chaque victoire on loot un item au hasard.


L'autre intérêt étant d'amener un gameplay par entrée de mots et pas simplement de chiffres.
J'avais bien évidemment en tête d'approfondir ainsi les fonctionnalités et le gameplay de l'aventure textuelle.

Mais finalement je ne me suis pas donné le temps de le faire, tout pressé que j'étais de mettre un pied dans la SDL. :p

Donc, dans la prochaine vidéo, adieu affichage console, bonjour fenêtre et sprites!

[dub]

Effectivement, c'est sympa pour un premier pas dans l'informatique. Ca me rappel les livres dont vous êtes le héro. Et puis passer sur un analyseur syntaxique pour débuter, chapeau.
J'ai hâte de voir tes productions graphiques.

Vivement une version physique pour qu'on se fasse écraser par des motards

[tfdi]

+1

On se croirait sur un livre dont vous êtes le héros, oui :)

Bienvenu dans le monde de la programmation

[Top l'âne]

On peut faire des citations multiples ici?

@tfdi: effectivement on m'a fait plusieurs retours livre-dont-vous-êtes-le-héros-esque.
L'esprit reste forcément très similaire aux jeux textuels d'époque que j'avais plutôt en tête alors.

@dub: utiliser un analyseur syntaxique. Bé en fait je ne me suis pas posé la question sur le moment.^^
J'ai juste suivi la progression des cours en me demandant ce que je pouvais faire en terme de jeu que j'aime avec les acquis. Et vu qu'on a commencé par m'apprendre à manipuler du texte...
A dire vrai j'avais même commencé à plancher sur un Versus-Fighting textuel.

Mais la SDL fût.

Ma première rencontre avec la SDL concerne le fameux TP Mario Sokoban diffusé encore une fois sur Openclassroom.
Dix jours d'intense frénésie à réaliser ce TP, couronnés d'une amère déception... :p
Le programme s'exécute jusqu'au menu, mais impossible de lancer l'éditeur de map, et donc une partie.
Comme j'ai peu d'attrait pour le Sokoban, je décidai d'en rester là, conservant toutefois les nombreux acquis inhérent au montage d'un projet complet et que je décidais de mettre à profit pour la mise en place d'un jeu qui m'inspire davantage.

Pacman m'ayant bien effleuré l'esprit FL, mais mon choix se portait sur la programmation d'un autre classique de l'arcade, Space Invaders, cause que, outre balancer des grenades sur des motards, j'aime aussi repousser des hordes d'aliens à coups de giclées de plasma.

Ce fut l'occasion d'aborder la gestion des collisions.
Je suis parti d'un petit exercice de mise en place dans lequel je lance deux sprites l'un contre l'autre, j'ai voulu en profité pour m'initier à la mise en place d'une ambiance graphique (paint).

Il en résulte une petite démo bâtarde sur une dizaine d'heures, que j'ai appréhendé à la fois comme une petite intro de jeu et un trailer:




Camstudio me bouffe une partie des pages de présentation dans les cinq premières secondes, mais ce n'est pas bien important.
Par ailleurs l'image rend vraiment crade. C'est trop flou par rapport à l'original. Mais là aussi je débute avec les logiciels de capture d'écran, donc je ne sais pas proposer mieux pour l'instant.
Pas de son non plus, je n'ai pas encore abordé ce chapitre, mais forcément ça finirait d'assoir la séquence.

[Top l'âne]

Pour conclure mon introduction à la programmation voici le dernier de mes ouvrages, une démo jouable de Space Invaders:



Pour faire échos à la version originale j'ai bridé le tir. Un seul à la fois. J'ai également retranscrit l'accélération des ennemis en fonction de leur destruction.

A savoir que je m'étais fixé un délai de réa d'un mois soit une trentaine d'heures.
Je suis content d'avoir pu, dans ce laps de temps, établir l'essence du jeu.
J'aurai pu en faire davantage mais j'ai parfois perdu du temps sur des âneries.
Typiquement, quatre jours pour trouver comment envoyer un tableau à une fonction, la noobitude dans toute sa gloire.  
Surtout que je ne me facilite pas la vie puisque je vis sans internet... Donc quand je suis dans la merde, je suis dans la merde... Tout seul.

Globalement je ne suis pas mécontent de mes pages de code. Je me suis efforcé de rendre quelque chose de propre et aéré.
Quelques petites choses à parfaire toutefois, comme une fonction d'init des sprites ou une fonction de blit. Ah, et l'animation du dégradé du menu. Pourtant je suis sûr que c'est un truc alakon.

Par contre y a un truc vraiment dégueu dans mon code, une grosse verrue indigeste, la fonction d'animation de la vague d'alien. Je n'ai pas réussis à faire quelque chose de simple, en gros j'ai un sale pavé qui scripte les déplacements ligne par ligne. Ce qui m'a contraint à construire une seconde fonction presque aussi moche pour la mise à jour de la vague après des destructions.

Les bons tuyaux sont les bienvenus, je ne vous le cache pas.

Je pensais d'abord en resté là pour le Space Invaders, parce que je suis plutôt pressé d'aller voir un peu les tutos sur la décomposition de l'animation et le scrolling, mais après réflexion, je pense que je vais plutôt boucler cette démo. D'une part ce sera gratifiant, et d'autre part j'entrevois des éléments qui vont me poser problème, donc bon exercice. :)
Pas de scoring en vue, mais plutôt un Wave Survival. Ajout des cités de défense et des tirs ennemis.
Et un minimum de son aussi, ça serait pas mal.^^

[Top l'âne]

Le Space Invaders avance...
En fait je pensais même en avoir terminé car j'avais 100% de réussite en debug sur la machine qui me sert à compiler, mais quand j'ai voulu partager l'exe je me suis vu harcelé par des bugs.
 Demie victoire seulement, donc un peu déçu, mais je poursuis le travail de correction, voire même je vais tout reprendre, attendu que le fait de pousser le projet m'a ouvert de nouvelles perspectives de simplification, mais qui m'obligent à tout reprendre du début. Aaargh!


Enfin bon, histoire de changer un peu d'air j'ai voulu me pencher sur la prog MD. Le but initial de ma plongée dans la prog. Grosse galère pour l'install/mise en place de SGDK via code block, mais finalement j'ai trouvé mon salut sur un forum canadien avec un beau tuto qui mâche tout le boulot.^^
J'ai pu commencer à me pencher sur la doc. Ounch! La SDL c'est Oui-oui à la plage à côté de ça.

Résultat:



Ca m'a refilé la banane pour la semaine, je vous jure.
Bref, un beau chantier pour 2016.



Avant de filer je reviens un poil sur le Space invaders sous SDL.
Grosso modo j'ai un bug sur la première vague d'aliens.  Mais une fois que c'est lancé ça parait relativement conforme à mes attentes.
Je laisse mon jeu.c à l'attention des âmes charitables de passage qui voudraient jeter un oeil.
Loin de moi l'idée de vous tanner avec une correction scolaire, simplement j'aimerai un avis global.
Y a t'il des erreurs bêtes et méchantes à éviter dans l'élaboration d'un code, voire des hérésies propres à modifier la nature du continuum espace temps?

Je vous le laisse quasi brut, j'ai laissé quelques annotations ici et là:


[hide]#include
#include
#include
#include

#include "constantes.h"
#include "jeu.h"
#include "intro.h"



int continuer (int entree)//conditionne la fermeture du programme
{
    static int continuer = 1;

    continuer = continuer - entree;

    return continuer;

}

int boucle_jeu (int entree)//conditionne le game over
{
    static int b_jeu = 0;

    b_jeu = b_jeu - entree;

    return b_jeu;
}

void jouer (SDL_Surface *ecran)
{
    SDL_Surface *tank = NULL, *shot = NULL, *boom = NULL,
    *sol = NULL, *cache = NULL, *alien_shot = NULL, *alien_shot_2 = NULL,
    *alien_shot_3 = NULL,
    *cite_1[5] = {NULL}, *cite_2[5] = {NULL}, *cite_3[5] = {NULL}, *cite_4[5] = {NULL},
    *alien[11][5] = {{NULL},{NULL}},
    *wave1 = NULL, *wave2 = NULL, *wave3 = NULL, *wave4 = NULL,
     *wave5 = NULL, *wave6 = NULL, *wave7 = NULL, *wave8 = NULL, *wave9 = NULL,
      *wave10 = NULL;

    SDL_Rect p_tank, p_shot, p_sol, p_cache, p_alien_shot, p_alien_shot_2,
    p_alien_shot_3,
    p_cite_1[5], p_cite_2[5], p_cite_3[5], p_cite_4[5],
    p_alien[11][5],
    p_wave;

    int jeton = 0, arret = 1, on = -1, i = 0, j = 0, compteur_temps = 0,
    temps_precedent = 0, temps_actuel = 0,
    vie_cite1[5] = {0}, vie_cite2[5] = {0}, vie_cite3[5] = {0},
    vie_cite4[5] = {0},
    vie_alien[11][5]={{0},{0}};


    static int retro_wave = 0, boucle = 1;//boucle conditionne la victoire sur une vague ennemie

    init_vie_alien(vie_alien);
    init_vie_cite(vie_cite1, vie_cite2, vie_cite3, vie_cite4);
    init_pos(&p_tank, &p_sol, &p_cache, &p_shot, p_alien, &p_wave);
    init_cite_pos(p_cite_1, p_cite_2, p_cite_3, p_cite_4);
    init_wave(&wave1, &wave2, &wave3, &wave4, &wave5, &wave6,
              &wave7, &wave8, &wave9, &wave10);


    for (i = 0; i < 11; i ++)
    {
        for (j = 0; j < 5; j ++)
        {

            alien[i][j] = SDL_LoadBMP("ennemy.bmp");
            SDL_SetColorKey(alien[i][j], SDL_SRCCOLORKEY, SDL_MapRGB(alien[i][j]->format, 0, 0, 255));
        }
    }


    SDL_Event event;


    SDL_TimerID t_shot;
    SDL_TimerID t_alien_shot;
    SDL_TimerID t_alien_shot_2;
    SDL_TimerID t_alien_shot_3;

    init_surface(&tank, &shot, &sol, &cache, &alien_shot, &alien_shot_2,
                 &alien_shot_3, &boom);

    SDL_SetColorKey(tank, SDL_SRCCOLORKEY, SDL_MapRGB(tank->format, 0, 0, 255));


    SDL_SetColorKey(boom, SDL_SRCCOLORKEY, SDL_MapRGB(boom->format, 0, 0, 255));



    for(i = 0; i < 5; i ++)
    {
        cite_1[i] = SDL_LoadBMP("brick.bmp");
        cite_2[i] = SDL_LoadBMP("brick.bmp");
        cite_3[i] = SDL_LoadBMP("brick.bmp");
        cite_4[i] = SDL_LoadBMP("brick.bmp");
    }


     /*init_wave(ecran);*/
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
    switch (wave(jeton))
        {
        case 1:
            SDL_BlitSurface(wave1, NULL, ecran, &p_wave);
            break;
        case 2:
            SDL_BlitSurface(wave2, NULL, ecran, &p_wave);
            break;
        case 3:
            SDL_BlitSurface(wave3, NULL, ecran, &p_wave);
            break;
        case 4:
            SDL_BlitSurface(wave4, NULL, ecran, &p_wave);
            break;
        case 5:
            SDL_BlitSurface(wave5, NULL, ecran, &p_wave);
            break;
        case 6:
            SDL_BlitSurface(wave6, NULL, ecran, &p_wave);
            break;
        case 7:
            SDL_BlitSurface(wave7, NULL, ecran, &p_wave);
            break;
        case 8:
            SDL_BlitSurface(wave8, NULL, ecran, &p_wave);
            break;
        case 9:
            SDL_BlitSurface(wave9, NULL, ecran, &p_wave);
            break;
        case 10:
            SDL_BlitSurface(wave10, NULL, ecran, &p_wave);
            break;
        }

        SDL_Flip(ecran);

        SDL_Delay(2000);



    SDL_EnableKeyRepeat(3,3);


    t_shot = SDL_AddTimer (1, tir, &p_shot);
    t_alien_shot = SDL_AddTimer (4, tir_alien, &p_alien_shot);
    t_alien_shot_2 = SDL_AddTimer (4, tir_alien_2, &p_alien_shot_2);
    t_alien_shot_3 = SDL_AddTimer (4, tir_alien_3, &p_alien_shot_3);


    if(tir_alien_actuel(jeton) == 0)
        tir_alien_actuel(on);
    if(tir_alien_actuel_2(jeton) == 0)
        tir_alien_actuel_2(on);
    if(tir_alien_actuel_3(jeton) == 0)
        tir_alien_actuel_3(on);







    while ((continuer(jeton)) == 1 && (boucle_jeu(jeton)) == 1 && (boucle == 1))
    {

        SDL_PollEvent(&event);
        switch(event.type)
        {
        case SDL_QUIT:
            continuer(arret);
            break;

        case SDL_KEYDOWN:
            switch(event.key.keysym.sym)
            {
            case SDLK_ESCAPE:
                continuer(arret);
                break;
            case SDLK_LEFT:
                p_tank.x--;
                break;
            case SDLK_RIGHT:
                p_tank.x++;
                if (p_tank.x > 768)
                    p_tank.x = 768;
                break;
            case SDLK_SPACE:

                if (tir_on(jeton) == 1)
                {

                p_shot.y = 533;
                p_shot.x = p_tank.x + SPRITE/2;


                tir_on(arret);


                }

                else if (p_shot.y == 0)
                {
                tir_on(on);
                }

                /*else if (collision(p_shot, p_ennemy) == 1)
                {
                    p_shot.x = 0;
                    p_shot.y = 0;
                }*/


                break;
            }
            break;
        }
       
        //gestion deplacement de la vague alien
       
        temps_actuel = SDL_GetTicks();

        gestion_ennemy(p_alien, vie_alien, &compteur_temps, &temps_actuel,
                          &temps_precedent);
        if(p_alien_shot.y > 600 && tir_alien_actuel(jeton) == 0)
        tir_alien_actuel(on);
        gestion_tir_alien(&p_alien_shot, p_alien, vie_alien);

        if(p_alien_shot_2.y > 600 && tir_alien_actuel_2(jeton) == 0)
        tir_alien_actuel_2(on);
        gestion_tir_alien_2(&p_alien_shot_2, p_alien, vie_alien);

        if(p_alien_shot_3.y > 600 && tir_alien_actuel_3(jeton) == 0)
            tir_alien_actuel_3(on);
            gestion_tir_alien_3(&p_alien_shot_3, p_alien, vie_alien);

        //tests de collision

        if (col_tank1(p_tank, p_alien_shot) == 1)
            boucle_jeu(arret);
        if (col_tank2(p_tank, p_alien_shot_2) == 1)
            boucle_jeu(arret);
        if (col_tank3(p_tank, p_alien_shot_3) == 1)
            boucle_jeu(arret);

        if (col_shot1(p_shot, p_alien_shot) == 1)
        {
            p_shot.y = 0;
            p_alien_shot.y = 600;
        }
        if (col_shot2(p_shot, p_alien_shot_2) == 1)
        {
            p_shot.y = 0;
            p_alien_shot_2.y = 600;
        }
        if (col_shot3(p_shot, p_alien_shot_3) == 1)
        {
            p_shot.y = 0;
            p_alien_shot_3.y = 600;
        }

        for (i = 0; i < 5; i ++)
        {
            if (col_cite1a(p_cite_1[i], p_alien_shot) == 1 && vie_cite1[i] == 0)
            {
                vie_cite1[i] = 1;
                p_alien_shot.y = 600;
            }
            if (col_cite1b(p_cite_1[i], p_alien_shot_2) == 1 && vie_cite1[i] == 0)
            {
                vie_cite1[i] = 1;
                p_alien_shot_2.y = 600;
            }
            if (col_cite1c(p_cite_1[i], p_alien_shot_3) == 1 && vie_cite1[i] == 0)
            {
                vie_cite1[i] = 1;
                p_alien_shot_3.y = 600;
            }


            if (col_cite2a(p_cite_2[i], p_alien_shot) == 1 && vie_cite2[i] == 0)
            {
                vie_cite2[i] = 1;
                p_alien_shot.y = 600;
            }
            if (col_cite2b(p_cite_2[i], p_alien_shot_2) == 1 && vie_cite2[i] == 0)
            {
                vie_cite2[i] = 1;
                p_alien_shot_2.y = 600;
            }
            if (col_cite2c(p_cite_2[i], p_alien_shot_3) == 1 && vie_cite2[i] == 0)
            {
                vie_cite2[i] = 1;
                p_alien_shot_3.y = 600;
            }


            if (col_cite3a(p_cite_3[i], p_alien_shot) == 1 && vie_cite3[i] == 0)
            {
                vie_cite3[i] = 1;
                p_alien_shot.y = 600;
            }
            if (col_cite3b(p_cite_3[i], p_alien_shot_2) == 1 && vie_cite3[i] == 0)
            {
                vie_cite3[i] = 1;
                p_alien_shot_2.y = 600;
            }
            if (col_cite3c(p_cite_3[i], p_alien_shot_3) == 1 && vie_cite3[i] == 0)
            {
                vie_cite3[i] = 1;
                p_alien_shot_3.y = 600;
            }

            if (col_cite4a(p_cite_4[i], p_alien_shot) == 1 && vie_cite4[i] == 0)
            {
                vie_cite4[i] = 1;
                p_alien_shot.y = 600;
            }
            if (col_cite4b(p_cite_4[i], p_alien_shot_2) == 1 && vie_cite4[i] == 0)
            {
                vie_cite4[i] = 1;
                p_alien_shot_2.y = 600;
            }
            if (col_cite4c(p_cite_4[i], p_alien_shot_3) == 1 && vie_cite4[i] == 0)
            {
                vie_cite4[i] = 1;
                p_alien_shot_3.y = 600;
            }

        }
       
        //blit des surfaces

      SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

        for (i = 0; i < 5; i ++)
        {
            if (vie_cite1[i] == 0)
            SDL_BlitSurface(cite_1[i], NULL, ecran, &p_cite_1[i]);
            if (vie_cite2[i] == 0)
            SDL_BlitSurface(cite_2[i], NULL, ecran, &p_cite_2[i]);
            if (vie_cite3[i] == 0)
            SDL_BlitSurface(cite_3[i], NULL, ecran, &p_cite_3[i]);
            if (vie_cite4[i] == 0)
            SDL_BlitSurface(cite_4[i], NULL, ecran, &p_cite_4[i]);
        }



         for (i = 0; i < 11; i ++)
      {
          for (j = 0; j < 5; j ++)
          {
      if (collision(p_shot, p_alien[i][j]) == 0 && vie_alien[i][j] /* != 1*/ == 0)
      {

              SDL_BlitSurface(alien[i][j], NULL, ecran, &p_alien[i][j]);

       }

      else if (collision(p_shot, p_alien[i][j]) == 1 && vie_alien[i][j] /* != 1*/ == 0)
      {

          SDL_BlitSurface(boom, NULL, ecran, &p_alien[i][j]);


          vie_alien[i][j] = 1;
          p_shot.y = 0;
          compteur_temps++;
          if (compteur_temps == 55)
          {
              wave(arret);
              retro_wave--;




              boucle = 0;
          }

      }
          }
      }

      SDL_BlitSurface(shot, NULL, ecran, &p_shot);
      SDL_BlitSurface(tank, NULL, ecran, &p_tank);
      SDL_BlitSurface(sol, NULL, ecran, &p_sol);
      SDL_BlitSurface(cache, NULL, ecran, &p_cache);
      SDL_BlitSurface(alien_shot, NULL, ecran, &p_alien_shot);
      SDL_BlitSurface(alien_shot_2, NULL, ecran, &p_alien_shot_2);
      SDL_BlitSurface(alien_shot_3, NULL, ecran, &p_alien_shot_3);







      SDL_Flip(ecran);


    }

    SDL_Delay(2000);



    SDL_FreeSurface(tank);

    SDL_FreeSurface(shot);
    SDL_FreeSurface(boom);
    SDL_FreeSurface(sol);
    SDL_FreeSurface(cache);
    SDL_FreeSurface(alien_shot);
    SDL_FreeSurface(alien_shot_2);
    SDL_FreeSurface(alien_shot_3);


    for (i = 0; i < 5; i ++)
    {
        SDL_FreeSurface(cite_1[i]);
        SDL_FreeSurface(cite_2[i]);
        SDL_FreeSurface(cite_3[i]);
        SDL_FreeSurface(cite_4[i]);
    }



    SDL_RemoveTimer(t_shot);
    SDL_RemoveTimer(t_alien_shot);
    SDL_RemoveTimer(t_alien_shot_2);
    SDL_RemoveTimer(t_alien_shot_3);


    for (i = 0; i < 11; i ++)
    {
        for (j = 0; j < 5; j ++)
        {
            SDL_FreeSurface(alien[i][j]);
        }
    }

    SDL_FreeSurface(wave1);
    SDL_FreeSurface(wave2);
    SDL_FreeSurface(wave3);
    SDL_FreeSurface(wave4);
    SDL_FreeSurface(wave5);
    SDL_FreeSurface(wave6);
    SDL_FreeSurface(wave7);
    SDL_FreeSurface(wave8);
    SDL_FreeSurface(wave9);
    SDL_FreeSurface(wave10);

//game over et nouvelle vague alien
    if ((boucle_jeu(jeton) == 0) && (boucle == 1))
    {

    page_game_over(ecran);

    wave(retro_wave);

    retro_wave = 0;
    }
    else if ((boucle_jeu(jeton) == 1) && (boucle == 0))
    {
        boucle = 1;
        jouer(ecran);
    }

    menu(ecran);




}


void init_surface(SDL_Surface **tank, SDL_Surface **shot, SDL_Surface **sol,
                  SDL_Surface **cache, SDL_Surface **alien_shot,
                  SDL_Surface **alien_shot_2, SDL_Surface **alien_shot_3,
                  SDL_Surface **boom)
{

    *tank = SDL_LoadBMP("tank.bmp");

    *boom = SDL_LoadBMP("boom.bmp");

    *shot = SDL_LoadBMP("shot.bmp");
    *alien_shot = SDL_LoadBMP("alien_shot.bmp");
    *alien_shot_2 = SDL_LoadBMP("alien_shot.bmp");
    *alien_shot_3 = SDL_LoadBMP("alien_shot.bmp");

    *cache = SDL_LoadBMP("cache.bmp");
    *sol = SDL_LoadBMP("sol.bmp");
}

void init_wave(SDL_Surface **wave1, SDL_Surface **wave2, SDL_Surface **wave3,
               SDL_Surface **wave4, SDL_Surface **wave5, SDL_Surface **wave6,
               SDL_Surface **wave7, SDL_Surface **wave8, SDL_Surface **wave9,
               SDL_Surface **wave10)
{
    *wave1 = SDL_LoadBMP("wave1.bmp");
    *wave2 = SDL_LoadBMP("wave2.bmp");
    *wave3 = SDL_LoadBMP("wave3.bmp");
    *wave4 = SDL_LoadBMP("wave4.bmp");
    *wave5 = SDL_LoadBMP("wave5.bmp");
    *wave6 = SDL_LoadBMP("wave6.bmp");
    *wave7 = SDL_LoadBMP("wave7.bmp");
    *wave8 = SDL_LoadBMP("wave8.bmp");
    *wave9 = SDL_LoadBMP("wave9.bmp");
    *wave10 = SDL_LoadBMP("wave10.bmp");
}

void init_vie_cite(int vie_cite1[5], int vie_cite2[5], int vie_cite3[5], int vie_cite4[5])
{
    int i = 0;

    for(i = 0; i < 5; i ++)
    {
        vie_cite1[i] = 0;
        vie_cite2[i] = 0;
        vie_cite3[i] = 0;
        vie_cite4[i] = 0;
    }
}

void init_vie_alien(int vie_alien[][5])
{
    int i = 0, j = 0;

    for(i = 0; i < 11; i ++)
    {
        for(j = 0; j < 5; j ++)
        {
            vie_alien[i][j] = 0;
        }
    }
}


Uint32 tir(Uint32 intervalle, void *parametre)
{
    SDL_Rect *p_shot = parametre;


    p_shot->y-=2;


    return intervalle;
}

Uint32 tir_alien(Uint32 intervalle, void *parametre)
{
    SDL_Rect *p_alien_shot = parametre;

    p_alien_shot->y ++;

    return intervalle;
}




int tir_on (int entree)
{
    static int tir = 1;



    tir = tir - entree;



    return tir;
}

void gestion_tir_alien(SDL_Rect *p_alien_shot, SDL_Rect p_alien[][5],
                       int vie_alien[][5])
{
    int random_i = 0, random_j = 0, i = 0, j = 0, jeton = 0, arret = 1;


    if (tir_alien_actuel(jeton) == 1)
    {
    random_i = (rand()%(MAX_I - MIN_I + 1) + MIN_I);
    random_j = (rand()%(MAX_J - MIN_J + 1) + MIN_J);

    switch (random_i)
    {
    case 1:
        i = 0;
        break;
    case 2:
        i = 1;
        break;
    case 3:
        i = 2;
        break;
    case 4:
        i = 3;
        break;
    case 5:
        i = 4;
        break;
    case 6:
        i = 5;
        break;
    case 7:
        i = 6;
        break;
    case 8:
        i = 7;
        break;
    case 9:
        i = 8;
        break;
    case 10:
        i = 9;
    case 11:
        i = 10;
        break;
    }

    switch (random_j)
    {
    case 1:
        j = 0;
        break;
    case 2:
        j = 1;
        break;
    case 3:
        j = 2;
        break;
    case 4:
        j = 3;
        break;
    case 5:
        j = 4;
        break;
    }


    if (vie_alien[i][j] == 0)
    {
    p_alien_shot->x = p_alien[i][j].x + SPRITE/2;
    p_alien_shot->y = p_alien[i][j].y + SPRITE;
    tir_alien_actuel(arret);
    }

    else
        gestion_tir_alien(p_alien_shot, p_alien, vie_alien);

    }


}

int tir_alien_actuel (int entree)
{
    static int shot_actuel = 1;

    shot_actuel = shot_actuel - entree;

    return shot_actuel;
}


Uint32 tir_alien_2(Uint32 intervalle, void *parametre)
{
    SDL_Rect *p_alien_shot_2 = parametre;

    p_alien_shot_2->y ++;

    return intervalle;
}


void gestion_tir_alien_2(SDL_Rect *p_alien_shot_2, SDL_Rect p_alien[][5],
                       int vie_alien[][5])
{
    int random_i = 0, random_j = 0, i = 0, j = 0, jeton = 0, arret = 1;



    if (tir_alien_actuel_2(jeton) == 1)
    {
    random_i = (rand()%(MAX_I - MIN_I + 1) + MIN_I);
    random_j = (rand()%(MAX_J - MIN_J + 1) + MIN_J);

    switch (random_i)
    {
    case 1:
        i = 0;
        break;
    case 2:
        i = 1;
        break;
    case 3:
        i = 2;
        break;
    case 4:
        i = 3;
        break;
    case 5:
        i = 4;
        break;
    case 6:
        i = 5;
        break;
    case 7:
        i = 6;
        break;
    case 8:
        i = 7;
        break;
    case 9:
        i = 8;
        break;
    case 10:
        i = 9;
    case 11:
        i = 10;
        break;
    }

    switch (random_j)
    {
    case 1:
        j = 0;
        break;
    case 2:
        j = 1;
        break;
    case 3:
        j = 2;
        break;
    case 4:
        j = 3;
        break;
    case 5:
        j = 4;
        break;
    }


    if (vie_alien[i][j] == 0)
    {
    p_alien_shot_2->x = p_alien[i][j].x + SPRITE/2;
    p_alien_shot_2->y = p_alien[i][j].y + SPRITE;
    tir_alien_actuel_2(arret);
    }

    else
        gestion_tir_alien_2(p_alien_shot_2, p_alien, vie_alien);

    }


}

int tir_alien_actuel_2 (int entree)
{
    static int shot_actuel = 1;

    shot_actuel = shot_actuel - entree;

    return shot_actuel;
}


Uint32 tir_alien_3(Uint32 intervalle, void *parametre)
{
    SDL_Rect *p_alien_shot_3 = parametre;

    p_alien_shot_3->y ++;

    return intervalle;
}


void gestion_tir_alien_3(SDL_Rect *p_alien_shot_3, SDL_Rect p_alien[][5],
                       int vie_alien[][5])
{
    int random_i = 0, random_j = 0, i = 0, j = 0, jeton = 0, arret = 1;


    if (tir_alien_actuel_3(jeton) == 1)
    {
    random_i = (rand()%(MAX_I - MIN_I + 1) + MIN_I);
    random_j = (rand()%(MAX_J - MIN_J + 1) + MIN_J);

    switch (random_i)
    {
    case 1:
        i = 0;
        break;
    case 2:
        i = 1;
        break;
    case 3:
        i = 2;
        break;
    case 4:
        i = 3;
        break;
    case 5:
        i = 4;
        break;
    case 6:
        i = 5;
        break;
    case 7:
        i = 6;
        break;
    case 8:
        i = 7;
        break;
    case 9:
        i = 8;
        break;
    case 10:
        i = 9;
    case 11:
        i = 10;
        break;
    }

    switch (random_j)
    {
    case 1:
        j = 0;
        break;
    case 2:
        j = 1;
        break;
    case 3:
        j = 2;
        break;
    case 4:
        j = 3;
        break;
    case 5:
        j = 4;
        break;
    }


    if (vie_alien[i][j] == 0)
    {
    p_alien_shot_3->x = p_alien[i][j].x + SPRITE/2;
    p_alien_shot_3->y = p_alien[i][j].y + SPRITE;
    tir_alien_actuel_3(arret);
    }

    else
        gestion_tir_alien_3(p_alien_shot_3, p_alien, vie_alien);

    }


}

int tir_alien_actuel_3 (int entree)
{
    static int shot_actuel = 1;

    shot_actuel = shot_actuel - entree;

    return shot_actuel;
}


int collision (SDL_Rect box1, SDL_Rect box2)
{



     if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;

    else
        return 1;




}




 int col_tank1(SDL_Rect box1, SDL_Rect box2)
{



     if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;




}

int col_tank2(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_tank3(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}


int col_shot1(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_shot2(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_shot3(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite1a(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite1b(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite1c(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite2a(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite2b(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite2c(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}


int col_cite3a(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite3b(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite3c(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}


int col_cite4a(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite4b(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}

int col_cite4c(SDL_Rect box1, SDL_Rect box2)
{
    if((box2.x >= box1.x + box1.w)
        || (box2.x + box2.w <= box1.x)
        || (box2.y >= box1.y + box1.h)
        || (box2.y + box2.h <= box1.y))
        return 0;



    else
        return 1;
}



void move_alien (SDL_Rect p_alien[][5])
{
    int i = 0, j = 0;

    for (i = 0; i < 11; i ++)
    {
        for (j = 0; j < 5; j ++)
        {

        if ((p_alien[0][j].x < 768 && p_alien[1][j].x < 768
                        && p_alien[2][j].x < 768 && p_alien[3][j].x < 768
                        && p_alien[4][j].x < 768 && p_alien[5][j].x < 768
                        && p_alien[6][j].x < 768 && p_alien[7][j].x < 768
                        && p_alien[8][j].x < 768 && p_alien[9][j].x < 768
                        && p_alien[10][j].x < 768)
                        && (p_alien[i][0].y <= 50 && p_alien[i][1].y <= 100
                        && p_alien[i][2].y <= 150 && p_alien[i][3].y <= 200
                        && p_alien[i][4].y <= 250
                        ))
                        {p_alien[i][j].x ++;

                        }



                   else if ((p_alien[0][j].x == 768 || p_alien[1][j].x == 768
                        || p_alien[2][j].x == 768 || p_alien[3][j].x == 768
                        || p_alien[4][j].x == 768 || p_alien[5][j].x == 768
                        || p_alien[6][j].x == 768 || p_alien[7][j].x == 768
                        || p_alien[8][j].x == 768 || p_alien[9][j].x == 768
                        || p_alien[10][j].x == 768)
                        && (p_alien[i][0].y <= 100 && p_alien[i][1].y <= 150
                        && p_alien[i][2].y <= 200 && p_alien[i][3].y <= 250
                        && p_alien[i][4].y <= 300
                        ))

                        p_alien[i][j].y ++;

                    else if ((p_alien[0][j].x > 0
                            && p_alien[1][j].x > 0 && p_alien[2][j].x > 0
                             && p_alien[3][j].x > 0 && p_alien[4][j].x > 0
                             && p_alien[5][j].x > 0 && p_alien[6][j].x > 0
                             && p_alien[7][j].x > 0 && p_alien[8][j].x > 0
                             && p_alien[9][j].x > 0 && p_alien[10][j].x > 0)
                             && (p_alien[i][0].y <= 110 && p_alien[i][1].y <= 160
                             && p_alien[i][2].y <= 210 && p_alien[i][3].y <= 260
                             && p_alien[i][4].y <= 310
                             ))

                        p_alien[i][j].x --;

                    else if ((p_alien[0][j].x == 0 || p_alien[1][j].x == 0
                             || p_alien[2][j].x == 0 || p_alien[3][j].x == 0
                             || p_alien[4][j].x == 0 || p_alien[5][j].x == 0
                             || p_alien[6][j].x == 0 || p_alien[7][j].x == 0
                             || p_alien[8][j].x == 0 || p_alien[9][j].x == 0
                             || p_alien[10][j].x == 0) && (p_alien[i][0].y <= 150
                             && p_alien[i][1].y <= 200 && p_alien[i][2].y <= 250
                             && p_alien[i][3].y <= 300 && p_alien[i][4].y <= 350
                             ))

                            p_alien[i][j].y ++;

                    else if ((p_alien[0][j].x < 768 && p_alien[1][j].x < 768
                             && p_alien[2][j].x < 768 && p_alien[3][j].x < 768
                             && p_alien[4][j].x < 768 && p_alien[5][j].x < 768
                             && p_alien[6][j].x < 768 && p_alien[7][j].x < 768
                             && p_alien[8][j].x < 768 && p_alien[9][j].x < 768
                             && p_alien[10][j].x < 768) && (p_alien[i][0].y <= 160
                             && p_alien[i][1].y <= 210 && p_alien[i][2].y <= 260
                             && p_alien[i][3].y <= 310 && p_alien[i][4].y <= 360
                             ))

                            p_alien[i][j].x ++;

                    else if ((p_alien[0][j].x == 768 || p_alien[1][j].x == 768
                        || p_alien[2][j].x == 768 || p_alien[3][j].x == 768
                        || p_alien[4][j].x == 768 || p_alien[5][j].x == 768
                        || p_alien[6][j].x == 768 || p_alien[7][j].x == 768
                        || p_alien[8][j].x == 768 || p_alien[9][j].x == 768
                        || p_alien[10][j].x == 768)
                        && (p_alien[i][0].y <= 200 && p_alien[i][1].y <= 250
                        && p_alien[i][2].y <= 300 && p_alien[i][3].y <= 350
                        && p_alien[i][4].y <= 400
                        ))

                             p_alien[i][j].y ++;

                     else if ((p_alien[0][j].x > 0
                            && p_alien[1][j].x > 0 && p_alien[2][j].x > 0
                             && p_alien[3][j].x > 0 && p_alien[4][j].x > 0
                             && p_alien[5][j].x > 0 && p_alien[6][j].x > 0
                             && p_alien[7][j].x > 0 && p_alien[8][j].x > 0
                             && p_alien[9][j].x > 0 && p_alien[10][j].x > 0)
                             && (p_alien[i][0].y <= 210 && p_alien[i][1].y <= 260
                             && p_alien[i][2].y <= 310 && p_alien[i][3].y <= 360
                             && p_alien[i][4].y <= 410
                             ))

                             p_alien[i][j].x --;

                     else if ((p_alien[0][j].x == 0 || p_alien[1][j].x == 0
                             || p_alien[2][j].x == 0 || p_alien[3][j].x == 0
                             || p_alien[4][j].x == 0 || p_alien[5][j].x == 0
                             || p_alien[6][j].x == 0 || p_alien[7][j].x == 0
                             || p_alien[8][j].x == 0 || p_alien[9][j].x == 0
                             || p_alien[10][j].x == 0) && (p_alien[i][0].y <= 250
                             && p_alien[i][1].y <= 300 && p_alien[i][2].y <= 350
                             && p_alien[i][3].y <= 400 && p_alien[i][4].y <= 450
                             ))

                             p_alien[i][j].y ++;

                     else if ((p_alien[0][j].x < 768 && p_alien[1][j].x < 768
                             && p_alien[2][j].x < 768 && p_alien[3][j].x < 768
                             && p_alien[4][j].x < 768 && p_alien[5][j].x < 768
                             && p_alien[6][j].x < 768 && p_alien[7][j].x < 768
                             && p_alien[8][j].x < 768 && p_alien[9][j].x < 768
                             && p_alien[10][j].x < 768) && (p_alien[i][0].y <= 260
                             && p_alien[i][1].y <= 310 && p_alien[i][2].y <= 360
                             && p_alien[i][3].y <= 410 && p_alien[i][4].y <= 460
                             ))

                             p_alien[i][j].x ++;

                     else if ((p_alien[0][j].x == 768 || p_alien[1][j].x == 768
                        || p_alien[2][j].x == 768 || p_alien[3][j].x == 768
                        || p_alien[4][j].x == 768 || p_alien[5][j].x == 768
                        || p_alien[6][j].x == 768 || p_alien[7][j].x == 768
                        || p_alien[8][j].x == 768 || p_alien[9][j].x == 768
                        || p_alien[10][j].x == 768)
                        && (p_alien[i][0].y <= 300 && p_alien[i][1].y <= 350
                        && p_alien[i][2].y <= 400 && p_alien[i][3].y <= 450
                        && p_alien[i][4].y <= 500
                        ))

                            p_alien[i][j].y ++;

                    else if ((p_alien[0][j].x > 0
                            && p_alien[1][j].x > 0 && p_alien[2][j].x > 0
                             && p_alien[3][j].x > 0 && p_alien[4][j].x > 0
                             && p_alien[5][j].x > 0 && p_alien[6][j].x > 0
                             && p_alien[7][j].x > 0 && p_alien[8][j].x > 0
                             && p_alien[9][j].x > 0 && p_alien[10][j].x > 0)
                             && (p_alien[i][0].y <= 310 && p_alien[i][1].y <= 360
                             && p_alien[i][2].y <= 410 && p_alien[i][3].y <= 460
                             && p_alien[i][4].y <= 510
                             ))

                             p_alien[i][j].x --;

                     else if ((p_alien[0][j].x == 0 || p_alien[1][j].x == 0
                             || p_alien[2][j].x == 0 || p_alien[3][j].x == 0
                             || p_alien[4][j].x == 0 || p_alien[5][j].x == 0
                             || p_alien[6][j].x == 0 || p_alien[7][j].x == 0
                             || p_alien[8][j].x == 0 || p_alien[9][j].x == 0
                             || p_alien[10][j].x == 0) && (p_alien[i][0].y <= 350
                             && p_alien[i][1].y <= 400 && p_alien[i][2].y <= 450
                             && p_alien[i][3].y <= 500 && p_alien[i][4].y <= 550
                             ))

                             p_alien[i][j].y ++;

                     else if ((p_alien[0][j].x < 768 && p_alien[1][j].x < 768
                             && p_alien[2][j].x < 768 && p_alien[3][j].x < 768
                             && p_alien[4][j].x < 768 && p_alien[5][j].x < 768
                             && p_alien[6][j].x < 768 && p_alien[7][j].x < 768
                             && p_alien[8][j].x < 768 && p_alien[9][j].x < 768
                             && p_alien[10][j].x < 768) && (p_alien[i][0].y <= 360
                             && p_alien[i][1].y <= 410 && p_alien[i][2].y <= 460
                             && p_alien[i][3].y <= 510 && p_alien[i][4].y <= 560
                             ))

                             p_alien[i][j].x ++;

                     else if ((p_alien[0][j].x == 768 || p_alien[1][j].x == 768
                        || p_alien[2][j].x == 768 || p_alien[3][j].x == 768
                        || p_alien[4][j].x == 768 || p_alien[5][j].x == 768
                        || p_alien[6][j].x == 768 || p_alien[7][j].x == 768
                        || p_alien[8][j].x == 768 || p_alien[9][j].x == 768
                        || p_alien[10][j].x == 768)
                        && (p_alien[i][0].y <= 400 && p_alien[i][1].y <= 450
                        && p_alien[i][2].y <= 500 && p_alien[i][3].y <= 550
                        && p_alien[i][4].y <= 600
                        ))

                            p_alien[i][j].y ++;

                        else if ((p_alien[0][j].x > 0
                            && p_alien[1][j].x > 0 && p_alien[2][j].x > 0
                             && p_alien[3][j].x > 0 && p_alien[4][j].x > 0
                             && p_alien[5][j].x > 0 && p_alien[6][j].x > 0
                             && p_alien[7][j].x > 0 && p_alien[8][j].x > 0
                             && p_alien[9][j].x > 0 && p_alien[10][j].x > 0)
                             && (p_alien[i][0].y <= 410 && p_alien[i][1].y <= 460
                             && p_alien[i][2].y <= 510 && p_alien[i][3].y <= 560
                             && p_alien[i][4].y <= 610
                             ))

                             p_alien[i][j].x --;

                         else if ((p_alien[0][j].x == 0 || p_alien[1][j].x == 0
                             || p_alien[2][j].x == 0 || p_alien[3][j].x == 0
                             || p_alien[4][j].x == 0 || p_alien[5][j].x == 0
                             || p_alien[6][j].x == 0 || p_alien[7][j].x == 0
                             || p_alien[8][j].x == 0 || p_alien[9][j].x == 0
                             || p_alien[10][j].x == 0) && (p_alien[i][0].y <= 450
                             && p_alien[i][1].y <= 500 && p_alien[i][2].y <= 550
                             && p_alien[i][3].y <= 600 && p_alien[i][4].y <= 650
                             ))

                             p_alien[i][j].y ++;

                         else if ((p_alien[0][j].x < 768 && p_alien[1][j].x < 768
                             && p_alien[2][j].x < 768 && p_alien[3][j].x < 768
                             && p_alien[4][j].x < 768 && p_alien[5][j].x < 768
                             && p_alien[6][j].x < 768 && p_alien[7][j].x < 768
                             && p_alien[8][j].x < 768 && p_alien[9][j].x < 768
                             && p_alien[10][j].x < 768) && (p_alien[i][0].y <= 460
                             && p_alien[i][1].y <= 510 && p_alien[i][2].y <= 560
                             && p_alien[i][3].y <= 610 && p_alien[i][4].y <= 660
                             ))

                             p_alien[i][j].x ++;

                         else if ((p_alien[0][j].x == 768 || p_alien[1][j].x == 768
                        || p_alien[2][j].x == 768 || p_alien[3][j].x == 768
                        || p_alien[4][j].x == 768 || p_alien[5][j].x == 768
                        || p_alien[6][j].x == 768 || p_alien[7][j].x == 768
                        || p_alien[8][j].x == 768 || p_alien[9][j].x == 768
                        || p_alien[10][j].x == 768)
                        && (p_alien[i][0].y <= 500 && p_alien[i][1].y <= 550
                        && p_alien[i][2].y <= 600 && p_alien[i][3].y <= 650
                        && p_alien[i][4].y <= 700
                        ))

                            p_alien[i][j].y ++;

                        else if ((p_alien[0][j].x > 0
                            && p_alien[1][j].x > 0 && p_alien[2][j].x > 0
                             && p_alien[3][j].x > 0 && p_alien[4][j].x > 0
                             && p_alien[5][j].x > 0 && p_alien[6][j].x > 0
                             && p_alien[7][j].x > 0 && p_alien[8][j].x > 0
                             && p_alien[9][j].x > 0 && p_alien[10][j].x > 0)
                             && (p_alien[i][0].y <= 510 && p_alien[i][1].y <= 560
                             && p_alien[i][2].y <= 610 && p_alien[i][3].y <= 660
                             && p_alien[i][4].y <= 710
                             ))

                             p_alien[i][j].x --;

                         else if ((p_alien[0][j].x == 0 || p_alien[1][j].x == 0
                             || p_alien[2][j].x == 0 || p_alien[3][j].x == 0
                             || p_alien[4][j].x == 0 || p_alien[5][j].x == 0
                             || p_alien[6][j].x == 0 || p_alien[7][j].x == 0
                             || p_alien[8][j].x == 0 || p_alien[9][j].x == 0
                             || p_alien[10][j].x == 0) && (p_alien[i][0].y <= 550
                             && p_alien[i][1].y <= 600 && p_alien[i][2].y <= 650
                             && p_alien[i][3].y <= 700 && p_alien[i][4].y <= 750
                             ))

                             p_alien[i][j].y ++;








        }
    }


}


void maj_alien (SDL_Rect p_alien[][5], int vie_alien[][5])//repositionne les surfaces d'aliens morts sur des surfaces toujours vivantes
{
    int i = 0, j = 0;

if (!(p_alien[0][j].x == 0 || p_alien[10][j].x == 768
    || p_alien[1][j].x == 0 || p_alien[9][j].x == 768
    || p_alien[2][j].x == 0 || p_alien[8][j].x == 768
    || p_alien[3][j].x == 0 || p_alien[7][j].x == 768
    || p_alien[4][j].x == 0 || p_alien[6][j].x == 768
    || p_alien[5][j].x == 0 || p_alien[5][j].x == 768
    || p_alien[6][j].x == 0 || p_alien[4][j].x == 768
    || p_alien[7][j].x == 0 || p_alien[3][j].x == 768
    || p_alien[8][j].x == 0 || p_alien[2][j].x == 768
    || p_alien[9][j].x == 0 || p_alien[1][j].x == 768))
        {

    for (i = 0; i < 11; i ++)
    {
        for (j = 0; j < 5; j ++)
        {




            if(vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)

            p_alien[0][j].x = p_alien[5][j].x;

            if(vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)

            p_alien[1][j].x = p_alien[5][j].x;

            if(vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)

            p_alien[2][j].x = p_alien[5][j].x;

            if(vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)

            p_alien[3][j].x = p_alien[5][j].x;

            if(vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)

            p_alien[4][j].x = p_alien[5][j].x;

            if(vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)

            p_alien[6][j].x = p_alien[5][j].x;

            if(vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)

            p_alien[7][j].x = p_alien[5][j].x;

            if(vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1)

            p_alien[8][j].x = p_alien[5][j].x;

            if(vie_alien[9][0] == 1 && vie_alien[9][1] == 1 && vie_alien[9][2] == 1
               && vie_alien[9][3] == 1 && vie_alien[9][4] == 1)

            p_alien[9][j].x = p_alien[5][j].x;



            if(vie_alien[10][0] == 1 && vie_alien[10][1] == 1
               && vie_alien[10][2] == 1 && vie_alien[10][3] == 1
               && vie_alien[10][4] == 1)

                p_alien[10][j].x = p_alien[5][j].x;


            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)
               && (vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)
               && (vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1))

            p_alien[5][j].x = p_alien[6][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)
               && (vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)
               && (vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1))

            p_alien[5][j].x = p_alien[7][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)
               && (vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)
               && (vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1))

            p_alien[5][j].x = p_alien[8][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)
               && (vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)
               && (vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)
               && (vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1))

            p_alien[5][j].x = p_alien[9][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[0][0] == 1 && vie_alien[0][1] == 1 && vie_alien[0][2] == 1
               && vie_alien[0][3] == 1 && vie_alien[0][4] == 1)
               && (vie_alien[1][0] == 1 && vie_alien[1][1] == 1 && vie_alien[1][2] == 1
               && vie_alien[1][3] == 1 && vie_alien[1][4] == 1)
               && (vie_alien[2][0] == 1 && vie_alien[2][1] == 1 && vie_alien[2][2] == 1
               && vie_alien[2][3] == 1 && vie_alien[2][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)
               && (vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1)
               && (vie_alien[9][0] == 1 && vie_alien[9][1] == 1 && vie_alien[9][2] == 1
               && vie_alien[9][3] == 1 && vie_alien[9][4] == 1))

            p_alien[5][j].x = p_alien[10][j].x;

              if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[10][0] == 1 && vie_alien[10][1] == 1 && vie_alien[10][2] == 1
               && vie_alien[10][3] == 1 && vie_alien[10][4] == 1)
               && (vie_alien[9][0] == 1 && vie_alien[9][1] == 1 && vie_alien[9][2] == 1
               && vie_alien[9][3] == 1 && vie_alien[9][4] == 1)
               && (vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1))

            p_alien[5][j].x = p_alien[4][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[10][0] == 1 && vie_alien[10][1] == 1 && vie_alien[10][2] == 1
               && vie_alien[10][3] == 1 && vie_alien[10][4] == 1)
               && (vie_alien[9][0] == 1 && vie_alien[9][1] == 1 && vie_alien[9][2] == 1
               && vie_alien[9][3] == 1 && vie_alien[9][4] == 1)
               && (vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1))

            p_alien[5][j].x = p_alien[3][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[10][0] == 1 && vie_alien[10][1] == 1 && vie_alien[10][2] == 1
               && vie_alien[10][3] == 1 && vie_alien[10][4] == 1)
               && (vie_alien[9][0] == 1 && vie_alien[9][1] == 1 && vie_alien[9][2] == 1
               && vie_alien[9][3] == 1 && vie_alien[9][4] == 1)
               && (vie_alien[8][0] == 1 && vie_alien[8][1] == 1 && vie_alien[8][2] == 1
               && vie_alien[8][3] == 1 && vie_alien[8][4] == 1)
               && (vie_alien[7][0] == 1 && vie_alien[7][1] == 1 && vie_alien[7][2] == 1
               && vie_alien[7][3] == 1 && vie_alien[7][4] == 1)
               && (vie_alien[6][0] == 1 && vie_alien[6][1] == 1 && vie_alien[6][2] == 1
               && vie_alien[6][3] == 1 && vie_alien[6][4] == 1)
               && (vie_alien[4][0] == 1 && vie_alien[4][1] == 1 && vie_alien[4][2] == 1
               && vie_alien[4][3] == 1 && vie_alien[4][4] == 1)
               && (vie_alien[3][0] == 1 && vie_alien[3][1] == 1 && vie_alien[3][2] == 1
               && vie_alien[3][3] == 1 && vie_alien[3][4] == 1))

            p_alien[5][j].x = p_alien[2][j].x;

            if((vie_alien[5][0] == 1 && vie_alien[5][1] == 1 && vie_alien[5][2] == 1
               && vie_alien[5][3] == 1 && vie_alien[5][4] == 1)
               && (vie_alien[10][0] == 1 && vie_alien[10][1] == 1 && vie_alien[10][2] == 1
               && vi

[dub]

Hou, ça c'est du code ... un bon paquet à lire.

Et il faudrait que tu expliques le bug que tu as ... Déjà, regardes à utiliser des noms variables plus simple pour te relire (continuer, boucle ==1, ... )

Et si t'as besoins pour le sgdk, y a du monde qui s'y connait sur ce forum. Perso, je code avec le Notepad (ou autre) et compile en ligne de commande. Mais tu auras moins de problème, une fois la rom créée. Si ça marche sur une console physique, ça marchera sur les autres. Juste la question du framerate par région.

[Invité]

Bon courage Kane pour ces nouvelles aventures !
Passes de bonnes fêtes.

[Top l'âne]

@vetea: merci. Pour avoir validé mon environnement de travail, je vais pouvoir me plonger sereinement dans la doc MD. :)
Je viens de viser ta signature, je mets la main sur le bin du Papi.

@dub: le bug survient au lancement de la première vague. Il prend plusieurs formes.
Au mieux j'ai juste des défauts d'affichage sur des morceaux de bunker (cite).
Plus souvent j'ai une vague intégralement morte. Freeze. Et soit le prog relance lui même la seconde vague soit il me renvoie au menu. Dans ce cas si je relance le jeu, le prog envoie la seconde vague.
De manière générale une fois que la seconde vague est lancée, le jeu semble se dérouler normalement.


Si je mène mon auto-critique, je pense que les tableaux 2d Surface alien[][] (pour les sprites) et int vie_alien[][] sont peut être une source de problème.
Sur le coup ça m'a semblé instinctif mais j'entrevois à présent que je peux faire la même chose avec des tableaux simples et alléger ainsi bon nombre de fonctions les utilisant. Et notamment les deux verrues move_alien et maj_alien.

[tetsuro]

Salut Citizen Kane,

Je viens de tomber sur ce forum et sur ton message, c'est marrant car on est au même niveau environ, j’apprends le langage C, j'en suis à l'étape SDL, et ce soir j'ai réaliser mon premier Hello World sur Megadrive :)
Mon objectif est de savoir faire un petit jeu simple sur Megadrive, tout comme toi j'ai un peu regarder les docs MD, enfin j'avance dans le noir, je ne sais pas du tout quel chemin prendre, beaucoup de sites sont obsolètes, des liens morts, des tutos pas finis, tu trouves où tes infos toi ?
Quand j'aurais un meilleur niveau je crois que je pense à réaliser un site web pour centraliser les infos liées au développement sur Megadrive, histoire d'avoir un bon point de départ pour les débutants comme nous, enfin c'est juste une idée :)

[Top l'âne]

Hey Tetsuro!

Je partage ton désarroi concernant l'apprentissage de la prog sur MD. Impossible de trouver du tuto pas à pas pour se faire la main. Principalement de grosses docs bien effrayantes pour les noobs que nous sommes.^^

Voilà ce que j'avais trouvé de plus accessible pour mettre les pieds dans l'eau:

https://github.com/Stephane-D/SGDK/wiki/Tuto-Intro

Tu l'avais sans doute déjà visionné.
Y a déjà pas mal de petites bricoles à appréhender sans risquer la foulure de neurones.
Pour l'instant j'ai juste tapoté un peu de tiles par curiosité mais je préfère ne point trop m'éparpiller et commencer par peaufiner mon code SDL.

Quoiqu'il en soit c'est un heureux hasard de trouver un camarade débutant. Outre la possibilité de simplement partager ici nos acquis, je suis parfaitement ouvert à un projet d'apprentissage en binôme, voire un projet créatif tout court, que ce soit SDL ou MD d'ailleurs. (ma boite à MP est ouverte :) )

Et bé sinon, j'ai repris le code du Space Invaders de zéro.
J'ai une nouvelle fonction pour le pattern aliens, dégraissée de 250 à 50 lignes, ça ne pourra qu'aller mieux.
C'était le gros morceau, le reste de la rédaction devrait couler rapidement et je fonde de gros espoirs sur une Release d'ici mi-janvier... Stable cette fois.

[tetsuro]

Salut Citizen Kane,
Je suis content de voir que t'es partant pour s'aider, se filer des infos, discuter, je t'envoie un MP :)

Edit : Finalement je n'arrive pas à t'envoyer de MP, on me dit que je n'ai pas assez écrit de messages sur le forum, ils ne précisent pas combien il en faudrait, j'en suis à 10 messages. Donc ben tu pourrais me MP toi si tu veux, ma boite est aussi ouverte :)

[Top l'âne]

ah vi exact c'est 20 posts pour la liberté de circuler.^^
MP. :)

[tetsuro]

Ce système est bien et pas bien à la fois car il peut créer du flood si de toute façon on ne s’intéresse pas au forum, et agacer ceux qui s’intéresse au forum, enfin bon moi j'y arrive tout doucement car c'est plaisant d'échanger, si il n'y avait pas eu cette restriction j’aurais juste pu MP plus tôt :)

[Stef]

Si vous vous interessez à la prog MD y'a une forum vraiment bien pour ça (mais en anglais) :
http://gendev.spritesmind.net/forum/

Il y a une section dédiée à SGDK par ailleurs :)

[Invité]

Non mais les gars n écoutez pas stef, faut arrêter le dev md qui ne vous apportera que malheur et destruction
La Pcengine c est plus cool

[Stef]

Y'a qu'un plan sur ta pauvre machine, on veut autre chose que de l'unique plan de 8 bits

PS: je plaisante bien sur :p

[tetsuro]

J'adore le PC Engine TOUKOU, un vrais amoureux, et un jour je compte bien maitre la main dedans :)

[Invité]

Nan mais je charriais stef, SGDK est un super outil, et pour un débutant c'est un outil idéal .

Le tout est d'arriver à ne pas abandonner au bout d'un mois et faut pas hésiter à aller sur le forum spritesmind pour poser des questions ou avoir de l'aide,en plus en fouinant dans les rubriques tu y trouves plein d'infos utiles .

Tiens comme stef a peur que vous deveniez meilleurs que lui,et qu'il ne vous a pas mis le lien  :
http://wiki.megadrive.org/index.php?title=Main_Page

Y'a la doc technique sur la MD,c'est bien fait et organisé par rubrique.

[dub]

  Ca y est les frères ennemies recommencent. Tout le monde sait bien que la GX4000 les défonce toutes.

[Invité]

Tout le monde sait bien que la GX4000 les défonce toutes.

 
the best machine ever ..

[Stef]

Nan mais je charriais stef, SGDK est un super outil, et pour un débutant c'est un outil idéal .

Le tout est d'arriver à ne pas abandonner au bout d'un mois et faut pas hésiter à aller sur le forum spritesmind pour poser des questions ou avoir de l'aide,en plus en fouinant dans les rubriques tu y trouves plein d'infos utiles .

Tiens comme stef a peur que vous deveniez meilleurs que lui,et qu'il ne vous a pas mis le lien  :
http://wiki.megadrive.org/index.php?title=Main_Page

Y'a la doc technique sur la MD,c'est bien fait et organisé par rubrique.

Merci

Effectivement le lien que tu as posté est interessant, mais je trouve qu'il reste vraiment très technique et peut faire peur de prime abord. Je me demande s'il existe un site plus généraliste qui explique avec de jolis schémas comment fonctionne les machines retro 2D, c'est à dire le système de plan à base de tilemap et ensuite la gestion hardware des sprites. Ca serait vraiment bien un site comme ça (et je pense que ça existe) car la plupart des consoles retro fonctionnent sous ce schéma (NES, Master System, Game Boy, Game Gear, PC Engine, Megadrive, SNES, Saturn, systèmes d'arcade et surement bien d'autre que j'oublie).

[Invité]

De rien c'est normal, mais c'est vrai que souvent les gens se lancent dans le dev sans connaitre un minimum ce qu'est un sprite ou un tilemap en croyant que SGDK va le faire pour eux (ce qui est presque vrai en plus) ..

Commencer à comprendre une machine, sans rentrer dans les détails aide bcp à savoir comment ça marche, et aussi à trouver pk ça marche pas .

Ca serait vraiment bien un site comme ça (et je pense que ça existe) car la plupart des consoles retro fonctionnent sous ce schéma (NES, Master System, Game Boy, Game Gear, PC Engine, Megadrive, SNES, Saturn, systèmes d'arcade et surement bien d'autre que j'oublie).

C'est clair bcp de machines fonctionnent sur le même schéma,et un site généraliste serrait pas mal pour le B.A.BA

[Top l'âne]

Holà, y pleut des posts ici.:p

Merci pour vos liens divers. Certains que j'avais déjà pointés et d'autres à découvrir.

De la lecture en perspective pour le début d'année.

[Top l'âne]

Bien, j'arrive avec un peu de nouveauté... Et quelques questions en fin de post.^^

Je me frotte à SGDK depuis une paire de semaine. J'ai avalé les tutos de base de Stef sans trop d'encombres, exception faite de l'utilisation de rescomp qui reste encore très obscure pour moi.

Et bien sûre je me plonge petit à petit dans la doc de la lib.

J'ai pondu une petite démo en guise d'exercice:



Dans un premier temps il m'a fallu me familiariser à la production de tiles. J'ai saisi le principe de mise en forme, reste à exploiter les palettes de couleurs.
J'ai observé la nature des plans d'affichage ainsi que les priorités.
J'ai saisi le principe des links... Heu, en gros.^^
Mais j'ai du mal à comprendre s'il s'agit d'un outil ou d'une nécessité.

J'ai associé le controller au sprite vert, pas de soucis pour les déplacements horizontaux/verticaux.
Les diagonales m'ont posé problème, je n'ai pas poussé plus loin pour l'instant (je crois deviner qu'il faut se reposer sur l'utilisation des states).
Les bouttons A & B permettent de switcher la priorité d'affichage du sprite pour le passer derrière le background. Toutefois je n'ai pas le résultat souhaité en cas de superposition avec un sprite tiers.
Mais je crois que ça découle simplement de la l'ordre de déclaration de mes sprites.

Au final j'ai inclus une fonction de collision AABB entre le sprite vert et les deux sprites gris mobiles.
Collision avec le sprite masqué = affichage d'une ligne de texte.
Collision avec l'autre sprite = suppression de la ligne de texte.

Je laisse la page de code pour ceux que ça intéresse :





Avec tout ça je me suis dit que j'avais sans doute assez de bagage pour transposer une démo de Space Invaders. Je rencontre rapidement mon premier problème.

Pour débuter je me contente d'afficher trois aliens en haut à gauche. RAS.




Ensuite je ponds une petite fonction pour leur pattern, et là ça va commencer à déconner.^^

A chaque fois que j'arrive au bout d'un déplacement y un micro-décalage se déclare, au bout de quelques aller/retours la vague est désynchronisée:



Comme j'utilise sans problème une fonction similaire sous SDL, je me sens un peu... fâché.

Voilà mon code pour ceux qui sauraient m'éclairer:



Par ailleurs, j'ai créé ma propre structure Sprite_Def afin d'inclure d'autres sous variables, en l'état longueur (w) et hauteur (h) du sprite.
Du coup ça fait un peu tiquer le setSpriteP qui attend un SpriteDef conventionnel en second argument. Ce qui allume quelques warnings. (d'ailleurs je ne vois pas de lien de cause à effet avec la désynchro de la vague, puisque j'ai le même soucis avec un bon SpriteDef).

Mais bref, y a un moyen de faire ça proprement?
Autre question. SDL me permet de créer une Surface *ecran, que je peux envoyer à mes fonctions pour ne pas avoir à surcharger le main. Y a t'il une approche similaire avec SGDK?
Dernière question pour la route, au démarrage savez vous ce que signifie le message "checksum incorrect"?

[Invité]

Une explication sans code source , je ne pense pas qu'on puisse énormément t'aider mais je peux répondre a certaine de tes questions.

Autre question. SDL me permet de créer une Surface *ecran, que je peux envoyer à mes fonctions pour ne pas avoir à surcharger le main. Y a t'il une approche similaire avec SGDK?

Euh la plus étrange de tes question , je vois pas en quoi le SGDK d'empeche de faire un pointeur et ou d'empeche de faire une fonction.

Dernière question pour la route, au démarrage savez vous ce que signifie le message "checksum incorrect"?

Le checksum appelé aussi somme de contrôle est tout simplement fait pour voir si ta rom est valide , j'imagine que le compilateur ne le met pas automatique sur l'entete.
Il doit y avoir des outils qui existe pour cela.

[Top l'âne]

Ah oui tiens, j'ai masqué le code pour éviter de surcharger le post, il s'affiche bien lorsque je suis connecté, mais pas en tant que visiteur.

Bref, je le remets en direct:


#include



typedef struct Sprite_Def Sprite_Def;
struct Sprite_Def
{
    s16 posx;
    s16 posy;
    u16 tile_attr;
    u8 size;
    u8 link;
    int w;
    int h;
};

void move_alien(Sprite_Def alien[3]);



const u32 tileAlien[4*8]=
{
    0x03333333,
    0x33222233,
    0x33000333,
    0x33330033,
    0x33333033,
    0x33333333,
    0x33333333,
    0x33333333,

    0x33333333,
    0x03333333,
    0x03333333,
    0x03333333,
    0x33333330,
    0x30303030,
    0x30303030,
    0x30303030,

    0x33333330,
    0x33222233,
    0x33300033,
    0x33003333,
    0x33033333,
    0x33333333,
    0x33333333,
    0x33333333,

    0x33333333,
    0x33333330,
    0x33333330,
    0x33333330,
    0x03333333,
    0x03030303,
    0x03030303,
    0x03030303
};



int main ()
{

    VDP_loadTileData((const u32 *)tileAlien, 1, 4, 0);

    Sprite_Def alien[3];

    alien[0].posx = 10;
    alien[0].posy = 10;
    alien[0].size = SPRITE_SIZE(2,2);
    alien[0].tile_attr = TILE_ATTR_FULL(PAL0, 1, 0, 0, 1);
    alien[0].link = 1;
    alien[0].w = 16;
    alien[0].h = 16;

    alien[1].posx = 36;
    alien[1].posy =  10;
    alien[1].size = SPRITE_SIZE(2,2);
    alien[1].tile_attr = TILE_ATTR_FULL(PAL0, 1, 0, 0, 1);
    alien[1].link = 2;
    alien[1].w = 16;
    alien[1].h = 16;

    alien[2].posx = 62;
    alien[2].posy = 10;
    alien[2].size = SPRITE_SIZE(2,2);
    alien[2].tile_attr = TILE_ATTR_FULL(PAL0, 1, 0, 0, 1);
    alien[2].link = 0;
    alien[2].w = 16;
    alien[2].h = 16;



    while(1)
    {


        move_alien(alien);

        VDP_setSpriteP(0, &alien[0]);
        VDP_setSpriteP(1, &alien[1]);
        VDP_setSpriteP(2, &alien[2]);

        VDP_updateSprites();

        VDP_waitVSync();
    }



    return(0);
}



void move_alien(Sprite_Def alien[3])
{
    int i = 0;
    static int dir = 1, compty = 0; //dir annonce la direction, compty comptabilise 50 lignes avant de conclure un déplacement en y

    for(i = 0; i < 3; i ++)
    {

        if(dir == 1 && alien[i].posx != 300)
        {
            alien[i].posx++;
        }

        else if(dir == 1 && alien[i].posx == 300)
            dir = 3;

        if(dir == 2 && alien[i].posx != 0)
        {
            alien[i].posx--;
        }

        else if(dir == 2 && alien[i].posx == 0)
            dir = 3;

        if(dir == 3 && compty < 50)
        {
            alien[i].posy++;
            compty++;
        }

         else if(compty == 50 && alien[i].posx == 300)
         {
                dir = 2;
                compty = 0;
         }
         else if(compty == 50 && alien[i].posx == 0)
         {
                dir = 1;
                compty = 0;
         }
 
    }
}

[Top l'âne]

Autre question. SDL me permet de créer une Surface *ecran, que je peux envoyer à mes fonctions pour ne pas avoir à surcharger le main. Y a t'il une approche similaire avec SGDK?

Euh la plus étrange de tes question , je vois pas en quoi le SGDK d'empeche de faire un pointeur et ou d'empeche de faire une fonction.

Je mets en avant mon syndrome de noobitude autodidacte. Pour l'instant plus souvent cerné par le doute que par les certitudes.^^
En définitive j'avais déjà ma petite idée sur la question et ta réponse à suffit à me conforter.
Je me suis sorti le doigt, j'ai farfouillé une petite heure, et j'ai trouvé la méthode. Merci.

De fait ma démo Space Invaders pour MD avance pas mal, je suis bien content.