[Résolu] Fonctions non reconnues par Admiral_Sydor - page 1

Bonjour à tous,

Je suis actuellement le cours de programmation en C de Matéo. Je suis rendu au chapitre de la SDL, au TP de Mario Sokoban. Ayant reproduit assez fidèlement le code de Matéo, je me suis heurté à quelques erreurs lors de la première compilation. Des erreurs bénignes pour la plupart, que j'ai aisément corrigées, mais 2 d'entre elles me posent problème. Tout d'abord, voici le code des fichiers concernés:

main.c

#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include "Constantes.h"
#include "Jeu.h"
#include "Editeur.h"

int main (int argc, char** argv)
{
    SDL_Surface *Ecran = NULL, *Menu = NULL;
    SDL_Rect Position_Menu;
    SDL_Event Event;

    int Continuer = 1;

    if (SDL_Init(SDL_INIT_VIDEO) > 0)
    {
        fprintf(stderr, "Erreur lors de l'initialisation de la SDL: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    SDL_WM_SetIcon(IMG_Load("Images/Caisse.jpg"), NULL);
    Ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Mario Sokoban", NULL);

    if (Ecran == NULL)
    {
        fprintf(stderr, "Erreur lors de l'initialisation du mode video: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    Menu = IMG_Load("Images/Menu.jpg");
    Position_Menu.x = 0;
    Position_Menu.y = 0;

    while (Continuer) // Boucle du menu
    {
        SDL_WaitEvent(&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_KP1:
                        Continuer = jouer(Ecran); // Première erreur ici
                        break;

                    case SDLK_KP2:
                        Continuer = editer(Ecran); // Deuxième erreur ici
                        break;
                }
                break;
        }

        SDL_FillRect(Ecran, NULL, SDL_MapRGB(Ecran->format, 0, 0, 0));
        SDL_BlitSurface(Menu, NULL, Ecran, &Position_Menu);
        SDL_Flip(Ecran);
    }

    SDL_FreeSurface(Menu);
    SDL_Quit();

    return EXIT_SUCCESS;
}

Jeu.c

#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include "Constantes.h"
#include "Jeu.h"

int jouer(SDL_Surface* Ecran)
{
    SDL_Surface *Mario[4] = {NULL};
    SDL_Surface *Mur = NULL, *Caisse = NULL, *Caisse_OK = NULL, *Objectif = NULL, *Mario_Actuel = NULL;
    SDL_Rect Position, Position_Joueur;
    SDL_Event Event;

    int Continuer = 1, Continuer_Programme = 1, Objectifs_Restants = 0;
    int Carte[NOMBRE_BLOCS_LARGEUR][NOMBRE_BLOCS_HAUTEUR] = {0};

    long i = 0, ii = 0;

    Mur = IMG_Load("Images/Mur.jpg");
    Caisse = IMG_Load("Images/Caisse.jpg");
    Caisse_OK = IMG_Load("Images/Caisse_OK.jpg");
    Objectif = IMG_Load("Images/Objectif.png");
    Mario[HAUT] = IMG_Load("Images/Mario_Haut.gif");
    Mario[BAS] = IMG_Load("Images/Mario_Bas.gif");
    Mario[GAUCHE] = IMG_Load("Images/Mario_Gauche.gif");
    Mario[DROITE] = IMG_Load("Images/Mario_Droite.gif");

    Mario_Actuel = Mario[BAS];

    if (!charger_niveau(Carte))
    {
        fprintf(stderr, "Erreur lors du chargement du niveau: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    for (i = 0 ; i < NOMBRE_BLOCS_LARGEUR ; i++)
    {
        for (ii = 0 ; ii < NOMBRE_BLOCS_HAUTEUR ; ii++)
        {
            if (Carte[i][ii] == MARIO)
            {
                Position_Joueur.x = i;
                Position_Joueur.y = ii;
                Carte[i][ii] = VIDE;
            }
        }
    }

    SDL_EnableKeyRepeat(100, 100);

    while (Continuer)
    {
        SDL_WaitEvent(&Event);

        switch (Event.type)
        {
            case SDL_QUIT:
                Continuer = 0;
                Continuer_Programme = 0;
                break;

            case SDL_KEYDOWN:
                switch (Event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        Continuer = 0;
                        break;

                    case SDLK_UP:
                        Mario_Actuel = Mario[HAUT];
                        deplacer_joueur(Carte, &Position_Joueur, HAUT);
                        break;

                    case SDLK_DOWN:
                        Mario_Actuel = Mario[BAS];
                        deplacer_joueur(Carte, &Position_Joueur, BAS);
                        break;

                    case SDLK_LEFT:
                        Mario_Actuel = Mario[GAUCHE];
                        deplacer_joueur(Carte, &Position_Joueur, GAUCHE);
                        break;

                    case SDLK_RIGHT:
                        Mario_Actuel = Mario[DROITE];
                        deplacer_joueur(Carte, &Position_Joueur, DROITE);
                        break;
                }
                break;
        }

        SDL_FillRect(Ecran, NULL, SDL_MapRGB(Ecran->format, 255, 255, 255));
        Objectifs_Restants = 0;

        for (i = 0 ; i < NOMBRE_BLOCS_LARGEUR ; i++)
        {
            for (ii = 0 ; ii < NOMBRE_BLOCS_HAUTEUR ; ii++)
            {
                Position.x = i * TAILLE_BLOC;
                Position.y = ii * TAILLE_BLOC;

                switch (Carte[i][ii])
                {
                    case MUR:
                        SDL_BlitSurface(Mur, NULL, Ecran, &Position);
                        break;

                    case CAISSE:
                        SDL_BlitSurface(Caisse, NULL, Ecran, &Position);
                        break;

                    case CAISSE_OK:
                        SDL_BlitSurface(Caisse_OK, NULL, Ecran, &Position);
                        break;

                    case OBJECTIF:
                        Objectifs_Restants = 1;
                        SDL_BlitSurface(Objectif, NULL, Ecran, &Position);
                        break;
                }
            }
        }

        if (!Objectifs_Restants)
        {
            Continuer = 0;
        }

        Position.x = Position_Joueur.x * TAILLE_BLOC;
        Position.y = Position_Joueur.y * TAILLE_BLOC;
        SDL_BlitSurface(Mario_Actuel, NULL, Ecran, &Position);

        SDL_Flip(Ecran);
    }

    SDL_EnableKeyRepeat(0, 0);

    SDL_FreeSurface(Mur);
    SDL_FreeSurface(Caisse);
    SDL_FreeSurface(Caisse_OK);
    SDL_FreeSurface(Objectif);

    for (i = 0 ; i < 4 ; i++)
    {
        SDL_FreeSurface(Mario[i]);
    }

    return Continuer_Programme;
}

void deplacer_joueur(int Carte[][NOMBRE_BLOCS_HAUTEUR], SDL_Rect* Position, int Direction)
{
    switch (Direction)
    {
        case HAUT:
            if (Position->y - 1 < 0)
                break;

            if (Carte[Position->x][Position->y - 1] == MUR)
                break;

            if ((Carte[Position->x][Position->y - 1] == CAISSE ||
            Carte[Position->x][Position->y - 1] == CAISSE_OK) && (Position->y - 2 < 0 ||
            Carte[Position->x][Position->y - 2] == MUR || Carte[Position->x][Position->y - 2] == CAISSE
            || Carte[Position->x][Position->y - 2] == CAISSE_OK))
                break;

            deplacer_caisse(&Carte[Position->x][Position->y - 1], &Carte[Position->x][Position->y - 2]);

            Position->y--;
            break;

        case BAS:
            if (Position->y + 1 > (NOMBRE_BLOCS_HAUTEUR - 1))
                break;

            if (Carte[Position->x][Position->y + 1] == MUR)
                break;

            if ((Carte[Position->x][Position->y + 1] == CAISSE ||
            Carte[Position->x][Position->y + 1] == CAISSE_OK) && (Position->y + 2 < 0 ||
            Carte[Position->x][Position->y + 2] == MUR || Carte[Position->x][Position->y + 2] == CAISSE
            || Carte[Position->x][Position->y + 2] == CAISSE_OK))
                break;

            deplacer_caisse(&Carte[Position->x][Position->y + 1], &Carte[Position->x][Position->y + 2]);

            Position->y++;
            break;

        case GAUCHE:
            if (Position->x - 1 < 0)
                break;

            if (Carte[Position->x - 1][Position->y] == MUR)
                break;

            if ((Carte[Position->x - 1][Position->y] == CAISSE ||
            Carte[Position->x - 1][Position->y] == CAISSE_OK) && (Position->x - 2 < 0 ||
            Carte[Position->x - 2][Position->y] == MUR || Carte[Position->x - 2][Position->y] == CAISSE
            || Carte[Position->x - 2][Position->y] == CAISSE_OK))
                break;

            deplacer_caisse(&Carte[Position->x - 1][Position->y], &Carte[Position->x - 2][Position->y]);

            Position->x--;
            break;

        case DROITE:
            if (Position->x + 1 > (NOMBRE_BLOCS_LARGEUR - 1));
                break;

            if (Carte[Position->x + 1][Position->y] == MUR)
                break;

            if ((Carte[Position->x + 1][Position->y] == CAISSE ||
            Carte[Position->x + 1][Position->y] == CAISSE_OK) && (Position->x + 2 < 0 ||
            Carte[Position->x + 2][Position->y] == MUR || Carte[Position->x + 2][Position->y] == CAISSE
            || Carte[Position->x + 2][Position->y] == CAISSE_OK))
                break;

            deplacer_caisse(&Carte[Position->x + 1][Position->y], &Carte[Position->x + 2][Position->y]);

            Position->x++;
            break;
    }
}

void deplacer_caisse(int* Premiere_Case, int* Seconde_Case)
{
    if (*Premiere_Case == CAISSE || *Premiere_Case == CAISSE_OK)
    {
        if (*Seconde_Case == OBJECTIF)
            *Seconde_Case = CAISSE_OK;
        else
            *Seconde_Case = CAISSE;

        if (*Premiere_Case == CAISSE_OK)
            *Premiere_Case = OBJECTIF;
        else
            *Premiere_Case = VIDE;
    }
}

Jeu.h

#ifndef JEU_H_INCLUDED
#define JEU_H_INCLUDED

int jouer(SDL_Surface* Ecran);

void deplacer_joueur(int Carte[][NOMBRE_BLOCS_HAUTEUR], SDL_Rect* Position, int Direction);

void deplacer_caisse(int* Premiere_Case, int* Seconde_Case);

#endif // JEU_H_INCLUDED

Editeur.c

#include <stdio.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

#include "Constantes.h"
#include "Editeur.h"

int editer(SDL_Surface* Ecran)
{
    SDL_Surface *Mur = NULL, *Caisse = NULL, *Caisse_OK = NULL, *Objectif = NULL, *Mario = NULL;
    SDL_Rect Position;
    SDL_Event Event;

    int Continuer = 1, Continuer_Programme = 1, Clic_Gauche_Enfonce = 0, Clic_Droit_Enfonce = 0;
    int Carte[NOMBRE_BLOCS_LARGEUR][NOMBRE_BLOCS_HAUTEUR] = {0};
    int Objet_Actuel = MUR;

    long i = 0, ii = 0;

    Mur = IMG_Load("Images/Mur.jpg");
    Caisse = IMG_Load("Images/Caisse.jpg");
    Caisse_OK = IMG_Load("Images/Caisse_OK.jpg");
    Objectif = IMG_Load("Images/Objectif.png");
    Mario = IMG_Load("Images/Mario_Bas.gif");

    if (!charger_niveau(Ecran))
    {
        fprintf(stderr, "Erreur lors du chargement du niveau: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    while (Continuer)
    {
        SDL_WaitEvent(&Event);

        switch (Event.type)
        {
            case SDL_QUIT:
                Continuer = 0;
                Continuer_Programme = 0;
                break;

            case SDL_MOUSEBUTTONDOWN:
                switch (Event.button.button)
                {
                    case SDL_BUTTON_LEFT:
                        Clic_Gauche_Enfonce = 1;
                        Carte[Event.button.x / TAILLE_BLOC][Event.button.y / TAILLE_BLOC] = Objet_Actuel;
                        break;

                    case SDL_BUTTON_RIGHT:
                        Clic_Droit_Enfonce = 1;
                        Carte[Event.button.x / TAILLE_BLOC][Event.button.y / TAILLE_BLOC] = VIDE;
                        break;
                }
                break;

            case SDL_MOUSEBUTTONUP:
                switch (Event.button.button)
                {
                    case SDL_BUTTON_LEFT:
                        Clic_Gauche_Enfonce = 0;
                        break;

                    case SDL_BUTTON_RIGHT:
                        Clic_Droit_Enfonce = 0;
                        break;
                }
                break;

            case SDL_KEYDOWN:
                switch (Event.key.keysym.sym)
                {
                    case SDLK_ESCAPE:
                        Continuer = 0;
                        break;

                    case SDLK_1:
                        Objet_Actuel = MUR;
                        break;

                    case SDLK_2:
                        Objet_Actuel = CAISSE;
                        break;

                    case SDLK_3:
                        Objet_Actuel = CAISSE_OK;
                        break;

                    case SDLK_4:
                        Objet_Actuel = OBJECTIF;
                        break;

                    case SDLK_5:
                        Objet_Actuel = MARIO;
                        break;

                    case SDLK_s:
                        if (!sauvegarder_niveau(Carte))
                        {
                            fprintf(stderr, "Erreur lors de la sauvegarde du niveau: %s\n", SDL_GetError());
                            exit(EXIT_FAILURE);
                        }
                        break;

                    case SDLK_l:
                        if (!charger_niveau(Carte))
                        {
                            fprintf(stderr, "Erreur lors du chargement du niveau: %s\n", SDL_GetError());
                            exit(EXIT_FAILURE);
                        }
                        break;
                }
                break;
        }

        SDL_FillRect(Ecran, NULL, SDL_MapRGB(Ecran->format, 255, 255, 255));

        for (i = 0 ; i < NOMBRE_BLOCS_LARGEUR ; i++)
        {
            for (ii = 0 ; ii < NOMBRE_BLOCS_HAUTEUR ; ii++)
            {
                Position.x = i * TAILLE_BLOC;
                Position.y = ii * TAILLE_BLOC;

                switch (Carte[i][ii])
                {
                    case MUR:
                        SDL_BlitSurface(Mur, NULL, Ecran, &Position);
                        break;

                    case CAISSE:
                        SDL_BlitSurface(Caisse, NULL, Ecran, &Position);
                        break;

                    case CAISSE_OK:
                        SDL_BlitSurface(Caisse_OK, NULL, Ecran, &Position);
                        break;

                    case OBJECTIF:
                        SDL_BlitSurface(Objectif, NULL, Ecran, &Position);
                        break;

                    case MARIO:
                        SDL_BlitSurface(Mario, NULL, Ecran, &Position);
                        break;
                }
            }
        }

        SDL_Flip(Ecran);
    }

    SDL_FreeSurface(Mur);
    SDL_FreeSurface(Caisse);
    SDL_FreeSurface(Caisse_OK);
    SDL_FreeSurface(Mario);
    SDL_FreeSurface(Objectif);

    return Continuer_Programme;
}

Editeur.h

#ifndef EDITEUR_H_INCLUDED
#define EDITEUR_H_INCLUDED

int editer(SDL_Surface* Ecran);

#endif // EDITEUR_H_INCLUDED

Lors de la compilation, je reçois 2 erreurs dans mon main.c:
(Ligne 56) undefined reference to `jouer(SDL_Surface*)'
(Ligne 60) undefined reference to `editer(SDL_Surface*)'

J'ai recherché des cas semblables dans les forums mais je n'ai pas trouvé de solution à mon problème. Si quelqu'un pouvait m'aider ce serait très apprécié :lol:

. Merci d'avance.

Admiral_Sydor

11 août 2008 à 0:28:07

chlablak

11 août 2008 à 0:33:29

Jeu.c et Editeur.c ne sont pas compilés (pas dans ton projet ou sinon fait un Rebuild All)

C++ Références | Idiomes | FAQ

11 août 2008 à 0:37:52

J'ai vérifié que Jeu.c et Editeur.c sont bien dans mon projet et ils le sont. J'ai aussi essayé de faire un Rebuild mais j'ai encore les erreurs

11 août 2008 à 0:39:28

Quel compilateur as-tu (la version aussi) ?

11 août 2008 à 0:43:00

J'utilise GNU GCC Compiler. Pour la version désolé mais je ne sais pas où la trouver :-°

11 août 2008 à 0:52:40

A non désolé c'est l'IDE qu'il me faut (avec la version).

11 août 2008 à 0:53:47

J'utilise Code::Blocks 8.02.

11 août 2008 à 1:00:50

(De tête)

Clique droit sur [Editeur|Jeu].c => Options de compilation (un truc du style) => Je ne sais plus quel onglet => coche "Build this file" et "Link this file"

ps: Avec CB 8.02, lorsque tu ajoute un fichier, il te demande si tu veux le compiler et le linker (sous forme de case à cocher)

11 août 2008 à 1:04:27

Malheureusement tout est déjà coché

11 août 2008 à 1:24:08

tu es sûr d'avoir fait un "rebuild all" ? C'est une erreur du linker, tes fichiers ne sont pas compilés (.o).

Voilà c'est tout ce que je peux faire, bonne nuit.

11 août 2008 à 1:54:00

Pourtant lorsque je regarde dans le dossier de mon projet, dans le dossier obj, dans Debug et dans Release, j'ai tous mes fichiers.o (main.o, Jeu.o, Editeur.o et Niveaux.o).

Edit: C'est bon mon problème est réglé. En fait c'était une erreur stupide, j'avais mal regardé mon main et je n'avais pas remarqué que c'était un fichier C++. J'ai changé l'extension, fait un rebuild et tout fonctionne. Merci quand même de tes réponses

Antolomo

13 août 2008 à 13:01:57

mon message sert à rien, mais je te remercie juste, parce que j'avais le même problème, et je l'ai résolu grâce à toi

Fonctions non reconnues

Fonctions non reconnues

Supprimer

Modérer

Signaler le message aux modérateurs