Partage

zMorp SDL

<< 1 2 3 4

12 février 2011 à 12:07:13

Tu as des balises de code pour présenter ton code : <code type="c">Ton code ici</code>
Il nous faudrait les images aussi.

Sur ton image, c'est normal que la croix soit entre 2 cases en bas ? :-°

schadocalex

12 février 2011 à 12:33:14

C'est peut-être la souris.

"If debbugging is the process of removing bugs, then programming must be the process of putting them in." (Edsger Dijkstra)

Gakuse78

12 février 2011 à 22:06:29

Citation : Pouet_forever

Tu as des balises de code pour présenter ton code : <code type="c">Ton code ici</code>

J'ai édité mon message dans ce sens. J'espère avoir bien compris.

Citation : Pouet_forever

Il nous faudrait les images aussi.

Je les ai ajoutées.

Citation : Pouet_forever

Sur ton image, c'est normal que la croix soit entre 2 cases en bas ?

Il s'agit de la souris. c'était au joueur2 de jouer...
Bien vu schadocalex

Au fait, quand je me suis lancé dans ce petit projet, je n'avais lu que le début de ce topic, et je me suis lancé.
Et ce soir je viens de lire en entier. J'avoue qu'en tant que débutant que je n'ai pas tout compris.
Mais je m'attends à ce que vous me dite : "la partie logique et la partie SDL ne sont pas du tout disjointe".
Probablement une faute de débutant (facile comme excuse :lol:

)
J'attends vos remarques et j'essaye de faire mieux.

GurneyH

12 février 2011 à 22:43:22

Citation : Gakuse78

Mais je m'attends à ce que vous me dite : "la partie logique et la partie SDL ne sont pas du tout disjointe".
Probablement une faute de débutant (facile comme excuse )

Tu vas apprendre à le faire après avoir codé plusieurs petits projets comme celui-ci.
Par toi même, tu vas voir que tu pourrais réutiliser des choses de ce projet dans le prochain, et voilà.
Je pense que là tu vas comprendre de quoi on parle.;)

Merci pour la participation, en tous cas, et joli rendu.

Zeste de Savoir, le site qui en a dans le citron !

zenko

13 février 2011 à 12:23:23

bravo Gakuse78, très jolie le rendu

En ce qui concerne la séparation logique / SDL, essaie de mettre tout ce qui concerne SDL dans des fonctions à part entière.
Le but étant de pouvoir utiliser n'importe quel lib graphique exemple :

#include <stdio.h>

// Les libs graphiques en option
#define SDL 1
#define SFML 2

// Lib a utiliser pour la compilation
#define LIB SDL

// On inclus la lib graphique LIB
#if LIB == SFML
    #include "lib/sfml/include.h"
#elif LIB == SDL
    #include "lib/sdl/include.h"
#endif

#include "jeu.h"

(Il y a ptet plus simple mais bon, on comprends l'idée :-°

)

Et normalement, que LIB vaille SFML ou SDL, le jeu doit fonctionner

Gakuse78

14 février 2011 à 0:00:04

Bonsoir,

Merci pour vos remarques pour vos conseils.

Je vais tâcher de refaire le programme en tenant compte de ces remarques.
Je vous le proposerai prochainement.

@+

Capricornus

22 décembre 2011 à 22:51:30

Bonsoir,

Bon, ben je m'y suis aussi mis... Et j'ai un petit problème.

J'ai beau lire et relire mon code, impossible de trouver mon erreur. Quand je compile, code::blocks n'affiche aucun message, mais quand je lance le programme, la fenêtre se ferme presque tout de suite :diable:

!
Alors, merci pour tous les commentaires possibles et imaginables sur ma maaagnifique production (de débutant...).

D'abord fx.h:

#ifndef ANTI_I
#define ANTI_I


#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include "SDL_image.h"
#
#define LARG_CASE 100
#define LARG_QUAD 5
#define LARG_FEN (LARG_CASE*3+LARG_QUAD*2)
#
#define DIM 3
#define NB_SURF_QUAD 4
#define NB_PTS 9


enum {HG,HM,HD,MG,MM,MD,BG,BM,BD};
enum {H, My, D};
enum {G, Mx, B};

typedef struct ChoixCase ChoixCase;
struct ChoixCase
{
	int x;
	int y;
};


int initialiserGrille (SDL_Surface *ecran, SDL_Surface *quad [], SDL_Surface *cases []);

void positionnerSurf (SDL_Rect quad [], SDL_Rect cases []);

int affichage (SDL_Surface *ecran, SDL_Surface *cases[], SDL_Surface *quad[], int quelsPointsOntEteMis[]);

int convChoix (ChoixCase ChxC);

void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur);

int testerGagnant(int quelsPointsOntEteMis[], int quelJoueur);

void initialiserVar(int *i, ChoixCase *ChxC);

void evenementsPaveNum (SDL_Event event, ChoixCase *ChxC, int *quitter);

#endif

puis fx.c:

#include "fx.h"

int initialiserGrille (SDL_Surface *ecran, SDL_Surface *quad [], SDL_Surface *cases [])
{
	int i=0;
	for (i=0; i<NB_PTS; i++)
		SDL_FillRect(cases [i], NULL, SDL_MapRGB(cases[i]->format, 255, 255, 255));
	for (i=0; i<NB_SURF_QUAD; i++)
		SDL_FillRect(quad [i], NULL, SDL_MapRGB(quad [i]->format, 0, 0, 0));

	return 1;
}

void positionnerSurf (SDL_Rect quad [], SDL_Rect cases [])
{
	//barres horizontales
	quad [1].x=0;
	quad [1].y=LARG_CASE;
	quad [2].x=0;
	quad [2].y=2*LARG_CASE+LARG_QUAD;

	//barres verticales
	quad [3].x=LARG_CASE;
	quad [3].y=0;
	quad [4].x=2*LARG_CASE+LARG_QUAD;
	quad [4].y=0;

	//cases
	cases[1].x=0;
	cases[1].y=0;
	cases[2].x=LARG_CASE+LARG_QUAD;
	cases[2].y=0;
	cases[3].x=LARG_FEN-LARG_CASE;
	cases[3].y=0;
	cases[4].x=0;
	cases[4].y=LARG_CASE+LARG_QUAD;
	cases[5].x=LARG_CASE+LARG_QUAD;
	cases[5].y=LARG_CASE+LARG_QUAD;
	cases[6].x=LARG_FEN-LARG_CASE;
	cases[6].y=LARG_CASE+LARG_QUAD;
	cases[7].x=0;
	cases[7].y=LARG_FEN-LARG_CASE;
	cases[8].x=LARG_CASE+LARG_QUAD;
	cases[8].y=LARG_FEN-LARG_CASE;
	cases[9].x=LARG_FEN-LARG_CASE;
	cases[9].y=LARG_FEN-LARG_CASE;
}



int affichage (SDL_Surface *ecran, SDL_Surface *cases[], SDL_Surface *quad[], int quelsPointsOntEteMis [])//manque
{
    int i=0;
    for (i=0; i<NB_PTS; i++)
    {
        switch(quelsPointsOntEteMis[i])
        {
            case 0:

            break;
            case 1:
                SDL_FillRect(cases[i], NULL, SDL_MapRGB(cases[i]->format, 135, 12, 29));
            break;
            case 2:
                SDL_FillRect(cases[i], NULL, SDL_MapRGB(cases[i]->format, 28, 37, 234));
            break;
            default:
                fprintf(stderr, "ERREUR: mauvaise donnée dans quelsPointsOntEteMis[%d]", i);
            break;
        }
    }
	return 1;
}


int convChoix (ChoixCase ChxC)
{
	int choix = 0;
	switch (ChxC.x)
	{
		case G:
			if (ChxC.y == H)
				choix = HG;
			else if (ChxC.y == My)
				choix = MG;
			else
				choix = BG;
			break;
		case Mx:
			if (ChxC.y == H)
				choix = HM;
			else if (ChxC.y == My)
				choix = MM;
			else
				choix = BM;
			break;
		case D:
			if (ChxC.y == H)
				choix = HD;
			else if (ChxC.y == My)
				choix = MD;
			else
				choix = BD;
			break;
		default:
			break;
	}
	return choix;
}



void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur)
{
	quelsPointsOntEteMis[choixCase-1]=quelJoueur;
}


int testerGagnant(int quelsPointsOntEteMis[], int quelJoueur)
{

    if ((quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[1]==quelJoueur && quelsPointsOntEteMis[2]==quelJoueur)
        ||(quelsPointsOntEteMis[3]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[5]==quelJoueur)
		||(quelsPointsOntEteMis[6]==quelJoueur && quelsPointsOntEteMis[7]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur)
        ||(quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur)
		||(quelsPointsOntEteMis[2]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[6]==quelJoueur)
        ||(quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[3]==quelJoueur && quelsPointsOntEteMis[6]==quelJoueur)
        ||(quelsPointsOntEteMis[1]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[7]==quelJoueur)
        ||(quelsPointsOntEteMis[2]==quelJoueur && quelsPointsOntEteMis[5]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur))
		return 1;
    else
		return 0;
}


void initialiserVar(int *i, ChoixCase *ChxC)
{
	*i=0;
	ChxC->x = 0;
	ChxC->y = 0;
}

void evenementsPaveNum (SDL_Event event, ChoixCase *ChxC, int *quitter)
{
    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE:
                            *quitter = 1;
                            break;
                        case SDLK_KP1:
                            ChxC->x = G;
                            ChxC->y = B;
                            break;
                        case SDLK_KP2:
                            ChxC->x = Mx;
                            ChxC->y = B;
                            break;
                        case SDLK_KP3:
                            ChxC->x = D;
                            ChxC->y = B;
                            break;
                        case SDLK_KP4:
                            ChxC->x = G;
                            ChxC->y = My;
                            break;
                        case SDLK_KP5:
                            ChxC->x = Mx;
                            ChxC->y = My;
                            break;
                        case SDLK_KP6:
                            ChxC->x = D;
                            ChxC->y = My;
                            break;
                        case SDLK_KP7:
                            ChxC->x = G;
                            ChxC->y = H;
                            break;
                        case SDLK_KP8:
                            ChxC->x = Mx;
                            ChxC->y = H;
                            break;
                        case SDLK_KP9:
                            ChxC->x = D;
                            ChxC->y = H;
                            break;
                        default:
                            break;
                    }
}

et enfin main.c

#include "fx.h"

int main(int argc, char *argv[])
{
    ///Déclarations
	SDL_Surface *ecran=NULL, *quad [NB_SURF_QUAD]= {NULL}, *cases [NB_PTS]={NULL};
	SDL_Rect posQuad[NB_SURF_QUAD], posCases[NB_PTS];
	SDL_Event event;
	ChoixCase ChxC;
	int i=0, quitter = 0, quelJoueur = 2;
	/*
	N.B.: On ne tire pas le joueur au sort, cela n'a pas d'intérêt : vu qu'on n'affiche pas leurs noms,
	les deux joueurs décident eux-mêmes qui prend la souris.
	*/
	int quelsPointsOntEteMis[NB_PTS]={0};//tableau pour savoir qui a joue quoi



	/// Initialisation de la SDL
	if ( SDL_Init(SDL_INIT_VIDEO) < 0 )//gesion de l'erreur
	{
		fprintf(stderr, "Impossible d'initialiser la SDL: %s\n", SDL_GetError());
		exit(EXIT_FAILURE);
	}//gestion d'erreur

	ecran=SDL_SetVideoMode(LARG_FEN, LARG_FEN, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

        if (ecran == NULL)//gestion d'erreur
		{
			fprintf(stderr, "Impossible de charger le mode Video: %s\n", SDL_GetError());
			SDL_Quit();
			exit(EXIT_FAILURE);
		}

    SDL_WM_SetCaption("Morpion SDL", NULL);
    SDL_WM_SetIcon(IMG_Load("Morpion_icone.jpg"), NULL);//icone


    /// Création des surfaces (quadrillage et cases)
	for (i=0; i<NB_SURF_QUAD/2; i++)
		quad[i]=SDL_CreateRGBSurface(SDL_HWSURFACE, LARG_FEN, LARG_QUAD, 32, 0, 0, 0, 0);
	for (i=2; i<NB_SURF_QUAD; i++)
		quad[i]=SDL_CreateRGBSurface(SDL_HWSURFACE, LARG_QUAD, LARG_FEN, 32, 0, 0, 0, 0);

    positionnerSurf(posQuad, posCases);


	while (!quitter)
	{
	    /// initialisation des variables et de la grille
	    initialiserVar(&i, &ChxC);
		initialiserGrille(ecran, quad, cases);

		///début de la partie !
		while (!testerGagnant(quelsPointsOntEteMis, quelJoueur) && !quitter);
		{
		    ///changement de joueur
			quelJoueur-=3;//alterne les joueurs
			if (quelJoueur == 1)
                SDL_WM_SetCaption("C'est à Joueur 1 de jouer", NULL);
            else
                SDL_WM_SetCaption("C'est à Joueur 1 de jouer", NULL);

			///affichage
			affichage(ecran, cases, quad, quelsPointsOntEteMis);
			for (i=0; i<NB_PTS; i++)
			    SDL_BlitSurface(cases[i], NULL, ecran, &posCases[i]);
            for (i=0; i<NB_SURF_QUAD; i++)
                SDL_BlitSurface(quad[i], NULL, ecran, &posQuad[i]);
			SDL_Flip(ecran);


			/// gestion des évènements
			SDL_WaitEvent(&event);
			switch (event.type)
			{

				case SDL_MOUSEMOTION:
					break;
				case SDL_MOUSEBUTTONDOWN:
					if (event.button.button == SDL_BUTTON_LEFT)
					{
						if (event.motion.x <= LARG_CASE)
							ChxC.x = G;
						else if (event.motion.x >= LARG_QUAD+LARG_CASE && event.motion.x <= LARG_QUAD+2*LARG_CASE)
							ChxC.x = Mx;
						else if (event.motion.x >= 2*(LARG_QUAD+LARG_CASE) && event.motion.x <= LARG_FEN)
							ChxC.x = D;

						if (event.motion.y <= LARG_CASE)
							ChxC.y = H;
						else if (event.motion.y >= LARG_QUAD+LARG_CASE && event.motion.y <= LARG_QUAD+2*LARG_CASE)
							ChxC.y = My;
						else if (event.motion.y >= 2*(LARG_QUAD+LARG_CASE) && event.motion.y <= LARG_FEN)
							ChxC.y = B;
					}

					jouerCoup(quelsPointsOntEteMis, convChoix(ChxC), quelJoueur);
					break;
				case SDL_KEYDOWN:
                    evenementsPaveNum(event, &ChxC, &quitter);
					break;
				case SDL_QUIT:
					quitter = 1;
					break;
				default:
					break;
			}
		}

		if (!quitter)// = if (testerGagnant(quelsPointsOntEteMis, quelJoueur))
		{
		    SDL_WM_SetCaption("GAGNE !", NULL);
		}
	}


	/// libération des surfaces et "arrêt" de la SDL
	for (i=0; i<NB_SURF_QUAD; i++)
		SDL_FreeSurface(quad[i]);
	for (i=0; i<NB_PTS; i++)
		SDL_FreeSurface(cases[i]);

	SDL_Quit();
	return(EXIT_SUCCESS);
}

Au fait, je sais que ce n'est pas terrible pour afficher le changement de joueur, mais je ne pouvais pas faire:

SDL_WM_SetCaption("C'est à Joueur %d de jouer", quelJoueur, NULL);

Merci...

Shadow-Homer

22 décembre 2011 à 23:17:00

je m'y met

Juste pour le SDL_Wm , c'est pas grave si on change le titre comme ça ?

GurneyH

23 décembre 2011 à 3:47:26

bonjour

Citation : Shadow-Homer

je m'y met
Juste pour le SDL_Wm , c'est pas grave si on change le titre comme ça ?

Je ne comprend pas ce que tu veux dire. :-°

@Capricornus:

dans ta fonction initialiserGrilles tu accèdes ton tableau de pointeurs cases est initialisée à NULL, et tu le déférences -> crash.
Ton code me semble très confus.

Zeste de Savoir, le site qui en a dans le citron !

razira59

23 décembre 2011 à 11:08:13

Vous avez pas l'impression d'avoir déterré ce topic ? :-°

Sinon pour ton problème Capriorus, pourquoi tu inclus SDL_Image comme si c'était toi qui l'avais crée ? tu devrais plutôt mettre :

#include <SDL/SDL_Image.h>
// ou #include <SDL_Image.h> selon où tu as placé SDL_Image.h

au lieu de :

#include "SDL_Image.h"

Enfin, si tu tiens vraiment à faire de la deuxième manière, et ben il faut que tu ouvres SDL_Image.h, copies son contenu et colles le dans un nouveau fichier "SDL_Image.h" mais dans ton projet.

Et pour le problème, il se pourrait que ce soit le chargement des images.

Je te conseille de faire ceci pour chaque image :

if(!image)
{
    fprintf("Impossible de charger image.png");

}

Capricornus

23 décembre 2011 à 13:54:56

Voilà mon code, après quelques modifications.

J'ai corrigé quelques trucs en-dehors de ce qui m'avait été dit, maintenant, il ne ferme plus tout de suite, mais il ouvre une page blanche qui devient noire, et... rien. o_O

Merci pour vos commentaires...!

Voici fx.h:

#ifndef ANTI_I
#define ANTI_I


#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <SDL_image.h>
#
#define LARG_CASE 100
#define LARG_QUAD 5
#define LARG_FEN (LARG_CASE*3+LARG_QUAD*2)
#
#define DIM 3
#define NB_SURF_QUAD 4
#define NB_PTS 9


enum {HG,HM,HD,MG,MM,MD,BG,BM,BD};
enum {H, My, D};
enum {G, Mx, B};

typedef struct ChoixCase ChoixCase;
struct ChoixCase
{
	int x;
	int y;
};


int initialiserGrille (SDL_Surface *ecran, SDL_Surface *quad [], SDL_Surface *cases []);

void positionnerSurf (SDL_Rect quad [], SDL_Rect cases []);

int affichage (SDL_Surface *ecran, SDL_Surface *cases[], SDL_Surface *quad[], int quelsPointsOntEteMis[]);

int convChoix (ChoixCase ChxC);

void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur);

int testerGagnant(int quelsPointsOntEteMis[], int quelJoueur);

void initialiserVar(int *i, ChoixCase *ChxC);

void evenementsPaveNum (SDL_Event event, ChoixCase *ChxC, int *quitter);

#endif

fx.c

#include "fx.h"

int initialiserGrille (SDL_Surface *ecran,  SDL_Surface *quad [], SDL_Surface *cases [])
{
	int i=0;
	for (i=0; i<NB_PTS; i++)
		SDL_FillRect(cases [i], NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
	for (i=0; i<NB_SURF_QUAD; i++)
		SDL_FillRect(quad [i], NULL, SDL_MapRGB(ecran->format, 0, 0, 0));

	return 1;
}

void positionnerSurf (SDL_Rect quad [], SDL_Rect cases [])
{
	//barres horizontales
	quad [0].x=0;
	quad [0].y=LARG_CASE;
	quad [1].x=0;
	quad [1].y=2*LARG_CASE+LARG_QUAD;

	//barres verticales
	quad [2].x=LARG_CASE;
	quad [2].y=0;
	quad [3].x=2*LARG_CASE+LARG_QUAD;
	quad [3].y=0;

	//cases
	cases[0].x=0;
	cases[0].y=0;
	cases[1].x=LARG_CASE+LARG_QUAD;
	cases[1].y=0;
	cases[2].x=LARG_FEN-LARG_CASE;
	cases[2].y=0;
	cases[3].x=0;
	cases[3].y=LARG_CASE+LARG_QUAD;
	cases[4].x=LARG_CASE+LARG_QUAD;
	cases[4].y=LARG_CASE+LARG_QUAD;
	cases[5].x=LARG_FEN-LARG_CASE;
	cases[5].y=LARG_CASE+LARG_QUAD;
	cases[6].x=0;
	cases[6].y=LARG_FEN-LARG_CASE;
	cases[7].x=LARG_CASE+LARG_QUAD;
	cases[7].y=LARG_FEN-LARG_CASE;
	cases[8].x=LARG_FEN-LARG_CASE;
	cases[8].y=LARG_FEN-LARG_CASE;
}



int affichage (SDL_Surface *ecran, SDL_Surface *cases[], SDL_Surface *quad[], int quelsPointsOntEteMis [])//manque
{
    int i=0;
    for (i=0; i<NB_PTS; i++)
    {
        switch(quelsPointsOntEteMis[i])
        {
            case 0:

            break;
            case 1:
                SDL_FillRect(cases[i], NULL, SDL_MapRGB(cases[i]->format, 135, 12, 29));
            break;
            case 2:
                SDL_FillRect(cases[i], NULL, SDL_MapRGB(cases[i]->format, 28, 37, 234));
            break;
            default:
                fprintf(stderr, "ERREUR: mauvaise donnée dans quelsPointsOntEteMis[%d]", i);
            break;
        }
    }
	return 1;
}


int convChoix (ChoixCase ChxC)
{
	int choix = 0;
	switch (ChxC.x)
	{
		case G:
			if (ChxC.y == H)
				choix = HG;
			else if (ChxC.y == My)
				choix = MG;
			else
				choix = BG;
			break;
		case Mx:
			if (ChxC.y == H)
				choix = HM;
			else if (ChxC.y == My)
				choix = MM;
			else
				choix = BM;
			break;
		case D:
			if (ChxC.y == H)
				choix = HD;
			else if (ChxC.y == My)
				choix = MD;
			else
				choix = BD;
			break;
		default:
			break;
	}
	return choix;
}



void jouerCoup(int quelsPointsOntEteMis[], int choixCase, int quelJoueur)
{
	quelsPointsOntEteMis[choixCase-1]=quelJoueur;
}


int testerGagnant(int quelsPointsOntEteMis[], int quelJoueur)
{

    if ((quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[1]==quelJoueur && quelsPointsOntEteMis[2]==quelJoueur)
        ||(quelsPointsOntEteMis[3]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[5]==quelJoueur)
		||(quelsPointsOntEteMis[6]==quelJoueur && quelsPointsOntEteMis[7]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur)
        ||(quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur)
		||(quelsPointsOntEteMis[2]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[6]==quelJoueur)
        ||(quelsPointsOntEteMis[0]==quelJoueur && quelsPointsOntEteMis[3]==quelJoueur && quelsPointsOntEteMis[6]==quelJoueur)
        ||(quelsPointsOntEteMis[1]==quelJoueur && quelsPointsOntEteMis[4]==quelJoueur && quelsPointsOntEteMis[7]==quelJoueur)
        ||(quelsPointsOntEteMis[2]==quelJoueur && quelsPointsOntEteMis[5]==quelJoueur && quelsPointsOntEteMis[8]==quelJoueur))
		return 1;
    else
		return 0;
}


void initialiserVar(int *i, ChoixCase *ChxC)
{
	*i=0;
	ChxC->x = 0;
	ChxC->y = 0;
}

void evenementsPaveNum (SDL_Event event, ChoixCase *ChxC, int *quitter)
{
    switch(event.key.keysym.sym)
                    {
                        case SDLK_ESCAPE:
                            *quitter = 1;
                            break;
                        case SDLK_KP1:
                            ChxC->x = G;
                            ChxC->y = B;
                            break;
                        case SDLK_KP2:
                            ChxC->x = Mx;
                            ChxC->y = B;
                            break;
                        case SDLK_KP3:
                            ChxC->x = D;
                            ChxC->y = B;
                            break;
                        case SDLK_KP4:
                            ChxC->x = G;
                            ChxC->y = My;
                            break;
                        case SDLK_KP5:
                            ChxC->x = Mx;
                            ChxC->y = My;
                            break;
                        case SDLK_KP6:
                            ChxC->x = D;
                            ChxC->y = My;
                            break;
                        case SDLK_KP7:
                            ChxC->x = G;
                            ChxC->y = H;
                            break;
                        case SDLK_KP8:
                            ChxC->x = Mx;
                            ChxC->y = H;
                            break;
                        case SDLK_KP9:
                            ChxC->x = D;
                            ChxC->y = H;
                            break;
                        default:
                            break;
                    }
}

et main.c:

#include "fx.h"

int main(int argc, char *argv[])
{
	SDL_Surface *ecran=NULL, *quad [NB_SURF_QUAD]= {NULL}, *cases [NB_PTS]={NULL};
	SDL_Rect posQuad[NB_SURF_QUAD], posCases[NB_PTS];
	SDL_Event event;
	ChoixCase ChxC;
	int i=0, quitter = 0, quelJoueur = 2;
	int quelsPointsOntEteMis[NB_PTS]={0};//tableau pour savoir qui a joue quoi



	/// Initialisation de la SDL
    if ( SDL_Init(SDL_INIT_VIDEO) < 0 )
    {
	fprintf(stderr, "Impossible d'initialiser la SDL: %s\n", SDL_GetError());
	exit(EXIT_FAILURE);
    }

	ecran=SDL_SetVideoMode(LARG_FEN, LARG_FEN, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

    if (ecran == NULL)
    {
	fprintf(stderr, "Impossible de charger le mode Video: %s\n", SDL_GetError());
	SDL_Quit();
	exit(EXIT_FAILURE);
    }

    SDL_WM_SetCaption("Morpion SDL", NULL);
    SDL_WM_SetIcon(IMG_Load("Morpion_icone.jpg"), NULL);


    for (i=0; i<NB_SURF_QUAD/2; i++)
    {
	quad[i]=SDL_CreateRGBSurface(SDL_HWSURFACE, LARG_FEN, LARG_QUAD, 32, 0, 0, 0, 0);//lignes horizontales
	if (quad[i] == NULL)
            fprintf(stderr, "Impossible de créer quad [%d]", i);
    }
    for (i=2; i<NB_SURF_QUAD; i++)
    {
	quad[i]=SDL_CreateRGBSurface(SDL_HWSURFACE, LARG_QUAD, LARG_FEN, 32, 0, 0, 0, 0);//lignes verticales
	if (quad[i] == NULL)
            fprintf(stderr, "Impossible de créer quad [%d]", i);
	}
    for (i=0; i<NB_PTS; i++)
    {
        cases [i] = SDL_CreateRGBSurface(SDL_HWSURFACE, LARG_CASE, LARG_CASE, 32, 0, 0, 0, 0);//cases
        if (cases[i] == NULL)
            fprintf(stderr, "Impossible de créer cases [%d]", i);
    }


    positionnerSurf(posQuad, posCases);


	while (!quitter)
	{
	    initialiserVar(&i, &ChxC);
		if(!initialiserGrille(ecran, quad, cases))
            fprintf(stderr, "Erreur lors de l'initialisation de la grille");


		///début de la partie !
		while (!testerGagnant(quelsPointsOntEteMis, quelJoueur) && !quitter);
		{
			quelJoueur-=3;//alterne les joueurs
			if (quelJoueur == 1)
                SDL_WM_SetCaption("C'est à Joueur 1 de jouer", NULL);
            else
                SDL_WM_SetCaption("C'est à Joueur 2 de jouer", NULL);

			///affichage
			affichage(ecran, cases, quad, quelsPointsOntEteMis);
			for (i=0; i<NB_PTS; i++)
			    SDL_BlitSurface(cases[i], NULL, ecran, &posCases[i]);
            for (i=0; i<NB_SURF_QUAD; i++)
                SDL_BlitSurface(quad[i], NULL, ecran, &posQuad[i]);
			SDL_Flip(ecran);



			SDL_WaitEvent(&event);
			switch (event.type)
			{

				case SDL_MOUSEMOTION:
					break;
				case SDL_MOUSEBUTTONDOWN:
					if (event.button.button == SDL_BUTTON_LEFT)
					{
						if (event.motion.x <= LARG_CASE)
							ChxC.x = G;
						else if (event.motion.x >= LARG_QUAD+LARG_CASE && event.motion.x <= LARG_QUAD+2*LARG_CASE)
							ChxC.x = Mx;
						else if (event.motion.x >= 2*(LARG_QUAD+LARG_CASE) && event.motion.x <= LARG_FEN)
							ChxC.x = D;

						if (event.motion.y <= LARG_CASE)
							ChxC.y = H;
						else if (event.motion.y >= LARG_QUAD+LARG_CASE && event.motion.y <= LARG_QUAD+2*LARG_CASE)
							ChxC.y = My;
						else if (event.motion.y >= 2*(LARG_QUAD+LARG_CASE) && event.motion.y <= LARG_FEN)
							ChxC.y = B;
					}

					jouerCoup(quelsPointsOntEteMis, convChoix(ChxC), quelJoueur);
					break;
				case SDL_KEYDOWN:
                    evenementsPaveNum(event, &ChxC, &quitter);
					break;
				case SDL_QUIT:
					quitter = 1;
					break;
				default:
					break;
			}
		}

		if (!quitter)// = if (testerGagnant(quelsPointsOntEteMis, quelJoueur))
		{
		    SDL_WM_SetCaption("GAGNE !", NULL);
		}
	}


	for (i=0; i<NB_SURF_QUAD; i++)
		SDL_FreeSurface(quad[i]);
	for (i=0; i<NB_PTS; i++)
		SDL_FreeSurface(cases[i]);

	SDL_Quit();
	return(EXIT_SUCCESS);
}

Ah, au fait, j'ai vérifié... aucun message dans stderr.txt généré automatiquement... :-°

Shadow-Homer

24 décembre 2011 à 23:46:59

Salut , j'ai finis le mien vous trouverez :

Les Sources
Les Ressources
L'exe (réduit ou pleine écran)

Cliquez ici pour telecharger le jeu

Voila des screens :
Image utilisateur

J'ai aussi ajouté de la musique et des bruitage qui rendent assez bien (grâce à sfxr qui fait des sons de saut , de clic de plein de choses aléatoirement ...)

Et voila les sources :

main.c :

/*
Morpion - Jeu de reflexion
Programmé par HomerEro
Projet Commencé le 23 décembre 2011.
*/

#include "main.h"

void delay(void)
{
    static unsigned int tempsPrecedent = 0;
    unsigned int tempsActuel = SDL_GetTicks();

    if (tempsActuel - tempsPrecedent > 16)
    {
        tempsPrecedent = tempsActuel;
    }

    else
    {
        SDL_Delay(16 - (tempsActuel - tempsPrecedent));
    }
}

int main(int argc , char *argv[])
{
    int continuer = 1 , i;
    Map map;
    Touche touche;

    init_sdl(&map);
    init_map(&map);

    memset(&touche , 0 , sizeof(Touche));

    SDL_ShowCursor(SDL_DISABLE);

    Mix_PlayMusic(map.mapmenu.musique , -1);

    while(continuer)
    {
        test_touche(&touche , &continuer);
        update(&map , &touche);
        draw(&map , &touche);
        delay();
    }

    for(i = 0 ; i < 4 ; i++)
    {
        SDL_FreeSurface(map.mapmenu.image[i]);
    }
    for(i = 0 ; i < 2 ; i++)
    {
        SDL_FreeSurface(map.mapjeu.imgSouris[i]);
    }
    SDL_FreeSurface(map.mapmenu.curseur);

    SDL_FreeSurface(map.mapjeu.pionJ1);
    SDL_FreeSurface(map.mapjeu.pionJ2);
    SDL_FreeSurface(map.mapjeu.grille);

    SDL_FreeSurface(map.mapjeu.joueur[0].imageVaiqueur);
    SDL_FreeSurface(map.mapjeu.joueur[1].imageVaiqueur);

    SDL_FreeSurface(map.mapmenu.credit.image);

    for(i = 0 ; i < 2 ; i++)
    {
        SDL_FreeSurface(map.mapjeu.texte.pointTexte[i]);
    }

    Mix_FreeMusic(map.mapmenu.credit.musique);
    Mix_FreeMusic(map.mapmenu.musique);

    TTF_CloseFont(map.mapjeu.texte.police);

    Mix_FreeChunk(map.son[0]);
    Mix_FreeChunk(map.son[1]);
    Mix_FreeChunk(map.son[2]);

    TTF_Quit();
    Mix_CloseAudio();
    SDL_Quit();

    return 0;
}

collision.c :

#include "collision.h"

int AABBCollision(int curseur_x ,int curseur_y ,AABB box) /*Voit si il y a eu collision avec une AABB (menu)*/
{
    if (curseur_x >= box.x && curseur_x < box.x + box.w
            && curseur_y >= box.y && curseur_y < box.y + box.h)
        return 1;
    else
        return 0;

}

void collisionCase(Map *map , Touche *touche)
{
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[0]) == 1
            && map->mapjeu.caseJeu[0].occupe != 1)
    {
        map->mapjeu.tabJeu[0][0] = map->mapjeu.tour;
        map->mapjeu.caseJeu[0].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[1]) == 1
            && map->mapjeu.caseJeu[1].occupe != 1)
    {
        map->mapjeu.tabJeu[0][1] = map->mapjeu.tour;
        map->mapjeu.caseJeu[1].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[2]) == 1
            && map->mapjeu.caseJeu[2].occupe != 1)
    {
        map->mapjeu.tabJeu[0][2] = map->mapjeu.tour;
        map->mapjeu.caseJeu[2].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[3]) == 1
            && map->mapjeu.caseJeu[3].occupe != 1)
    {
        map->mapjeu.tabJeu[1][0] = map->mapjeu.tour;
        map->mapjeu.caseJeu[3].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[4]) == 1
            && map->mapjeu.caseJeu[4].occupe != 1)
    {
        map->mapjeu.tabJeu[1][1] = map->mapjeu.tour;
        map->mapjeu.caseJeu[4].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[5]) == 1
            && map->mapjeu.caseJeu[5].occupe != 1)
    {
        map->mapjeu.tabJeu[1][2] = map->mapjeu.tour;
        map->mapjeu.caseJeu[5].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[6]) == 1
            && map->mapjeu.caseJeu[6].occupe != 1)
    {
        map->mapjeu.tabJeu[2][0] = map->mapjeu.tour;
        map->mapjeu.caseJeu[6].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[7]) == 1
            && map->mapjeu.caseJeu[7].occupe != 1)
    {
        map->mapjeu.tabJeu[2][1] = map->mapjeu.tour;
        map->mapjeu.caseJeu[7].occupe = 1;
        change_tour(map);
    }
    if (AABBCollision(touche->posSouris.x + MOITIE_IMAGE_LARGEUR , touche->posSouris.y + MOITIE_IMAGE_HAUTEUR , map->mapjeu.posCase[8]) == 1
            && map->mapjeu.caseJeu[8].occupe != 1)
    {
        map->mapjeu.tabJeu[2][2] = map->mapjeu.tour;
        map->mapjeu.caseJeu[8].occupe = 1;
        change_tour(map);
    }
}

draw.c

#include "draw.h"

void draw_victoireJ1(Map *map , Touche *touche)
{
    SDL_BlitSurface(map->mapjeu.joueur[0].imageVaiqueur , NULL , map->ecran , NULL);
    SDL_BlitSurface(map->mapmenu.curseur , NULL , map->ecran , &touche->posSouris);
}
void draw_victoireJ2(Map *map , Touche *touche)
{
    SDL_BlitSurface(map->mapjeu.joueur[1].imageVaiqueur , NULL , map->ecran , NULL);
    SDL_BlitSurface(map->mapmenu.curseur , NULL , map->ecran , &touche->posSouris);
}

void draw_point(Map *map)
{
    SDL_BlitSurface(map->mapjeu.texte.pointTexte[0] , NULL , map->ecran , &map->mapjeu.texte.pos1);
    SDL_BlitSurface(map->mapjeu.texte.pointTexte[1] , NULL , map->ecran , &map->mapjeu.texte.pos2);
}

void draw_pion(Map *map)
{
    int i , j;
    SDL_Rect pos;

    for (j = 0 ; j < HAUTEUR_LEVEL ; j++)
    {
        for (i = 0 ; i < LARGEUR_LEVEL ; i++)
        {
            switch (map->mapjeu.tabJeu[j][i])
            {
            case 1 :
                pos.x = 175 + i * 111;
                pos.y = 80 + j * 113;
                SDL_BlitSurface(map->mapjeu.pionJ1 , NULL , map->ecran , &pos);
                break;
            case 2 :
                pos.x = 175 + i * 111;
                pos.y = 80 + j * 113;
                SDL_BlitSurface(map->mapjeu.pionJ2 , NULL , map->ecran , &pos);
                break;
            default : break;
            }
        }
    }
}

void draw_jeu(Map *map , Touche *touche)
{
    SDL_BlitSurface(map->mapjeu.grille , NULL , map->ecran , &map->mapjeu.grillePos);

    draw_pion(map);

    if (map->mapjeu.tour == 1)
    {
        SDL_BlitSurface(map->mapjeu.pionJ1 , NULL , map->ecran , &touche->posSouris);
    }
    if (map->mapjeu.tour == 2)
    {
        SDL_BlitSurface(map->mapjeu.pionJ2 , NULL , map->ecran , &touche->posSouris);
    }

    draw_point(map);
}

void draw_menu(Map *map , Touche *touche)
{
    SDL_BlitSurface(map->mapmenu.image[map->mapmenu.imageActuelle] , NULL , map->ecran , &map->mapmenu.destinationMenu);
    SDL_BlitSurface(map->mapmenu.curseur , NULL , map->ecran , &touche->posSouris);
}

void draw_credit(Map *map , Touche *touche)
{
    SDL_BlitSurface(map->mapmenu.credit.image , NULL , map->ecran , NULL);
    SDL_BlitSurface(map->mapmenu.curseur , NULL , map->ecran , &touche->posSouris);
}

void draw(Map *map , Touche *touche)
{
    SDL_FillRect(map->ecran , NULL , SDL_MapRGB(map->ecran->format , 255 , 255 , 255 ));

    if (map->dansJeu == 1 && map->inVictoireJ1 != 1 && map->inVictoireJ2 != 1)
        draw_jeu(map , touche);
    if (map->dansMenu == 1)
        draw_menu(map , touche);
    if(map->dansCredit == 1)
        draw_credit(map , touche);
    if(map->inVictoireJ1 == 1)
        draw_victoireJ1(map , touche);
    if(map->inVictoireJ2 == 1)
        draw_victoireJ2(map , touche);

    SDL_Flip(map->ecran);
}

init.c :

#include "init.h"

SDL_Surface *init_img(const char file[])/*charge une image*/
{
    SDL_Surface *imgTemporaire = NULL;
    SDL_Surface *imgNew = NULL;

    imgTemporaire = IMG_Load(file);

    if (imgTemporaire == NULL)
    {
        fprintf(stderr, "Erreur avec %s\n--> %s\n" , file, IMG_GetError());
        return NULL;
    }

    imgNew = SDL_DisplayFormat(imgTemporaire);

    SDL_SetColorKey(imgNew , (SDL_SRCCOLORKEY | SDL_RLEACCEL) , SDL_MapRGB( SDL_GetVideoSurface()->format , 0 , 206 , 0));

    SDL_FreeSurface(imgTemporaire);

    return imgNew;
}

void init_sdl(Map *map)
{
    if (SDL_Init(SDL_INIT_VIDEO) < 0)
    {
        fprintf(stderr , "Erreur -> %s" , SDL_GetError());
    }

    map->ecran = SDL_SetVideoMode(LARGEUR , HAUTEUR , 32 , SDL_HWSURFACE | SDL_DOUBLEBUF);
    if (map->ecran == NULL)
    {
        fprintf(stderr , "Erreur -> %s" , SDL_GetError());
    }

    SDL_WM_SetCaption("Morpion" , NULL);

    srand(time(NULL));

    if (Mix_OpenAudio(44100 , MIX_DEFAULT_FORMAT , MIX_DEFAULT_CHANNELS , 1024) == -1) /*Initialisation de l'API Mixer*/
    {
        fprintf(stderr , "erreur avec mix open audio");
    }

    Mix_AllocateChannels(10);

    if (TTF_Init() == -1)
    {
        fprintf(stderr, "Erreur avec TTF_Init");
    }
}

input.c :

#include "input.h"

void test_touche(Touche *touche , int *continuer)
{
    SDL_Event event;

    while (SDL_PollEvent(&event))
    {
        switch (event.type)
        {
        case SDL_QUIT :
            *continuer = 0;
            break;
        case SDL_KEYDOWN :
            switch (event.key.keysym.sym)
            {
            case SDLK_RETURN :
                touche->entrer = 1;
                break;
             case SDLK_ESCAPE :
                touche->echap = 1;
                break;
            default : ;
            }
            break;
        case SDL_KEYUP :
            switch (event.key.keysym.sym)
            {
            case SDLK_RETURN :
                touche->entrer = 0;
                break;
             default : break;
            }
            break;
        case SDL_MOUSEBUTTONDOWN :
            switch (event.button.button)
            {
            case SDL_BUTTON_LEFT :
                touche->clic = 1;
                break;
            default : break;
            }
            break;
        case SDL_MOUSEBUTTONUP :
            touche->clic = 0;
            break;
        case SDL_MOUSEMOTION:
            touche->posSouris.x = event.motion.x; /* On change les coordonnées de Zozor */
            touche->posSouris.y = event.motion.y;
            break;
        default :
            break;
        }
    }
}

map.c :

#include "map.h"

void init_map_credit(Map *map)
{
    map->mapmenu.credit.image = init_img("Ressources/img/menu/credit.png");
    map->mapmenu.credit.musique = Mix_LoadMUS("Ressources/sound/musicCredit.mp3");
}

void init_map_pos_case(Map *map)
{
    charger_box(map->mapjeu.posCase, "Ressources/AABB/case.aabb" , 9);
}

void reinit_map(Map *map)
{
    init_map_pos_case(map);
    init_case_valeur(map);
    hasard_commence(map);
}

void init_map_jeu(Map *map)
{
    map->mapjeu.grille = init_img("Ressources/img/jeu/grille.png");
    map->mapjeu.pionJ1 = init_img("Ressources/img/jeu/pionJ1.png");
    map->mapjeu.pionJ2 = init_img("Ressources/img/jeu/pionJ2.png");
    map->mapjeu.joueur[0].imageVaiqueur = init_img("Ressources/img/jeu/victoireJ1.png");
    map->mapjeu.joueur[1].imageVaiqueur = init_img("Ressources/img/jeu/victoireJ2.png");

    map->mapjeu.grillePos.x = 0;
    map->mapjeu.grillePos.y = 0;

    init_map_pos_case(map);
    init_case_valeur(map);

    init_texte(map);
}

void init_map_menu(Map *map)
{
    map->mapmenu.image[RIEN] = init_img("Ressources/img/menu/menu.png");
    map->mapmenu.image[CLIC1] = init_img("Ressources/img/menu/menu1.png");
    map->mapmenu.image[CLIC2] = init_img("Ressources/img/menu/menu2.png");
    map->mapmenu.image[CLIC3] = init_img("Ressources/img/menu/menu3.png");
    map->mapmenu.destinationMenu.x = 0;
    map->mapmenu.destinationMenu.y = 0;

    map->mapmenu.imageActuelle = RIEN;

    charger_box(map->mapmenu.clicMenu , "Ressources/AABB/boxmenu.aabb" , 3);
    map->mapmenu.curseur = init_img("Ressources/img/curseur.png");

    map->mapmenu.musique = Mix_LoadMUS("Ressources/sound/musicMenu.mp3");

    init_map_credit(map);
}

void init_map(Map *map)
{
    map->dansJeu = 0;
    map->dansMenu = 1;
    map->dansCredit = 0;
    map->inVictoireJ1 = 0;
    map->inVictoireJ2 = 0;
    init_map_menu(map);
    init_map_jeu(map);

    map->son[0] = Mix_LoadWAV("Ressources/sound/Woohoo.wav");
    map->son[1] = Mix_LoadWAV("Ressources/sound/clic.wav");
    map->son[2] = Mix_LoadWAV("Ressources/sound/quitter.wav");
}

update.c :

#include "update.h"

void update_image_victoire(Map *map , Touche *touche)
{
    if (touche->entrer == 1)
    {
        map->inVictoireJ1 = 0;
        map->inVictoireJ2 = 0;
        map->mapjeu.joueur[0].nombrePointJ = 0;
        map->mapjeu.joueur[1].nombrePointJ = 0;
        map->dansJeu = 0;
        map->dansMenu = 1;
        Mix_PlayChannel(-1, map->son[1], 0);
    }
}

