IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

Snake : la queue


Sujet :

C

  1. #1
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut Snake : la queue
    Bonjour a vous tous développeur et développeuse.

    je suis actuellement en train de programmer un jeu de type Snake en SDL, pour ce faire, j'utilise un tableau qui se fait charger par une fonction qui lit les caractères '0' '1' '2' '3' '4' en ASCII.

    Seulement pour la queue, je ne sais pas trop comment faire.
    En effet, j'avais penser a creer un tableau de position SDL_Rect dans la quelle contient toutes les positions de ma queue et une SDL_Surface *queue dans laquelle je charge l'image et une variable "longueur queue".

    Mais je ne vois pas comment charger les positions pour qu'elles "suivent" la tete.

    Cordialement Qnope

  2. #2
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Mon premier tronceau s'affiche, mais ... pas les autres^^

    Pour se faire j'utilise un tableau de SDL_Rect positionQueue[1000], comme je voulais faire donc

    Puis, je met que la position queue[0] egal a positionjoueur et j'ajuste etc.

    Voici mon code

    je precise que taille commence a 10^^, c'est juste pour tester^^

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;
     
            SDL_Flip(screen);
    Cordialement

  3. #3
    Membre Expert
    Avatar de méphistopheles
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    1 551
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 1 551
    Par défaut
    Bonjour.

    L'erreur est en fait simple:

    Citation Envoyé par qnop Voir le message
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
    Ici, schématiquement , tu fais:

    • positionQueue[1]=positionQueue[0]
    • positionQueue[2]=positionQueue[1]=positionQueue[0]
    • positionQueue[3]=positionQueue[2]=positionQueue[0]
    • ...
    • positionQueue[n]=positionQueue[n-1]=positionQueue[0]


    Donc en fait, toutes tes positions son égales... et tu n'as donc au final qu'un pixel de dessiné.

    Pour corriger cela, il suffit de parcourir ton tableau dans l'autre sens :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
            for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
    et là, tu copiera la valeur AVANT de l'effacer et donc cela marchera (enfin plutôt rampera dans ton cas ).

    Bonne chance

  4. #4
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Salut a toi, merci de ta réponse mais malheureusement, cela ne fonctionne toujours, pas.

    Plusieurs personnes m'ont conseillé d'utilisé les listes chainés. De rajouter un element, puis de supprimer le dernier si la queue ne grandit pas, et d'en ajouter un sans supprimer a la fin si elle doit grandir, seulement, je ne sais pas du tout comment m'y prendre, pour la position de la queue etc.

    Si tu pourrais me renseigner^^

    Cordialement

  5. #5
    Membre Expert
    Avatar de méphistopheles
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    1 551
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 1 551
    Par défaut
    Une liste chainée serait effectivement plus appropriée, mais tu en trouveras sans problèmes dans la faq et les sources.

    Par contre, ce que je t'ais donné devrait marcher... à condition de suivre la logique, c'est à dire que si tu inverse la boucle, il faut aussi insérer l'élément 0 apres.

    au final, cela donne :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
            if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;
     
            SDL_Flip(screen);
    et si cela ne marche pas, c'est qu'il me manque des éléments. merci d'indiquer quelle est l'erreur dans ce cas.

    Bonne chance

  6. #6
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Re salut a toi

    Merci de prendre la patience de m'aider.

    Ton code ne fonctionne toujours pas, il m'affiche que le premier morceau encore

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
     
            if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;
     
            SDL_Flip(screen);

  7. #7
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Même en esseyant d'adapter un peu le code, ca ne marche pas u_U


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    for(v=0; v<taille; v++)
            {
     
            if(snakeActu == snake[DROITE])
            {
                if(v == 0)
                {
                    positionQueue[v].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                    positionQueue[v].y = (positionJoueur.y) * TAILLE_CASE;
                }
     
                else
                {
                    positionQueue[v].x = positionQueue[v-1].x - 1;
                    positionQueue[v].y = positionQueue[v-1].y;
                }

  8. #8
    Membre Expert
    Avatar de méphistopheles
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    1 551
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 1 551
    Par défaut
    Citation Envoyé par qnop Voir le message
    Re salut a toi

    Merci de prendre la patience de m'aider.

    Ton code ne fonctionne toujours pas, il m'affiche que le premier morceau encore
    Citation Envoyé par qnop Voir le message
    Même en esseyant d'adapter un peu le code, ca ne marche pas u_U
    Oups, mauvais copié coller: je sais pas si tu as remarqué, mais je t'ai redonné la première boucle :red:

    le bon code est :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
            for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
            if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;
     
            SDL_Flip(screen);
    Celui-ci (je l'espère) devrait marcher (si j'ai pas fais d'autre gaffes )

    bonne chance

  9. #9
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Ce code ne fonctionne pas non+.

    Au lieu de faire par les tableaux peux tu me donner la méthode avec les listes chainées

    Au cas ou voila ma structure

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    typedef struct Element Element;
    struct Element
    {
        SDL_Rect positionQueue;
        Element *suivant
    };
     
    typedef struct Liste Liste;
    struct Liste
    {
        Element *premier;
    };
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    Liste *initialisation()
    {
        Liste *liste = malloc(sizeof(*liste));
        Element *element = malloc(sizeof(*element));
     
        if(liste == NULL || element == NULL)
            exit(EXIT_FAILURE);
     
        element->positionQueue.x = 0;
        element->positionQueue.y = 0;
        element->suivant = NULL;
        liste->premier = element;
     
        return liste;
    }
     
    void ajouterEnTete(Liste *liste, SDL_Rect position)
    {
        Element *nouveau = malloc(sizeof(*nouveau));
        if(liste == NULL || nouveau == NULL)
            exit(EXIT_FAILURE);
     
        nouveau->positionQueue.x = position.x;
        nouveau->positionQueue.y = position.y;
     
        nouveau->suivant = liste->premier;
        liste->premier = nouveau;
    }
     
    void supprimerEnFin(Liste *liste, SDL_Rect position)
    {
        if(liste == NULL)
            exit(EXIT_FAILURE);
     
            Element *elementADepiler = liste->premier;
     
        if(elementADepiler->suivant == NULL)
        {
            free(elementADepiler);
        }
     
        while(elementADepiler->suivant != NULL);
     
        free(elementADepiler);
    }
    je vais coder une fonction afficher

  10. #10
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    En fait, pour bliter la je ne sais pas comment créer de fonction ca me soule grave quand meme u_U

  11. #11
    Membre Expert
    Avatar de méphistopheles
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    1 551
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 1 551
    Par défaut
    Citation Envoyé par qnop Voir le message
    Ce code ne fonctionne pas non+.
    Peux -tu être plus précis ? as-tu essayé de regarder ce qu'il y avait dans ton tableau ?

    Si tu ne règle pas ce problème avec un tableau statique, il y a peu de chances que ça marche mieux avec des struct chainées.

    Citation Envoyé par qnop Voir le message
    Au lieu de faire par les tableaux peux tu me donner la méthode avec les listes chainées

    Au cas ou voila ma structure
    je suis gentil, mais je ne suis pas là pour faire ton boulot à ta place.

    Si tu n'essaye pas de comprendre et de chercher un minimum, je n'ais pas l'intention d'en faire plus.

  12. #12
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Comment puis-je regarder ce qu'il il y a dans mon tableau(je n'ai pas appris a utiliser la SDL_TTF) pour mettre du texte

    Il y a toujours que le premier morceau qui s'affiche, mais les autres ne veulent pas s'afficher et sa m'énerve^^.

    Lorsque je disais la méthode, ce n'est pas le code que je demandais, je suis désolé que tu l'es pris comme ca.

    Cordialement Qnope

  13. #13
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Sinon, je ne sais pas si c utile ou si j'ai raison.

    Mais la queue ne suit pas réellement la tete.

    En gros imaginant que ma queue fasse 10 morceau, la queue resterait toujours droite.

  14. #14
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Ca y est, ma queue s'affiche enfin, mais elle reste droite



    et voici mon code

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    for(v = 0; v<NB_BLOCS_HAUTEUR * NB_BLOCS_LARGEUR; v++)
            {
                if(v == 0)
                {
                    if(snakeActu == snake[HAUT])
                    {
                        positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                        positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[BAS])
                    {
                        positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                        positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[GAUCHE])
                    {
                        positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                        positionQueue[0].y = positionJoueur.y * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[DROITE])
                    {
                        positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;
                        positionQueue[0].y = positionJoueur.y * TAILLE_CASE;
                    }
                }
                else
                {
                    if(snakeActu == snake[GAUCHE])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x + 1 * TAILLE_CASE;
                        positionQueue[v].y = positionQueue[v - 1].y;
                    }
     
                    if(snakeActu == snake[DROITE])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x - 1 * TAILLE_CASE;
                        positionQueue[v].y = positionQueue[v - 1].y;
                    }
     
                    if(snakeActu == snake[BAS])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x;
                        positionQueue[v].y = positionQueue[v - 1].y - 1 * TAILLE_CASE;
                    }
     
                    if(snakeActu == snake[HAUT])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x;
                        positionQueue[v].y = positionQueue[v - 1].y + 1 * TAILLE_CASE;
                    }
                }
            }
     
            for(v=0; v<taille; v++)
            SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
    Voila voila merci

  15. #15
    Membre Expert
    Avatar de méphistopheles
    Profil pro
    Inscrit en
    Janvier 2005
    Messages
    1 551
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : France

    Informations forums :
    Inscription : Janvier 2005
    Messages : 1 551
    Par défaut
    Salut.

    Apparement, tu n'as pas compris/lu ce que j'ai écrit auparavant:
    lorsque tu fais positionQueue[v].x = positionQueue[v - 1].x, en réalité, pour tout v positionQueue[v].x = positionQueue[0].x.

    Du coup rien d'étonnant à ce que ta queue reste droite. Ce que tu fais ici, c'est que tu redessine ta queue à partir de ta position joueur.... donc rien en fait.

    Sinon, je crois que je viens de trouver pourquoi le code que je t'avais posté avant ne fonctionne pas. tu l'aurais vu si tu avait pris la peine de le lire au lieu de le copier coller.

    à la fin, j'ai laissé le:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
            for (v = 1; v<taille; v++)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
    Ce qui annulle en fait le
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
            for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
    du début.

    essaye donc avec:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
            for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
            if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;
     
            SDL_Flip(screen);
    Si cela ne fonctionne(encore) pas, deux choses à faire:
    1. Vérifier que je n'ai pas fait d'autres erreurs bêtes
    2. Me montrer le reste du code, nottement l'initialisation de ton tableau de position.



    Bonnec chance .

  16. #16
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Citation Envoyé par méphistopheles Voir le message

    Apparement, tu n'as pas compris/lu ce que j'ai écrit auparavant:
    lorsque tu fais positionQueue[v].x = positionQueue[v - 1].x, en réalité, pour tout v positionQueue[v].x = positionQueue[0].x.
    Re salut a toi, si ca je l'ai compris mais je n'ai pas compris le code que tu me dis d'essayer, celon moi, il est fort possible que je me trompe, mais tu fais a peu près la même chose que moi, enfin je pense car quand tu fais

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }

    tu ne bouge pas la position, car tu fais que positionqueue[v] = a la meme position que celle d'avant^^

    Je pense aussi que tu n'as pas lis mon code en entier car quand tu me dis

    positionQueue[v].x = positionQueue[v - 1].x, en réalité, pour tout v positionQueue[v].x = positionQueue[0].x.

    je fais bien ce que tu me dis a peu près, car j'ai rajouter - TAILLE CASE si v est superieur a 1. (en esperant avoir ete clair )

    Ceci dit, j'ai penser a faire une succession d'if, je vais voir si cela fonctionne sinon, je te remercie de prendre la patience de m'aider^^

    Cordialement Qnope

  17. #17
    Membre confirmé
    Inscrit en
    Mars 2006
    Messages
    209
    Détails du profil
    Informations forums :
    Inscription : Mars 2006
    Messages : 209
    Par défaut
    Bon etant donner que je me suis emballer pour les if etc, je ne sais pas trop comment mi prendre

    Bon je te met mon code avec ma facon de bliter la queue et je te met le code avec ta facon, j'ai essayé de commenté mais je suis pas très douer^^
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    void play(SDL_Surface *screen)
    {
        SDL_Surface *snake[4] = {NULL};
        SDL_Surface *snakeActu = NULL, *mur = NULL, *orange= NULL, *pommeVerte = NULL, *queue = NULL;
        SDL_Rect positionJoueur, position;
        SDL_Rect positionQueue[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR] = {0};
        SDL_Event event;// on initialise tout
     
        int continuer = 1, i = 0, j = 0, objetRestant = 1, tempsActu = 0, tempsPrecedent = 0, v = 0, taille = 10;
        int map[NB_BLOCS_HAUTEUR][NB_BLOCS_LARGEUR] = {0};
     
        snake[BAS] = IMG_Load("Snake_Bas.bmp");
        snake[HAUT] = IMG_Load("Snake_Haut.bmp");
        snake[DROITE] = IMG_Load("Snake_Droit.bmp");
        snake[GAUCHE] = IMG_Load("Snake_Gauche.bmp");
        mur = IMG_Load("mur.png");
        orange = IMG_Load("Orange.bmp");
        pommeVerte = IMG_Load("PommeVerte.bmp");
        queue = IMG_Load("Snake_Queue.bmp");//on charge les images
     
        for (i = 0; i<4; i++)
            SDL_SetColorKey(snake[i] , SDL_SRCCOLORKEY, SDL_MapRGB(snake[i]-> format, 2, 0, 255));
        SDL_SetColorKey(orange, SDL_SRCCOLORKEY, SDL_MapRGB(orange-> format, 2, 0, 255));
        SDL_SetColorKey(pommeVerte, SDL_SRCCOLORKEY, SDL_MapRGB(pommeVerte-> format, 2, 0, 255));
        SDL_SetColorKey(queue, SDL_SRCCOLORKEY, SDL_MapRGB(queue-> format, 2, 0, 255));// on rend tout transparent
     
        snakeActu = snake[BAS];// on commence par partir vers le bas
     
        if(!loadLevel(map))// on charge la map
            return 0;
     
        for (i=0; i<NB_BLOCS_LARGEUR; i++)
        {
            for(j=0; j<NB_BLOCS_HAUTEUR; j++)
            {
                if(map[i][j] == TETE)
                {
                    positionJoueur.x = i;
                    positionJoueur.y = j;
                    map[i][j] = VIDE;
                }
            }
        }//On recherche la positition dujoueur
     
        SDL_EnableKeyRepeat (100, 100);
     
        while(continuer)
        {
            tempsActu = SDL_GetTicks();
            objetRestant = 0;
            SDL_PollEvent(&event);
     
            switch(event.type)
            {
                case SDL_QUIT:
                    continuer = 0;
                break;
     
                case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                    break;
     
                    case SDLK_UP:
                        snakeActu = snake[HAUT];
                    break;
     
                    case SDLK_DOWN:
                        snakeActu = snake[BAS];
                    break;
     
                    case SDLK_LEFT:
                        snakeActu = snake[GAUCHE];
                    break;
     
                    case SDLK_RIGHT:
                        snakeActu = snake[DROITE];
                    break;// on place le snake dans une certaine direction
     
                    default:
                    break;
                }
     
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[HAUT])
            {
                moveSnake(map, &positionJoueur, HAUT);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[BAS])
            {
                moveSnake(map, &positionJoueur, BAS);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[GAUCHE])
            {
                moveSnake(map, &positionJoueur, GAUCHE);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[DROITE])// on le fait bouger^^
            {
                moveSnake(map, &positionJoueur, DROITE);
                tempsPrecedent = tempsActu;
            }
     
            SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 178, 200));// on efface l'ecran a chaque tour de boucle
     
            for(i=0; i<NB_BLOCS_LARGEUR; i++)
            {
                for(j=0; j<NB_BLOCS_HAUTEUR; j++)
                {
                    position.x = i * TAILLE_CASE;
                    position.y = j * TAILLE_CASE;
     
                    switch(map[i][j])
                    {
                        case MUR:
                            SDL_BlitSurface(mur, NULL, screen, &position);
                        break;
     
                        case ORANGE:
                            SDL_BlitSurface(orange, NULL, screen, &position);
                            objetRestant = 1;// on met objet Restant a 1 si il reste des objets
                        break;
     
                        case POMME_VERTE:
                            SDL_BlitSurface(pommeVerte, NULL, screen, &position);
                        break;//On blit tous les objets
                    }
                }
            }
     
            position.x = positionJoueur.x * TAILLE_CASE;
            position.y = positionJoueur.y * TAILLE_CASE;
     
            for(v = 0; v<NB_BLOCS_HAUTEUR * NB_BLOCS_LARGEUR; v++)
            {
                if(v == 0)
                {
                    if(snakeActu == snake[HAUT])
                    {
                        positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                        positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[BAS])
                    {
                        positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                        positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[GAUCHE])
                    {
                        positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                        positionQueue[0].y = positionJoueur.y * TAILLE_CASE;
                    }
     
                    else if(snakeActu == snake[DROITE])
                    {
                        positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;
                        positionQueue[0].y = positionJoueur.y * TAILLE_CASE;
                    }
                }
                else
                {
                    if(snakeActu == snake[GAUCHE])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x + 1 * TAILLE_CASE;
                        positionQueue[v].y = positionQueue[v - 1].y;
                    }
     
                    if(snakeActu == snake[DROITE])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x - 1 * TAILLE_CASE;
                        positionQueue[v].y = positionQueue[v - 1].y;
                    }
     
                    if(snakeActu == snake[BAS])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x;
                        positionQueue[v].y = positionQueue[v - 1].y - 1 * TAILLE_CASE;
                    }
     
                    if(snakeActu == snake[HAUT])
                    {
                        positionQueue[v].x = positionQueue[v - 1].x;
                        positionQueue[v].y = positionQueue[v - 1].y + 1 * TAILLE_CASE;
                    }
                }
            }// On place la queue a ma facon(qui n'est pas terrible^^)
     
            for(v=0; v<taille; v++)
            SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            SDL_Flip(screen);// On blit le tout
     
            if(!objetRestant)
                continuer = 0;// si il n'y a plus d'objet on arrete et on a gaggner^^
        }
     
        SDL_FreeSurface(snakeActu);
        SDL_FreeSurface(queue);
        SDL_FreeSurface(mur);
        SDL_FreeSurface(pommeVerte);
        SDL_FreeSurface(orange);
     
        for ( i=0; i<4; i++)
            SDL_FreeSurface(snake[i]);
    }
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    void play(SDL_Surface *screen)
    {
        SDL_Surface *snake[4] = {NULL};
        SDL_Surface *snakeActu = NULL, *mur = NULL, *orange= NULL, *pommeVerte = NULL, *queue = NULL;
        SDL_Rect positionJoueur, position;
        SDL_Rect positionQueue[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR] = {0};
        SDL_Event event;// on initialise tout
     
        int continuer = 1, i = 0, j = 0, objetRestant = 1, tempsActu = 0, tempsPrecedent = 0, v = 0, taille = 10;
        int map[NB_BLOCS_HAUTEUR][NB_BLOCS_LARGEUR] = {0};
     
        snake[BAS] = IMG_Load("Snake_Bas.bmp");
        snake[HAUT] = IMG_Load("Snake_Haut.bmp");
        snake[DROITE] = IMG_Load("Snake_Droit.bmp");
        snake[GAUCHE] = IMG_Load("Snake_Gauche.bmp");
        mur = IMG_Load("mur.png");
        orange = IMG_Load("Orange.bmp");
        pommeVerte = IMG_Load("PommeVerte.bmp");
        queue = IMG_Load("Snake_Queue.bmp");//on charge les images
     
        for (i = 0; i<4; i++)
            SDL_SetColorKey(snake[i] , SDL_SRCCOLORKEY, SDL_MapRGB(snake[i]-> format, 2, 0, 255));
        SDL_SetColorKey(orange, SDL_SRCCOLORKEY, SDL_MapRGB(orange-> format, 2, 0, 255));
        SDL_SetColorKey(pommeVerte, SDL_SRCCOLORKEY, SDL_MapRGB(pommeVerte-> format, 2, 0, 255));
        SDL_SetColorKey(queue, SDL_SRCCOLORKEY, SDL_MapRGB(queue-> format, 2, 0, 255));// on rend tout transparent
     
        snakeActu = snake[BAS];// on commence par partir vers le bas
     
        if(!loadLevel(map))// on charge la map
            return 0;
     
        for (i=0; i<NB_BLOCS_LARGEUR; i++)
        {
            for(j=0; j<NB_BLOCS_HAUTEUR; j++)
            {
                if(map[i][j] == TETE)
                {
                    positionJoueur.x = i;
                    positionJoueur.y = j;
                    map[i][j] = VIDE;
                }
            }
        }//On recherche la positition dujoueur
     
        SDL_EnableKeyRepeat (100, 100);
     
        while(continuer)
        {
            tempsActu = SDL_GetTicks();
            objetRestant = 0;
            SDL_PollEvent(&event);
     
            switch(event.type)
            {
                case SDL_QUIT:
                    continuer = 0;
                break;
     
                case SDL_KEYDOWN:
                switch(event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        continuer = 0;
                    break;
     
                    case SDLK_UP:
                        snakeActu = snake[HAUT];
                    break;
     
                    case SDLK_DOWN:
                        snakeActu = snake[BAS];
                    break;
     
                    case SDLK_LEFT:
                        snakeActu = snake[GAUCHE];
                    break;
     
                    case SDLK_RIGHT:
                        snakeActu = snake[DROITE];
                    break;// on place le snake dans une certaine direction
     
                    default:
                    break;
                }
     
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[HAUT])
            {
                moveSnake(map, &positionJoueur, HAUT);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[BAS])
            {
                moveSnake(map, &positionJoueur, BAS);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[GAUCHE])
            {
                moveSnake(map, &positionJoueur, GAUCHE);
                tempsPrecedent = tempsActu;
            }
     
            if(tempsActu - tempsPrecedent > 100 && snakeActu == snake[DROITE])// on le fait bouger^^
            {
                moveSnake(map, &positionJoueur, DROITE);
                tempsPrecedent = tempsActu;
            }
     
            SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 100, 178, 200));// on efface l'ecran a chaque tour de boucle
     
            for(i=0; i<NB_BLOCS_LARGEUR; i++)
            {
                for(j=0; j<NB_BLOCS_HAUTEUR; j++)
                {
                    position.x = i * TAILLE_CASE;
                    position.y = j * TAILLE_CASE;
     
                    switch(map[i][j])
                    {
                        case MUR:
                            SDL_BlitSurface(mur, NULL, screen, &position);
                        break;
     
                        case ORANGE:
                            SDL_BlitSurface(orange, NULL, screen, &position);
                            objetRestant = 1;// on met objet Restant a 1 si il reste des objets
                        break;
     
                        case POMME_VERTE:
                            SDL_BlitSurface(pommeVerte, NULL, screen, &position);
                        break;//On blit tous les objets
                    }
                }
            }
     
            position.x = positionJoueur.x * TAILLE_CASE;
            position.y = positionJoueur.y * TAILLE_CASE;
     
            for (v = taille-1; v!=0; --v)
            {
                positionQueue[v].x = positionQueue[v-1].x;
                positionQueue[v].y = positionQueue[v-1].y;
            }
            if(snakeActu == snake[DROITE])
            {
                positionQueue[0].x = (positionJoueur.x - 1) * TAILLE_CASE;//si a droite on place le premier morceau
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[GAUCHE])//si a gauche on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x + 1) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[HAUT])//si en haut on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y + 1) * TAILLE_CASE;
            }
     
            else if(snakeActu == snake[BAS])//si en bas on place le premier morceau
            {
                positionQueue[0].x = (positionJoueur.x) * TAILLE_CASE;
                positionQueue[0].y = (positionJoueur.y - 1) * TAILLE_CASE;
            }
     
            SDL_BlitSurface(snakeActu, NULL, screen, &position);
     
            for (v = 0; v<taille; v++)
                SDL_BlitSurface(queue, NULL, screen, &positionQueue[v]);
     
            if(!objetRestant)
                continuer = 0;//On arrete si il n'y a plus d'objet restant
     
            SDL_Flip(screen);
        }
     
        SDL_FreeSurface(snakeActu);
        SDL_FreeSurface(queue);
        SDL_FreeSurface(mur);
        SDL_FreeSurface(pommeVerte);
        SDL_FreeSurface(orange);
     
        for ( i=0; i<4; i++)
            SDL_FreeSurface(snake[i]);
    }
    Je tiens a préciser que je n'ai pas encore fait pour l'augmentation de la queue et je n'ai pas mis mes fonctions de déplacement

    Cordialement Qnope

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Conception] Queue avec priorité
    Par Mobius dans le forum Général Java
    Réponses: 4
    Dernier message: 11/04/2005, 08h26
  2. [TP][Projet] Réaliser un Snake-Like
    Par Giovanny Temgoua dans le forum Turbo Pascal
    Réponses: 69
    Dernier message: 17/01/2005, 18h04
  3. Réponses: 6
    Dernier message: 14/01/2005, 10h36
  4. STL iterateur pour queue
    Par Mathieu.Nanoux dans le forum SL & STL
    Réponses: 2
    Dernier message: 05/11/2004, 00h35
  5. Gérer les queue avec sql server ?
    Par devdev dans le forum MS SQL Server
    Réponses: 8
    Dernier message: 17/06/2004, 17h38

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo