Partage

Probleme pour le mario sokoban !

19 décembre 2006 à 23:10:37

bonsoir.

j'ai commencé le mario sokoban cette apres midi et je l'ai finis, je compile, l'ecran du menu s'affiche et pour essayer le jeu j'appui sur "1" et la fenetre se ferme, je pense avoir fait une petite erreur mais aidez moi !!!

constantes.h

/*
constantes.h
––––––––––––

Par kudo2.

Rôle : définit des constantes communes à tout le programme (taille de la fenêtre...)
*/

#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES

#define TAILLE_BLOC 34 // Taille d'un bloc (carré) en pixels
#define NB_BLOCS_LARGEUR 12
#define NB_BLOCS_HAUTEUR 12
#define LARGEUR_FENETRE TAILLE_BLOC * NB_BLOCS_LARGEUR
#define HAUTEUR_FENETRE TAILLE_BLOC * NB_BLOCS_HAUTEUR

enum {HAUT‚ BAS‚ GAUCHE‚ DROITE};
enum {VIDE‚ MUR‚ CAISSE‚ OBJECTIF‚ MARIO‚ CAISSE_OK};

#endif

editeur.h

void editeur(SDL_Surface* ecran);

fichiers.h

int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR]);
int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR]);

jeu.h

void jouer(SDL_Surface* ecran);
void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR]‚ SDL_Rect *pos‚ int direction);
void deplacerCaisse(int *premiereCase‚ int *secondeCase);

main.c

/*
main.c
––––––

Par kudo2

Rôle : menu du jeu. Permet de choisir entre l'éditeur et le jeu lui–même.
*/

#include <stdlib.h>
#include <stdio.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 positionMenu;
SDL_Event event;

int continuer = 1;

SDL_Init(SDL_INIT_VIDEO);

SDL_WM_SetIcon(IMG_Load("caisse.jpg")‚ NULL); // L'icône doit être chargée avant SDL_SetVideoMode
ecran = SDL_SetVideoMode(LARGEUR_FENETRE‚ HAUTEUR_FENETRE‚ 32‚ SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Mario Sokoban"‚ NULL);

menu = IMG_Load("menu.jpg");
positionMenu.x = 0;
positionMenu.y = 0;

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE: // Veut arrêter le jeu
continuer = 0;
break;
case SDLK_KP1: // Demande à jouer
jouer(ecran);
break;
case SDLK_KP2: // Demande l'éditeur de niveaux
editeur(ecran);
break;
}
break;
}

// Effacement de l'écran
SDL_FillRect(ecran‚ NULL‚ SDL_MapRGB(ecran–>format‚ 0‚ 0‚ 0));
SDL_BlitSurface(menu‚ NULL‚ ecran‚ &positionMenu);
SDL_Flip(ecran);
}

SDL_FreeSurface(menu);
SDL_Quit();

return EXIT_SUCCESS;
}

jeu.c

/*
jeu.c
–––––

Par kudo2

Rôle : fonctions du jeu.
*/

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

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

void jouer(SDL_Surface* ecran)
{
SDL_Surface *mario[4] = {NULL}; // 4 surfaces pour chacune des directions de mario
SDL_Surface *mur = NULL‚ *caisse = NULL‚ *caisseOK = NULL‚ *objectif = NULL‚ *marioActuel = NULL;
SDL_Rect position‚ positionJoueur;
SDL_Event event;

SDL_BlitSurface(marioActuel‚ NULL‚ ecran‚ &position);

int continuer = 1‚ objectifsRestants = 0‚ i = 0‚ j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

// Chargement des sprites (décors‚ personnage...)
mur = IMG_Load("mur.jpg");
caisse = IMG_Load("caisse.jpg");
caisseOK = IMG_Load("caisse_ok.jpg");
objectif = IMG_Load("objectif.png");
mario[BAS] = IMG_Load("mario_bas.gif");
mario[GAUCHE] = IMG_Load("mario_gauche.gif");
mario[HAUT] = IMG_Load("mario_haut.gif");
mario[DROITE] = IMG_Load("mario_droite.gif");

marioActuel = mario[BAS]; // Mario sera dirigé vers le bas au départ

// Chargement du niveau
if (!chargerNiveau(carte))
exit(EXIT_FAILURE); // On arrête le jeu si on n'a pas pu charger le niveau

// Recherche de la position de Mario au départ
for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
{
if (carte[i][j] == MARIO) // Si Mario se trouve à cette position sur la carte
{
positionJoueur.x = i;
positionJoueur.y = j;
carte[i][j] = VIDE;
}
}
}
// Activation de la répétition des touches
SDL_EnableKeyRepeat(100‚ 100);

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:
marioActuel = mario[HAUT];
deplacerJoueur(carte‚ &positionJoueur‚ HAUT);
break;
case SDLK_DOWN:
marioActuel = mario[BAS];
deplacerJoueur(carte‚ &positionJoueur‚ BAS);
break;
case SDLK_RIGHT:
marioActuel = mario[DROITE];
deplacerJoueur(carte‚ &positionJoueur‚ DROITE);
break;
case SDLK_LEFT:
marioActuel = mario[GAUCHE];
deplacerJoueur(carte‚ &positionJoueur‚ GAUCHE);
break;
}
break;
}
// Effacement de l'écran
SDL_FillRect(ecran‚ NULL‚ SDL_MapRGB(ecran–>format‚ 255‚ 255‚ 255));

// Placement des objets à l'écran
objectifsRestants = 0;

for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

switch(carte[i][j])
{
case MUR:
SDL_BlitSurface(mur‚ NULL‚ ecran‚ &position);
break;
case CAISSE:
SDL_BlitSurface(caisse‚ NULL‚ ecran‚ &position);
break;
case CAISSE_OK:
SDL_BlitSurface(caisseOK‚ NULL‚ ecran‚ &position);
break;
case OBJECTIF:
SDL_BlitSurface(objectif‚ NULL‚ ecran‚ &position);
objectifsRestants = 1;
break;
}
}
}
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

// Si on n'a trouvé aucun objectif sur la carte‚ c'est qu'on a gagné
if (!objectifsRestants)
continuer = 0;

// On place le joueur à la bonne position
position.x = positionJoueur.x * TAILLE_BLOC;
position.y = positionJoueur.y * TAILLE_BLOC;
SDL_BlitSurface(marioActuel‚ NULL‚ ecran‚ &position);

SDL_Flip(ecran); // mise a jour de l'ecran

// Désactivation de la répétition des touches (remise à 0)
SDL_EnableKeyRepeat(0‚ 0);

// Libération des surfaces chargées
SDL_FreeSurface(mur);
SDL_FreeSurface(caisse);
SDL_FreeSurface(caisseOK);
SDL_FreeSurface(objectif);
for (i = 0 ; i < 4 ; i++)
SDL_FreeSurface(mario[i]);
}

void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR]‚ SDL_Rect *pos‚ int direction)
{
switch(direction)
{
case HAUT:
if (pos–>y – 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>y – 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>y – 1] == CAISSE || carte[pos–>x][pos–>y – 1] == CAISSE_OK) &&
(pos–>y – 2 < 0 || carte[pos–>x][pos–>y – 2] == MUR ||
carte[pos–>x][pos–>y – 2] == CAISSE || carte[pos–>x][pos–>y – 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>y – 1]‚ &carte[pos–>x][pos–>y – 2]);

pos–>y––; // On peut enfin faire monter le joueur (oufff !)
break;

case BAS:
if (pos–>y + 1 > 12) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>y + 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>y + 1] == CAISSE || carte[pos–>x][pos–>y + 1] == CAISSE_OK) &&
(pos–>y + 2 < 0 || carte[pos–>x][pos–>y + 2] == MUR ||
carte[pos–>x][pos–>y + 2] == CAISSE || carte[pos–>x][pos–>y + 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>y + 1]‚ &carte[pos–>x][pos–>y + 2]);

pos–>y++; // On peut enfin faire descendre le joueur (oufff !)
break;

case GAUCHE:
if (pos–>x – 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>x – 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>x – 1] == CAISSE || carte[pos–>x][pos–>x – 1] == CAISSE_OK) &&
(pos–>x – 2 < 0 || carte[pos–>x][pos–>x – 2] == MUR ||
carte[pos–>x][pos–>x – 2] == CAISSE || carte[pos–>x][pos–>x – 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>x – 1]‚ &carte[pos–>x][pos–>x – 2]);

pos–>x––;
break;