void update_texte(Map *map)
{
    int i;
    SDL_Color color;
    color.r = 0;
    color.g = 0;
    color.b = 0;

    for (i = 0 ; i < 2 ; i++)
    {
        SDL_FreeSurface(map->mapjeu.texte.pointTexte[i]);
    }

    sprintf(map->mapjeu.texte.nombrePointJ1 , "%d Points" , map->mapjeu.joueur[0].nombrePointJ);
    sprintf(map->mapjeu.texte.nombrePointJ2 , "%d Points" , map->mapjeu.joueur[1].nombrePointJ);

    map->mapjeu.texte.pointTexte[0] = TTF_RenderText_Blended(map->mapjeu.texte.police, map->mapjeu.texte.nombrePointJ1 , color);
    map->mapjeu.texte.pointTexte[1] = TTF_RenderText_Blended(map->mapjeu.texte.police, map->mapjeu.texte.nombrePointJ2 , color);
}

void update_victoire(Map *map)
{
    testJoueurVictoire(map , 1);
    testJoueurVictoire(map , 2);

    if (map->mapjeu.joueur[0].nombrePointJ == 3)
    {
        map->inVictoireJ1 = 1;
        Mix_PlayChannel(-1, map->son[0], 0);
        Mix_PlayChannel(-1, map->son[1], 0);
    }
    if (map->mapjeu.joueur[1].nombrePointJ == 3)
    {
        map->inVictoireJ2 = 1;
        Mix_PlayChannel(-1, map->son[0], 0);
    }
}

void update_souris_menu(Map *map , Touche *touche)
{
    if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[0]) == 1)
        map->mapmenu.imageActuelle = CLIC1;

    if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[1]) == 1)
        map->mapmenu.imageActuelle = CLIC2;

    if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[2]) == 1)
        map->mapmenu.imageActuelle = CLIC3;

    else if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[0]) == 0 &&
             AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[1]) == 0 &&
             AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[2]) == 0)
    {
        map->mapmenu.imageActuelle = RIEN;
    }
}

void update_clic_menu(Map *map , Touche *touche)
{
    if (touche->clic == 1)
    {
        if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[0]) == 1)
        {
            Mix_PlayChannel(-1, map->son[1], 0);
            map->dansMenu = 0;
            map->dansJeu = 1;
            hasard_commence(map);
            touche->clic = 0;
        }

        if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[1]) == 1)
        {
            Mix_PlayChannel(-1, map->son[1], 0);
            map->dansMenu = 0;
            map->dansCredit = 1;
            Mix_PlayMusic(map->mapmenu.credit.musique , -1);
        }

        if (AABBCollision(touche->posSouris.x ,touche->posSouris.y , map->mapmenu.clicMenu[2]) == 1)
        {
            Mix_PlayChannel(-1, map->son[2], 0);
            exit(0);
        }
    }

}

void update_jeu(Map *map , Touche *touche)
{
    if (touche->clic == 1)
    {
        collisionCase(map , touche);
        touche->clic = 0;
    }
    if(touche->echap == 1)/*Retour au menu si on appuis sur echap*/
    {
        map->inVictoireJ1 = 0;
        map->inVictoireJ2 = 0;
        map->mapjeu.joueur[0].nombrePointJ = 0;
        map->mapjeu.joueur[1].nombrePointJ = 0;
        map->dansJeu = 0;
        map->dansMenu = 1;
        Mix_PlayChannel(-1, map->son[1], 0);
    }
    update_victoire(map);

    test_egalite(map);

    update_texte(map);
}

void update_menu(Map *map , Touche *touche)
{
    update_souris_menu(map , touche);
    update_clic_menu(map , touche);
}

void update_credit(Map *map , Touche *touche)
{
    if (touche->entrer == 1)
    {
        map->dansCredit = 0;
        map->dansMenu = 1;
        Mix_PlayChannel(-1, map->son[1], 0);
        Mix_HaltMusic();
        Mix_PlayMusic(map->mapmenu.musique , -1);
    }
}

void update(Map *map , Touche *touche)
{
    if (map->dansJeu == 1 && map->inVictoireJ1 !=1 && map->inVictoireJ2 != 1)
        update_jeu(map , touche);
    if (map->dansMenu == 1)
        update_menu(map , touche);
    if (map->dansCredit == 1)
        update_credit(map , touche);
    if (map->inVictoireJ1 == 1 || map->inVictoireJ2 == 1)
        update_image_victoire(map , touche);
}

collision.h :

#ifndef COLLISION_H
#define COLLISION_H

#include "structs.h"

int AABBCollision(int curseur_x ,int curseur_y ,AABB box);
void collisionCase(Map *map , Touche *touche);
void change_tour(Map *map);

#endif

defs.h :

#ifndef DEFS_H
#define DEFS_H

#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <SDL_Image.h>
#include <SDL_Mixer.h>
#include <time.h>
#include <SDL_ttf.h>

#define LARGEUR 640
#define HAUTEUR 480

#define HAUTEUR_LEVEL 3
#define LARGEUR_LEVEL 3

#define HAUTEUR_IMAGE 73
#define LARGEUR_IMAGE 73

#define MOITIE_IMAGE_HAUTEUR 36
#define MOITIE_IMAGE_LARGEUR 36

enum{RIEN , CLIC1 , CLIC2 , CLIC3};

#endif

draw.h :

#ifndef DRAW_H
#define DRAW_H

#include "structs.h"

void draw(Map *map , Touche *touche);
void draw_jeu(Map *map , Touche *touche);
void draw_menu(Map *map , Touche *touche);
void draw_victoireJ1(Map *map , Touche *touche);
void draw_victoireJ2(Map *map , Touche *touche);
void draw_point(Map *map);
void draw_pion(Map *map);
void draw_credit(Map *map , Touche *touche);

#endif

init.h :

#ifndef INIT_H
#define INIT_H

#include "structs.h"

void init_sdl(Map *map);
SDL_Surface *init_img(const char file[]);

#endif

input.h :

#ifndef INPUT_H
#define INPUT_H

#include "structs.h"

void test_touche(Touche *touche , int *continuer);

#endif

main.h :

#ifndef MAIN_H
#define MAIN_H

#include "structs.h"

void delay(void);
void init_sdl(Map *map);
void init_map(Map *map);
void test_touche(Touche *touche , int *continuer);
void draw(Map *map , Touche *touche);
void update(Map *map , Touche *touche);

#endif

map.h :

#ifndef MAP_H
#define MAP_H

#include "structs.h"

void init_map_menu(Map *map);
void init_map(Map *map);
SDL_Surface *init_img(const char file[]);
void charger_box(AABB box[] , char file[] , int nombreMax);
void init_map_jeu(Map *map);
void init_map_credit(Map *map);
void init_map_pos_case(Map *map);
void reinit_map(Map *map);
void init_case_valeur(Map *map);
void hasard_commence(Map *map);
void init_texte(Map *map);

#endif

structs.h :

#ifndef STRUCTS_H
#define STRUCTS_H

#include "defs.h"

typedef struct
{
    int x ,  y , h , w;

}AABB;

typedef struct
{
    int occupe;/*1 = Joueur 1 ; 2 = joueur 2*/

}Case;

typedef struct
{
    TTF_Font *police;
    SDL_Surface *pointTexte[2];
    char nombrePointJ1[100];
    char nombrePointJ2[100];

    SDL_Rect pos1 , pos2;

}Texte;

typedef struct
{
    int nombrePointJ;
    SDL_Surface *imageVaiqueur;

}Joueur;

typedef struct
{
    SDL_Surface *grille;
    SDL_Surface *pionJ1;
    SDL_Surface *pionJ2;
    SDL_Rect grillePos;
    Case caseJeu[9];
    int tour; /*qui commence ? Joueur 1 ou Joueur 2*/
    SDL_Surface *imgSouris[2]; /*représente le tour joueur en gros*/
    int tabJeu[HAUTEUR_LEVEL][LARGEUR_LEVEL];
    AABB posCase[9];
    Texte texte;
    Joueur joueur[2];

}MapJeu;