case DROITE:
if (pos–>x + 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>x + 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>x + 1] == CAISSE || carte[pos–>x][pos–>x + 1] == CAISSE_OK) &&
(pos–>x + 2 < 0 || carte[pos–>x][pos–>x + 2] == MUR ||
carte[pos–>x][pos–>x + 2] == CAISSE || carte[pos–>x][pos–>x + 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>x – 1]‚ &carte[pos–>x][pos–>x – 2]);

pos–>x++;
break;
}
}

void deplacerCaisse(int *premiereCase‚ int *secondeCase)
{
if (*premiereCase == CAISSE || *premiereCase == CAISSE_OK)
{
if (*secondeCase == OBJECTIF)
*secondeCase = CAISSE_OK;
else
*secondeCase = CAISSE;

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

fichiers.c

/*
fichiers.c
–––––

Par kudo2

Rôle : charger et enregistrer les niveaux.
*/

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

#include "constantes.h"
#include "fichiers.h"

int chargerNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
char ligneFichier[NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1] = {0};
int i = 0‚ j = 0;

fichier = fopen("niveaux.lvl"‚ "r");
if (fichier == NULL)
return 0;

fgets(ligneFichier‚ NB_BLOCS_LARGEUR * NB_BLOCS_HAUTEUR + 1‚ fichier);

for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
{
switch (ligneFichier[(i * NB_BLOCS_LARGEUR) + j])
{
case '0':
niveau[j][i] = 0;
break;
case '1':
niveau[j][i] = 1;
break;
case '2':
niveau[j][i] = 2;
break;
case '3':
niveau[j][i] = 3;
break;
case '4':
niveau[j][i] = 4;
break;
}
}
}

fclose(fichier);
return 1;
}

int sauvegarderNiveau(int niveau[][NB_BLOCS_HAUTEUR])
{
FILE* fichier = NULL;
int i = 0‚ j = 0;

fichier = fopen("niveaux.lvl"‚ "w");
if (fichier == NULL)
return 0;

for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
{
fprintf(fichier‚ "%d"‚ niveau[j][i]);
}
}

fclose(fichier);
return 1;
}

editeur.c

/*
editeur.c
–––––

Par kudo2

Rôle : charger et enregistrer les niveaux.
*/

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

#include "constantes.h"
#include "editeur.h"

void editeur(SDL_Surface* ecran)
{
SDL_Surface *mur = NULL‚ *caisse = NULL‚ *objectif = NULL‚ *mario = NULL;
SDL_Rect position;
SDL_Event event;

int continuer = 1‚ clicGaucheEnCours = 0‚ clicDroitEnCours = 0;
int objetActuel = MUR‚ i = 0‚ j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

// Chargement des objets et du niveau
mur = IMG_Load("mur.jpg");
caisse = IMG_Load("caisse.jpg");
objectif = IMG_Load("objectif.png");
mario = IMG_Load("mario_bas.gif");

if (!chargerNiveau(carte))
exit(EXIT_FAILURE);

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;

case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
{
// On met l'objet actuellement choisi (mur‚ caisse...) à l'endroit du clic
carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
}
else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
{
carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
clicDroitEnCours = 1;
}
break;

case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
if (event.button.button == SDL_BUTTON_LEFT)
clicGaucheEnCours = 0;
else if (event.button.button == SDL_BUTTON_RIGHT)
clicDroitEnCours = 0;
break;

case SDL_MOUSEMOTION:
if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
{
carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
}
else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
{
carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
}
break;

case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_s:
sauvegarderNiveau(carte);
break;
case SDLK_c:
chargerNiveau(carte);
break;
case SDLK_KP1:
objetActuel = MUR;
break;
case SDLK_KP2:
objetActuel = CAISSE;
break;
case SDLK_KP3:
objetActuel = OBJECTIF;
break;
case SDLK_KP4:
objetActuel = MARIO;
break;
}
break;
}
}
// Effacement de l'écran
SDL_FillRect(ecran‚ NULL‚ SDL_MapRGB(ecran–>format‚ 255‚ 255‚ 255));

// Placement des objets à l'écran
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

switch(carte[i][j])
{
case MUR:
SDL_BlitSurface(mur‚ NULL‚ ecran‚ &position);
break;
case CAISSE:
SDL_BlitSurface(caisse‚ NULL‚ ecran‚ &position);
break;
case OBJECTIF:
SDL_BlitSurface(objectif‚ NULL‚ ecran‚ &position);
break;
case MARIO:
SDL_BlitSurface(mario‚ NULL‚ ecran‚ &position);
break;
}
}
}

// Mise à jour de l'écran
SDL_Flip(ecran);

SDL_FreeSurface(mur);
SDL_FreeSurface(caisse);
SDL_FreeSurface(objectif);
SDL_FreeSurface(mario);
}

merci de votre aide.

minirop

19 décembre 2006 à 23:37:37

tu n'as rien dans std***.txt ?

M41d3n-dc

20 décembre 2006 à 22:00:21

non !! j'ai meme pas le fichier !!

Caleb

21 décembre 2006 à 14:10:02

Citation : Pas de titre

j'ai commencé le mario sokoban cette apres midi et je l'ai finis, je compile, l'ecran du menu s'affiche et pour essayer le jeu j'appui sur "1" et la fenetre se ferme, je pense avoir fait une petite erreur mais aidez moi !!!

Reduis déjà ton code en isolant le passage qui pose problème. Quand tu fais un jeu entier, il faut coder fonction par fonction et vérifier leur comportement séparement, sinon bonjour l'angoisse.

Caribou87

21 décembre 2006 à 14:13:31

M41d3n-dc

21 décembre 2006 à 18:14:56

j'ai remarquer qu'il y avait 2 SDL_Blit de marioActuel !!
j'ai supprimer le 1er qui se trouvait au niveau des initiation de variable mais losque l'on test il s'affiche mais que quelque milliseconde par contre l'editeur ne s'affiche pas et si on appuie sur "2" alors on doit cliquer 2 fois sur la croix pour quitter !!!
editeur.c

/*
editeur.c
–––––

Par kudo2

Rôle : charger et enregistrer les niveaux.
*/

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

#include "constantes.h"
#include "editeur.h"

void editeur(SDL_Surface* ecran)
{
SDL_Surface *mur = NULL‚ *caisse = NULL‚ *objectif = NULL‚ *mario = NULL;
SDL_Rect position;
SDL_Event event;

int continuer = 1‚ clicGaucheEnCours = 0‚ clicDroitEnCours = 0;
int objetActuel = MUR‚ i = 0‚ j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

// Chargement des objets et du niveau
mur = IMG_Load("mur.jpg");
caisse = IMG_Load("caisse.jpg");
objectif = IMG_Load("objectif.png");
mario = IMG_Load("mario_bas.gif");

if (!chargerNiveau(carte))
exit(EXIT_FAILURE);

while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;

case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_LEFT)
{
// On met l'objet actuellement choisi (mur‚ caisse...) à l'endroit du clic
carte[event.button.x / TAILLE_BLOC][event.button.y / TAILLE_BLOC] = objetActuel;
clicGaucheEnCours = 1; // On active un booléen pour retenir qu'un bouton est enfoncé
}
else if (event.button.button == SDL_BUTTON_RIGHT) // Le clic droit sert à effacer
{
carte[event.button.x / TAILLE_BLOC][event.button.y /TAILLE_BLOC] = VIDE;
clicDroitEnCours = 1;
}
break;

case SDL_MOUSEBUTTONUP: // On désactive le booléen qui disait qu'un bouton était enfoncé
if (event.button.button == SDL_BUTTON_LEFT)
clicGaucheEnCours = 0;
else if (event.button.button == SDL_BUTTON_RIGHT)
clicDroitEnCours = 0;
break;

case SDL_MOUSEMOTION:
if (clicGaucheEnCours) // Si on déplace la souris et que le bouton gauche de la souris est enfoncé
{
carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = objetActuel;
}
else if (clicDroitEnCours) // Pareil pour le bouton droit de la souris
{
carte[event.motion.x / TAILLE_BLOC][event.motion.y / TAILLE_BLOC] = VIDE;
}
break;

case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_s:
sauvegarderNiveau(carte);
break;
case SDLK_c:
chargerNiveau(carte);
break;
case SDLK_KP1:
objetActuel = MUR;
break;
case SDLK_KP2:
objetActuel = CAISSE;
break;
case SDLK_KP3:
objetActuel = OBJECTIF;
break;
case SDLK_KP4:
objetActuel = MARIO;
break;
}
break;
}
}
// Effacement de l'écran
SDL_FillRect(ecran‚ NULL‚ SDL_MapRGB(ecran–>format‚ 255‚ 255‚ 255));