typedef struct
{
    Mix_Music *musique;
    SDL_Surface *image;

}Credit;

typedef struct
{
    SDL_Surface *curseur;
    SDL_Surface *image[4];
    AABB clicMenu[3];
    SDL_Rect destinationMenu;
    int imageActuelle;
    Mix_Music *musique;

    Credit credit;

}MapMenu;

typedef struct
{
    MapMenu mapmenu;
    MapJeu mapjeu;
    SDL_Surface *ecran;
    int dansJeu;
    int dansMenu;
    int dansCredit;
    int inVictoireJ1;
    int inVictoireJ2;

    Mix_Chunk *son[3];
}Map;

typedef struct
{
    int clic;
    SDL_Rect posSouris;
    int entrer , echap;

}Touche;

#endif

update.h :

#ifndef UPDATE_H
#define UPDATE_H

#include "structs.h"
void update(Map *map , Touche *touche);
void update_jeu(Map *map , Touche *touche);
void update_menu(Map *map , Touche *touche);
void update_souris_menu(Map *map , Touche *touche);
int AABBCollision(int curseur_x ,int curseur_y ,AABB box);
void update_clic_menu(Map *map , Touche *touche);
void hasard_commence(Map *map);
void update_image_victoire(Map *map , Touche *touche);
void update_texte(Map *map);
void update_victoire(Map *map);
void testJoueurVictoire(Map *map , int joueur);
void collisionCase(Map *map , Touche *touche);
void test_egalite(Map *map);
void update_credit(Map *map , Touche *touche);

#endif

utiles.h :

#ifndef UTILES_H
#define UTILES_H

#include "structs.h"

int AABBCollision(int curseur_x ,int curseur_y ,AABB box);
void charger_box(AABB box[] , char file[] , int nombreMax);
void hasard_commence(Map *map);
void init_texte(Map *map);
void change_tour(Map *map);
void init_case_valeur(Map *map);
void test_verticale(Map *map , int joueur);
void reinit_map(Map *map);
void test_horizontale(Map *map , int joueur);
void test_oblique(Map *map , int joueur);
void testJoueurVictoire(Map *map , int joueur);
void test_egalite(Map *map);

#endif

Voila , Merci .
Bonne soirée et joyeux Noel !

Camp0us

25 décembre 2011 à 3:32:44

C'est bien codé! (tu as pas mal progressé par rapport à des bouts de code que j'avais vu avant). Dommage juste peut être de ne pas gérer tes évènements avec la méthode de fvirtman (la fonction test_touche()).

Pouet_forever

25 décembre 2011 à 11:59:00

Citation : Camp0us

C'est bien codé!

Tout est relatif.

Il manque des fichiers !
Le fait de tout inclure dans un .h n'est pas forcément la meilleure des idées (bon, c'est pas grave pour un petit projet, mais pour un grand tu vas avoir des surprises). Tout simplement que, si tu modifies 1 seule chose dans ton .h, tu seras obligé de recompiler tous tes fichiers.

Pourquoi dans ton fichier 'map.c' il n'y a que des fonctions 'init' ? lol
C'est dangereux ce que tu fais avec tes .h, tu ne sais pas trop qui inclut qui. Essaye d'harmoniser ça.

T'es sûr que ta fonction 'collisionCase' ne peut pas être améliorée ?
Je me suis pas plongé dans le code, j'ai juste vu ce qui m'a sauté aux yeux.

C'est vrai que c'est mieux que tes précédents codes, continues comme ça, ça va venir !

Evite peut-être de t'embarquer dans des projets trop conséquents avant d'être vraiment à l'aise et d'avoir les techniques de programmations adéquates !)
Joyeux noël !

Shadow-Homer

25 décembre 2011 à 12:43:01

Merci

J'crois que j'ai mis tout les fichiers ?

Citation

Le fait de tout inclure dans un .h n'est pas forcément la meilleure des idées (bon, c'est pas grave pour un petit projet, mais pour un grand tu vas avoir des surprises). Tout simplement que, si tu modifies 1 seule chose dans ton .h, tu seras obligé de recompiler tous tes fichiers

Bah je recompile tout le temps de toute façon , mais je trouve que c'est propre au lieu que je mette à chaque fichier .h les inclusions de la SDL etc !

Citation

Pourquoi dans ton fichier 'map.c' il n'y a que des fonctions 'init' ? lol

Je fait toujours comme ça , même dans TDOA il y a 310 lignes d'initialisation dans map.c ^^'

Citation

C'est dangereux ce que tu fais avec tes .h, tu ne sais pas trop qui inclut qui. Essaye d'harmoniser ça.

Ok merci , tu me conseille de faire comment ?

Citation

T'es sûr que ta fonction 'collisionCase' ne peut pas être améliorée ?

Bah nan jcrois pas que c'est possible !

Citation

C'est vrai que c'est mieux que tes précédents codes, continues comme ça, ça va venir !

Merci

Citation

Evite peut-être de t'embarquer dans des projets trop conséquents avant d'être vraiment à l'aise et d'avoir les techniques de programmations adéquates !)

Justement c'est faire de gros projets qui m'améliore :magicien:

Joyeux Noel encore une fois

Pouet_forever

26 décembre 2011 à 0:49:47

Je pense qu'il n'y a pas tous les fichiers. Par exemple la fonction change_tour n'est présente que dans un .h. Il y en a d'autres comme ça.

Tu penses tout recompiler, mais ton compilateur est intelligent et il recompile uniquement ce qui a été modifié.

C'est pas parce que tu as toujours fait comme ça que c'est forcément une bonne idée, tu crois pas ?

Bah, un .h n'inclus que ce dont il a besoin. Là tu as un .h qui inclus des .h qui inclus d'autres .h. Au final tu t'y perds vite !
Sisi, je suis sûr que si.

C'est toi qui voit, mais les gros projets ça t'apprends, c'est sûr, mais tu vois toujours la même chose, du coup tu progresses pas forcément plus vite. Et tu as moins de retours. Un code d'une centaine de lignes ça se lit vite et tu peux avoir des critiques, un code d'un milliers de lignes un peu bancale, ça ne se lit pas du tout et tu n'auras pas de commentaires. :-°

Shadow-Homer

26 décembre 2011 à 1:17:04

Ok merci , je vais revoir le code

Citation

C'est toi qui voit, mais les gros projets ça t'apprends, c'est sûr, mais tu vois toujours la même chose, du coup tu progresses pas forcément plus vite. Et tu as moins de retours. Un code d'une centaine de lignes ça se lit vite et tu peux avoir des critiques, un code d'un milliers de lignes un peu bancale, ça ne se lit pas du tout et tu n'auras pas de commentaires.

C'est pour ça que j'ai d'autres projets en parallèles (tetris)

Encore merci pour ton retour !

Capricornus

28 décembre 2011 à 10:35:30

@ Shadow-Homer:
juste un tout petit détail. Sur ton screenshot n°2 avec les cercles et les croix, on voit un petit décalage entre la première ligne verticale et la deuxième colonne de cases, et le même petit décalage entre la deuxième ligne verticale et la dernière colonne.

Shadow-Homer

28 décembre 2011 à 21:42:53

Citation : Capricornus

@ Shadow-Homer:
juste un tout petit détail. Sur ton screenshot n°2 avec les cercles et les croix, on voit un petit décalage entre la première ligne verticale et la deuxième colonne de cases, et le même petit décalage entre la deuxième ligne verticale et la dernière colonne.

exact merci , sinon ta résout ton problème ?

<< 1 2 3 4

zMorp SDL

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.

× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.

zMorp SDL

zMorp SDL

Supprimer

Modérer

Signaler le message aux modérateurs