// Placement des objets à l'écran
for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

switch(carte[i][j])
{
case MUR:
SDL_BlitSurface(mur‚ NULL‚ ecran‚ &position);
break;
case CAISSE:
SDL_BlitSurface(caisse‚ NULL‚ ecran‚ &position);
break;
case OBJECTIF:
SDL_BlitSurface(objectif‚ NULL‚ ecran‚ &position);
break;
case MARIO:
SDL_BlitSurface(mario‚ NULL‚ ecran‚ &position);
break;
}
}
}

// Mise à jour de l'écran
SDL_Flip(ecran);
// liberation de la memoire
SDL_FreeSurface(mur);
SDL_FreeSurface(caisse);
SDL_FreeSurface(objectif);
SDL_FreeSurface(mario);
}

et jeu.c

/*
jeu.c
–––––

7Par kudo2

Rôle : fonctions du jeu.
*/

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

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

void jouer(SDL_Surface* ecran)
{
SDL_Surface *mario[4] = {NULL}; // 4 surfaces pour chacune des directions de mario
SDL_Surface *mur = NULL‚ *caisse = NULL‚ *caisseOK = NULL‚ *objectif = NULL‚ *marioActuel = NULL;
SDL_Rect position‚ positionJoueur;
SDL_Event event;

int continuer = 1‚ objectifsRestants = 0‚ i = 0‚ j = 0;
int carte[NB_BLOCS_LARGEUR][NB_BLOCS_HAUTEUR] = {0};

// Chargement des sprites (décors‚ personnage...)
mur = IMG_Load("mur.jpg");
caisse = IMG_Load("caisse.jpg");
caisseOK = IMG_Load("caisse_ok.jpg");
objectif = IMG_Load("objectif.png");
mario[BAS] = IMG_Load("mario_bas.gif");
mario[GAUCHE] = IMG_Load("mario_gauche.gif");
mario[HAUT] = IMG_Load("mario_haut.gif");
mario[DROITE] = IMG_Load("mario_droite.gif");

marioActuel = mario[BAS]; // Mario sera dirigé vers le bas au départ

// Chargement du niveau
if (!chargerNiveau(carte))
exit(EXIT_FAILURE); // On arrête le jeu si on n'a pas pu charger le niveau

// Recherche de la position de Mario au départ
for (i = 0 ; i < NB_BLOCS_HAUTEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_LARGEUR ; j++)
{
if (carte[i][j] == MARIO) // Si Mario se trouve à cette position sur la carte
{
positionJoueur.x = i;
positionJoueur.y = j;
carte[i][j] = VIDE;
}
}
}
// Activation de la répétition des touches
SDL_EnableKeyRepeat(100‚ 100);

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:
marioActuel = mario[HAUT];
deplacerJoueur(carte‚ &positionJoueur‚ HAUT);
break;
case SDLK_DOWN:
marioActuel = mario[BAS];
deplacerJoueur(carte‚ &positionJoueur‚ BAS);
break;
case SDLK_RIGHT:
marioActuel = mario[DROITE];
deplacerJoueur(carte‚ &positionJoueur‚ DROITE);
break;
case SDLK_LEFT:
marioActuel = mario[GAUCHE];
deplacerJoueur(carte‚ &positionJoueur‚ GAUCHE);
break;
}
break;
}
// Effacement de l'écran
SDL_FillRect(ecran‚ NULL‚ SDL_MapRGB(ecran–>format‚ 255‚ 255‚ 255));

// Placement des objets à l'écran
objectifsRestants = 0;

for (i = 0 ; i < NB_BLOCS_LARGEUR ; i++)
{
for (j = 0 ; j < NB_BLOCS_HAUTEUR ; j++)
{
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

switch(carte[i][j])
{
case MUR:
SDL_BlitSurface(mur‚ NULL‚ ecran‚ &position);
break;
case CAISSE:
SDL_BlitSurface(caisse‚ NULL‚ ecran‚ &position);
break;
case CAISSE_OK:
SDL_BlitSurface(caisseOK‚ NULL‚ ecran‚ &position);
break;
case OBJECTIF:
SDL_BlitSurface(objectif‚ NULL‚ ecran‚ &position);
objectifsRestants = 1;
break;
}
}
}
position.x = i * TAILLE_BLOC;
position.y = j * TAILLE_BLOC;

// Si on n'a trouvé aucun objectif sur la carte‚ c'est qu'on a gagné
if (!objectifsRestants)
continuer = 0;

// On place le joueur à la bonne position
position.x = positionJoueur.x * TAILLE_BLOC;
position.y = positionJoueur.y * TAILLE_BLOC;
SDL_BlitSurface(marioActuel‚ NULL‚ ecran‚ &position);

SDL_Flip(ecran); // mise a jour de l'ecran

// Désactivation de la répétition des touches (remise à 0)
SDL_EnableKeyRepeat(0‚ 0);

// Libération des surfaces chargées
SDL_FreeSurface(mur);
SDL_FreeSurface(caisse);
SDL_FreeSurface(caisseOK);
SDL_FreeSurface(objectif);
for (i = 0 ; i < 4 ; i++)
SDL_FreeSurface(mario[i]);
}

void deplacerJoueur(int carte[][NB_BLOCS_HAUTEUR]‚ SDL_Rect *pos‚ int direction)
{
switch(direction)
{
case HAUT:
if (pos–>y – 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>y – 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>y – 1] == CAISSE || carte[pos–>x][pos–>y – 1] == CAISSE_OK) &&
(pos–>y – 2 < 0 || carte[pos–>x][pos–>y – 2] == MUR ||
carte[pos–>x][pos–>y – 2] == CAISSE || carte[pos–>x][pos–>y – 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>y – 1]‚ &carte[pos–>x][pos–>y – 2]);

pos–>y––; // On peut enfin faire monter le joueur (oufff !)
break;

case BAS:
if (pos–>y + 1 > 12) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>y + 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>y + 1] == CAISSE || carte[pos–>x][pos–>y + 1] == CAISSE_OK) &&
(pos–>y + 2 < 0 || carte[pos–>x][pos–>y + 2] == MUR ||
carte[pos–>x][pos–>y + 2] == CAISSE || carte[pos–>x][pos–>y + 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>y + 1]‚ &carte[pos–>x][pos–>y + 2]);

pos–>y++; // On peut enfin faire descendre le joueur (oufff !)
break;

case GAUCHE:
if (pos–>x – 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>x – 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>x – 1] == CAISSE || carte[pos–>x][pos–>x – 1] == CAISSE_OK) &&
(pos–>x – 2 < 0 || carte[pos–>x][pos–>x – 2] == MUR ||
carte[pos–>x][pos–>x – 2] == CAISSE || carte[pos–>x][pos–>x – 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>x – 1]‚ &carte[pos–>x][pos–>x – 2]);

pos–>x––;
break;

case DROITE:
if (pos–>x + 1 < 0) // Si le joueur dépasse l'écran‚ on arrête
break;
if (carte[pos–>x][pos–>x + 1] == MUR) // S'il y a un mur‚ on arrête
break;
// Si on veut pousser une caisse‚ il faut vérifier qu'il n'y a pas de mur derrière (ou une autre caisse‚ ou la limite du monde)
if ((carte[pos–>x][pos–>x + 1] == CAISSE || carte[pos–>x][pos–>x + 1] == CAISSE_OK) &&
(pos–>x + 2 < 0 || carte[pos–>x][pos–>x + 2] == MUR ||
carte[pos–>x][pos–>x + 2] == CAISSE || carte[pos–>x][pos–>x + 2] == CAISSE_OK))
break;

// Si on arrive là‚ c'est qu'on peut déplacer le joueur !
// On vérifie d'abord s'il y a une caisse à déplacer
deplacerCaisse(&carte[pos–>x][pos–>x – 1]‚ &carte[pos–>x][pos–>x – 2]);

pos–>x++;
break;
}
}

void deplacerCaisse(int *premiereCase‚ int *secondeCase)
{
if (*premiereCase == CAISSE || *premiereCase == CAISSE_OK)
{
if (*secondeCase == OBJECTIF)
*secondeCase = CAISSE_OK;
else
*secondeCase = CAISSE;

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

merci

Caribou87

21 décembre 2006 à 18:17:48

Si tu sais pas d'où vien l'erreur tu peux débugger avec du fprintf(stderr) pour voir là où le programme se ferme.

T'en mets un peu partout et tu vois dans stderr (ou stderr.txt) les bouts de codes executés et ceux qui ne le sont pas.

(Si tu comprends pas un message tu demandes des précisions, ça n'avance à rien de passer outre...)