Forums des Zéros

22 janvier 2011 à 13:41:39

Voilà, j'ai terminé le mien :

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <SDL/SDL.h>

#define MAX 2
#define MIN 1
#define TAILLETAB 3
#define T_CASE 160

void affichage(char** tableau, SDL_Surface *ecran, SDL_Surface *c_vide, SDL_Surface *c_j1, SDL_Surface *c_j2);
int saisie(int joueur);
int testerCoup(int coord, char** tableau); // Si le coup est bon, il renvoie 1
void jouerCoup(char** tableau, int coord, int joueur);
void gagner(char** tableau, int* gagne, int joueur); //teste si un joueur a gagné, mais aussi si le tableau est plein.
void rejouer(int* jouer);

int main(void)
{	
	SDL_Init(SDL_INIT_VIDEO);
	SDL_Surface *ecran = NULL;
	SDL_Surface *c_vide = NULL;
	SDL_Surface *c_j1 = NULL;
	SDL_Surface *c_j2 = NULL;

	srand(time(NULL));

	int jouer = 1;
	
	while (jouer == 1)
	{
		int coord = 0;
		int i = 0;
		int j = 0;
		int gagne = 0;
		char** tableau = NULL;
		int joueur = 1; //1 : joueur 1, 2 : joueur 2
		
		tableau = malloc(TAILLETAB * sizeof(char *));
		if (tableau == NULL)
			exit(0);

		for (i = 0; i < TAILLETAB; i++)
		{
			tableau[i] = malloc(TAILLETAB * sizeof(char));
			if (tableau[i] == NULL)
				exit(0);
		}

		//Initialisation 
		for (i = 0 ; i < TAILLETAB; i++)
		{
			for (j = 0; j < TAILLETAB; j++)
				tableau[i][j] = '.';
		}
		//Tirage au sort
		joueur = (rand() % (MAX - MIN + 1)) + MIN;
		
		while (!gagne)
		{
			//Affichage du morpion
			affichage (tableau, ecran, c_vide, c_j1, c_j2);
			//Saisie des coordonnées et tester si le coup est permis
			do
				coord = saisie(joueur);
			while(testerCoup(coord, tableau) == 0);
			//On inscrit le coup dans le tableau
			jouerCoup(tableau, coord, joueur);
			//On change de joueur
			if (joueur == 1)
				joueur++;
			else if (joueur == 2)
				joueur--;
			
			//Un joueur a gagné ?	
			gagner(tableau, &gagne, joueur);
			
			if (gagne == 1)
				affichage (tableau, ecran, c_vide, c_j1, c_j2);

		}
		
		rejouer(&jouer);
	}
	
	SDL_FreeSurface(c_vide);
	SDL_FreeSurface(c_j1);
	SDL_FreeSurface(c_j2);
	SDL_Quit();
	
	return EXIT_SUCCESS;
}

void affichage(char** tableau, SDL_Surface *ecran, SDL_Surface *c_vide, SDL_Surface *c_j1, SDL_Surface *c_j2)
{
	int i = 0;
	int j = 0;
	
	ecran = SDL_SetVideoMode(T_CASE*TAILLETAB+20, T_CASE*TAILLETAB+20, 32, SDL_SWSURFACE);
	if (ecran == NULL)
		exit(EXIT_FAILURE);
		
	SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
	SDL_Flip(ecran);
	
	c_vide = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	c_j1 = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	c_j2 = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	
	SDL_FillRect(c_vide, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
	SDL_FillRect(c_j1, NULL, SDL_MapRGB(ecran->format, 255, 161, 0));
	SDL_FillRect(c_j2, NULL, SDL_MapRGB(ecran->format, 0, 71, 255));

	/*Blit*/

	SDL_Rect position;

	position.x = 0;
	position.y = 0;

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == '.')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;

				SDL_BlitSurface(c_vide, NULL, ecran, &position);
			}
			else if (tableau[i][j] == 'X')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;
				
				SDL_BlitSurface(c_j1, NULL, ecran, &position);
			}
			else if (tableau[i][j] == 'O')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;

				SDL_BlitSurface(c_j2, NULL, ecran, &position);
			}
		}
	}
	SDL_Flip(ecran);
}

int saisie(int joueur)
{
	int x = 0, y = 0, continuer = 1;

	SDL_Event event;
	
	if (joueur == 1)
		SDL_WM_SetCaption("Joueur 1, à vous de jouer...", NULL);
	else if (joueur == 2)
		SDL_WM_SetCaption("Joueur 2, à vous de jouer...", NULL);
	
	while (continuer)
	{
		SDL_WaitEvent(&event);
		switch(event.type)
		{
			case SDL_MOUSEBUTTONUP:
				x = event.button.x/(T_CASE+20);
				y = event.button.y/(T_CASE+20);
				continuer = 0;
				break;
			case SDL_QUIT:
				continuer = 0;
				break;
		}
	}

	return x+(y*TAILLETAB);
}

void gagner(char** tableau, int* gagne, int joueur)
{
	int count_1 = 0;
	int count_2 = 0;
	int i = 0;
	int j = 0;
	int casesPl = 0;

	//Tests sur l'abscisse

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == 'X')
				count_1++;
			else if (tableau[i][j] == 'O')
				count_2++;

			if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			{	
				i = TAILLETAB;
				j = TAILLETAB;
				
				if (count_1 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
				else if (count_2 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

				*gagne = 1;
			}
		}
		count_1 = 0;
		count_2 = 0;		
	}
	
	count_1 = 0;
	count_2 = 0;

	//Tests sur l'ordonnée

	for (j = 0; j < TAILLETAB; j++)
	{
		for (i = 0; i < TAILLETAB; i++)
		{
			if (tableau[i][j] == 'X')
				count_1++;
			else if (tableau[i][j] == 'O')
				count_2++;

			if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			{
				if (count_1 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
				else if (count_2 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

				*gagne = 1;
				break;
			}
		}

		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			break;
		count_2 = 0;
		count_1 = 0;
	}
	
	count_1 = 0;
	count_2 = 0;

	//Tests sur les diagonales

	for (i = 0; i < TAILLETAB; i++)
	{	
		if (tableau[i][i] == 'X')
			count_1++;
		else if (tableau[i][i] == 'O')
			count_2++;
		
		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
		{
			if (count_1 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
			else if (count_2 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

			*gagne = 1;
			break;
		
		}
	}
	count_2 = 0;
	count_1 = 0;

	for (i = 1; i < TAILLETAB; i++)
	{
		if (tableau[i-1][TAILLETAB-i] == 'X')
			count_1++;
		else if (tableau[i][TAILLETAB-i] == 'O')
			count_2++;
		
		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
		{
			if (count_1 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
			else if (count_2 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

			*gagne = 1;
			break;

		}
	}

	count_2 = 0;
	count_1 = 0;
	
	//Teste si toutes les cases sont pleines 

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == 'X' || tableau[i][j] == 'O')
				casesPl++;
		}
	}
			
	if (casesPl == (TAILLETAB*TAILLETAB) && *gagne != 0)
	{
		*gagne = 1;
		SDL_WM_SetCaption("Personne n'a gagné ! Rejouer ? (O/N)", NULL);
	}
}


int testerCoup(int coord, char** tableau)
{
	int x = 0, y = 0;

	x = coord%TAILLETAB;
	y = coord/TAILLETAB;

	if (tableau[y][x] == 'X' || tableau[y][x] == 'O')
		return 0;
	else
		return 1;
}

void jouerCoup(char** tableau, int coord, int joueur)
{
	int x = 0, y = 0;
	
	x = coord%TAILLETAB;
	y = coord/TAILLETAB;

	if (joueur == 1)
		tableau[y][x] = 'X';
	
	else if (joueur == 2)
		tableau[y][x] = 'O';
}

void rejouer(int* jouer)
{
	int continuer = 1;
	
	SDL_Event event;

	while (continuer)
	{
		SDL_WaitEvent(&event);

		switch(event.type)
		{
			case SDL_KEYDOWN:
				switch(event.key.keysym.sym)
				{
					case SDLK_o:
						*jouer = 1;
						continuer = 0;
						break;
					case SDLK_n:
						*jouer = 0;
						continuer = 0;
						break;
				}
		}
	}
}

joe78

22 janvier 2011 à 16:44:28

Bonjour,

@sydzero :
Juste au passage, il y a quelques petits soucis avec ton code :
- Ligne 40, tu fais un malloc dans une boucle et cette mémoire n'est jamais libérée (il n'y a pas un seul 'free' dans ton code). Tu as donc une fuite mémoire.

* Fonction 'Affichage' :
- Ligne 100, tu fais SDL_SetVideoMode. Cette fonction ne devrait être appelée qu'une fois dans ton main, pas successivement à chaque tour de boucle. (Sans parler de la fuite mémoire).

Tu passes 3 pointeurs à ta fonction, c_vide, c_j1 et c_j2. Tu écrases le contenu de ces pointeurs lignes 107, 108 et 109 avec le CreateRGBSurface, et tu ne libères jamais cette mémoire. La encore, c'est une fuite mémoire.

Soit tu fais les CreateRGBSurface et les FreeSurface dans la fonction affichage, soit tu les fais dans le main et tu passes les pointeurs à ta fonction 'affichage'.

Dans l'état actuel, les FreeSurface dans le main ne liberent rien, puisque la valeur des pointeurs reste à NULL dans le 'main'.

Le mieux serait de faire tes RGBCreateSurface dans le main, ça résoudrait tous les problèmes.

(Et le plus simple serait de faire directement tes SDL_FillRect dans ta surface 'ecran').

Enfin, il est plus sûr de tester le résultat des fonctions SDL_Init, SDL_SetVideoMode et SDL_CreateRGBSurface, ce qui évite de chercher quand un plantage survient.

Enfin voilà, c'était juste en survolant, je n'ai pas testé. Je laisse GurneyH et Pouet_forever le soin de commenter plus en profondeur.

Ne le prends pas mal, hein, c'est déjà bien de proposer qqchose !

(Moi je n'ai pas eu le temps). Je me contente juste de te signaler les petits problèmes que j'ai vu.

Clément.

22 janvier 2011 à 18:30:06

Merci joe78, je prend note

Nouveau site en constrution sur les mangas, anime, Visual novel

22 janvier 2011 à 20:12:09

Bonjour, je vous mets mon code (C'est un peu beaucoup le bordel par contre, faut que je m'améliore... :-°

)

main.c

#include "include.h"

int main(int argc, char *argv[]){
    if(Init() != EXIT_SUCCESS)
        return EXIT_FAILURE;
    initGame();
    Quit();
    return EXIT_SUCCESS;
}

include.h

#ifndef INCLUDE_H
#define INCLUDE_H

#include <time.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include "SDL.h"
#include "game.h"


#define CELL_SPACE 4
#define CELL_LENGTH 150
#define SCREEN_LENGTH CELL_LENGTH * 3 + CELL_SPACE * 4

enum {VIDE, PLAYER1, PLAYER2};

#endif

game.h

#ifndef GAME_H
#define GAME_H
// Menu principal
void initGame();

// Ecran de jeu
int play(SDL_Surface*);

// Récupère les coordonnées d'une cellule
SDL_Rect getCell(int,int);

// Indique si une cellule est vide
int isEmpty(SDL_Rect, int[][3]);

// Remplit une cellule (en arrière-plan par la valeur du joueur)
void fillCell(SDL_Rect, int[][3], int);

// Retourne toutes les cellules vides (pour l'ordi)
int getEmptyCells(int[][3], int[8]);

// Retourne une cellule aléatoire
SDL_Rect getRandomCell(int[8], int*);

// Vérifie si quelqu'un à gagné
int hasWin(int,int[][3]);

#endif

game.c

#include "include.h"

// Menu principal
void initGame(){
    SDL_Surface *screen = 0;
    if((screen = SDL_SetVideoMode(SCREEN_LENGTH, SCREEN_LENGTH, 32, SDL_HWSURFACE | SDL_DOUBLEBUF))){
        TTF_Font *bigFont = TTF_OpenFont("fonts/angelina.ttf", 130),
                 *littleFont = TTF_OpenFont("fonts/angelina.ttf", 60),
                 *tinyFont = TTF_OpenFont("fonts/angelina.ttf", 40);
        SDL_Color white = {255,255,255}, black = {0,0,0};
        SDL_Surface *zMorp = TTF_RenderText_Shaded(bigFont, "zMorp", white, black),
                    *by = TTF_RenderText_Shaded(littleFont, "by Zenko", white, black),
                    *msg = TTF_RenderText_Shaded(tinyFont, "Press \"Enter\" to play", white, black);
        Input in;
        SDL_WM_SetCaption("zMorp", NULL);
        int quitGame = 0;
        memset(&in, 0, sizeof(in));
        while (!in.quit && !in.key[SDLK_ESCAPE] && !quitGame){
            UpdateEvent(&in);
            if(in.key[SDLK_RETURN]){ // Si "Entrée", on joue
                in.key[SDLK_RETURN] = 0;
                quitGame = play(screen);
            }
            if(!quitGame){ // Si on a pas encore quitté le jeu, on blitte
                fill(screen, black);
                blit(zMorp, screen, (screen->w / 2 - zMorp->w / 2), 30);
                blit(msg, screen, (screen->w / 2 - msg->w / 2), (screen->h / 2 - msg->h / 2));
                blit(by, screen, (screen->w - by->w - 10), (screen->h - by->h - 20));
                SDL_Flip(screen);
            }
        }

        // Faut pas oublier de tous libérer !!!
        SDL_FreeSurface(zMorp);
        SDL_FreeSurface(by);
        SDL_FreeSurface(msg);
        TTF_CloseFont(bigFont);
        TTF_CloseFont(littleFont);
        TTF_CloseFont(tinyFont);
    }
}

// Ecran de jeu
int play(SDL_Surface *screen){
    int cells[3][3] = {
        {VIDE,VIDE,VIDE},
        {VIDE,VIDE,VIDE},
        {VIDE,VIDE,VIDE}
    }, quitGame = 0, gameOver = 0, winner = 0, i = 0, cellsLeft = 9, emptyCells[8]; // 8 car c'est toujours au joueur de commencer...
    Input in;
    char winMsg[22];
    TTF_Font *font = TTF_OpenFont("fonts/angelina.ttf", CELL_LENGTH * 0.8),
             *msgFont = TTF_OpenFont("fonts/angelina.ttf", CELL_LENGTH / 2);
    SDL_Color white = {255,255,255}, black = {0,0,0};
    SDL_Surface *X = TTF_RenderText_Shaded(font, "X", black, white),
                *O = TTF_RenderText_Shaded(font, "O", black, white),
                *cell = SDL_CreateRGBSurface(SDL_HWSURFACE, CELL_LENGTH, CELL_LENGTH, 32, 0, 0, 0, 0),
                *winnerRender = 0;
    SDL_Rect currentCell;

    // On prepare le plateau, on blittera les lettres par dessus du blanc et on peut pas supprimer notre coup...
    fill(screen, black);
    fill(cell, white);
    for(i = 0; i < 9; i++)
        blit(cell, screen, ((i % 3) * CELL_LENGTH + CELL_SPACE * (i % 3 + 1)), ((i / 3) * CELL_LENGTH + CELL_SPACE * (i / 3 + 1)));
    memset(&in, 0, sizeof(in));
    while(!in.key[SDLK_ESCAPE] && !gameOver){
        UpdateEvent(&in);
        if(in.key[SDL_BUTTON_LEFT]){
            // On récup la cellulue
            currentCell = getCell(in.mouseX, in.mouseY);
            if(isEmpty(currentCell, cells)){
                // Elle est vide, on change le plateau et on blitte
                fillCell(currentCell, cells, PLAYER1);
                blit(X, screen, ((((currentCell.x) * CELL_LENGTH + CELL_SPACE * (currentCell.x + 1)) + CELL_LENGTH / 2) - X->w / 2), ((((currentCell.y) * CELL_LENGTH + CELL_SPACE * (currentCell.y + 1)) + CELL_LENGTH / 2) - X->h / 2)); // Oui, le joueur sera X na !
                SDL_Flip(screen);
                // Il a gagné ?
                if(hasWin(PLAYER1, cells)){
                    gameOver = 1;
                    winner = PLAYER1;
                } else {
                    // Au tour de l'ordi
                    // Deja, on fait patienter le gentil joueur pour
                    // faire croire que le PC réfléchit
                    SDL_Delay(500);

                    // On vide les id des cellules vides pour éviter
                    // de se retrouver avec un O sur un X
                    memset(emptyCells, 0, sizeof(int));
                    if(getEmptyCells(cells, emptyCells)){
                        // Et on joue son tour
                        currentCell = getRandomCell(emptyCells, &cellsLeft);
                        fillCell(currentCell, cells, PLAYER2);
                        blit(O, screen, ((((currentCell.x) * CELL_LENGTH + CELL_SPACE * (currentCell.x + 1)) + CELL_LENGTH / 2) - O->w / 2), ((((currentCell.y) * CELL_LENGTH + CELL_SPACE * (currentCell.y + 1)) + CELL_LENGTH / 2) - O->h / 2));
                        // Le joueur a perdu ?
                        if(hasWin(PLAYER2, cells)){
                            gameOver = 1;
                            winner = PLAYER2;
                        }
                    } else {
                        // S'il n'y a plus de cellules vides, c'est qu'il y a match nul
                        gameOver = 1;
                    }
                }
            }
        }
        if(in.quit){ // Si on clique sur la croix, on ferme l'application complète
            gameOver = quitGame = 1;
        }
        if(in.key[SDLK_ESCAPE]) // Et pour Echappe, on revient au menu principale
            gameOver = 1;
        SDL_Flip(screen);
    }
    if(!quitGame){
        SDL_Delay(500);
        // On a un vainqueur ?
        if(winner != 0)
            sprintf(winMsg, "Player %d win !!", winner);
        else
            sprintf(winMsg, "Draw !!");
        winnerRender = TTF_RenderText_Shaded(msgFont, winMsg, white, black);
        fill(screen, black);
        blit(winnerRender, screen, screen->w / 2 - winnerRender->w / 2, screen->h / 2 - winnerRender->h / 2);
        // On lui laisse tout le temps qu'il veut pour lire
        // D'ailleurs, on pourrait très bien utiliser SDL_GetTicks pour laisser un temps maximum, a voir...
        while(!in.key[SDLK_ESCAPE] && !in.key[SDLK_RETURN]){
            UpdateEvent(&in);
            SDL_Flip(screen);
        }
    }

    // Et on libère tout, comme d'hab, sans rien oublier XD
    SDL_FreeSurface(X);
    SDL_FreeSurface(O);
    SDL_FreeSurface(cell);
    SDL_FreeSurface(winnerRender);
    TTF_CloseFont(font);
    TTF_CloseFont(msgFont);
    return quitGame;
}

// Récupère les coordonnées de la cellule cliquée
SDL_Rect getCell(int x, int y){
    SDL_Rect cell;
    cell.x = cell.y = 4;
    // Si on retourne x ou y a 4 c'est qu'il est entre 2 cases...
    int i = 0;
    // Cherchons d'abord x (la colonne)
    for(i = 0; i < 3; i++){
        if(((i % 3) * CELL_LENGTH + CELL_SPACE * (i % 3 + 1)) < x && (((i % 3) * CELL_LENGTH + CELL_SPACE * (i % 3 + 1)) + CELL_LENGTH) > x){
            cell.x = i;
            break;
        }
    }
    for(i = 0; i < 3; i++){
        if((i * CELL_LENGTH + CELL_SPACE * (i + 1)) < y && ((i * CELL_LENGTH + CELL_SPACE * (i + 1)) + CELL_LENGTH) > y){
            cell.y = i;
            break;
        }
    }
    return cell;
}

// Verifie qu'une case est vide (= 0)
int isEmpty(SDL_Rect cell, int cells[][3]){
    return (cells[cell.y][cell.x] == VIDE);
}

// Remplit une cellule par la valeur donnée au joueur "id"
void fillCell(SDL_Rect cell, int cells[][3], int id){
    cells[cell.y][cell.x] = id;
}

// Retourne toutes les cellules vide (pour le tour de l'ordi)
int getEmptyCells(int cells[][3], int empty[8]){
    int i = 0, j = 0;
    for(i = 0; i < 9; i++)
        if(cells[i/3][i%3] == VIDE)
            empty[j++] = i;
    // Bah oui, s'il y en a plus, ça sert à rien de continuer !
    return j != 0;
}

// Retourne une cellule vide aléatoirement (pour l'ordi uniquement)
SDL_Rect getRandomCell(int empty[8], int *left){
    // Avant tout, on supprime le tour du joueur...
    --*left;
    
    // On récupère une cellule aléatoire
    int id = (rand() % *left);
    SDL_Rect cell;
    cell.x = empty[id] % 3;
    cell.y = empty[id] / 3;
    // Et maintenant, celui de l'ordi 
    --*left;
    // Et on la retourne
    return cell;
}

// Est ce que p a gagné ?
int hasWin(int p, int cells[][3]){
    return
        // Lignes horizontales
        (cells[0][0] == p && cells[0][1] == p && cells[0][2] == p)
            ||
        (cells[1][0] == p && cells[1][1] == p && cells[1][2] == p)
            ||
        (cells[2][0] == p && cells[2][1] == p && cells[2][2] == p)
            ||
        // Lignes verticales
        (cells[0][0] == p && cells[1][0] == p && cells[2][0] == p)
            ||
        (cells[0][1] == p && cells[1][1] == p && cells[2][1] == p)
            ||
        (cells[0][2] == p && cells[1][2] == p && cells[2][2] == p)
            ||
        // Et les diagonales
        (cells[1][1] == p  && ((cells[0][0] == p && cells[2][2] == p) || (cells[0][2] == p && cells[2][0] == p)));
}

SDL.h

#ifndef MySDL_H
#define MySDL_H


typedef struct {
    char key[SDLK_LAST];
    int mouseX, mouseY, quit;
} Input;

// Mets les évènnements à jour
void UpdateEvent(Input*);

// Initialise SDL / TTF
int Init();

// Ferme SDL / TTF
void Quit();

// Fonction de blittage
int blit(SDL_Surface*, SDL_Surface*, int, int);

// Remplit une surface
int fill(SDL_Surface*, SDL_Color);


#endif

SDL.c

#include "include.h"

// Mets les évènnement à jour
void UpdateEvent(Input *in){
    SDL_Event event;
    SDL_WaitEvent(&event);
    switch(event.type){
        case SDL_KEYDOWN:
            in->key[event.key.keysym.sym] = 1;
            break;
        case SDL_KEYUP:
            in->key[event.key.keysym.sym] = 0;
            break;
        case SDL_MOUSEBUTTONDOWN:
            in->key[event.button.button] = 1;
            break;
        case SDL_MOUSEBUTTONUP:
            in->key[event.button.button] = 0;
            break;
        case SDL_MOUSEMOTION:
            in->mouseX = event.motion.x;
            in->mouseY = event.motion.y;
            break;
        case SDL_QUIT:
            in->quit = 1;
            break;
    }
}

// Initialise SDL / TTF
int Init(){
    if(SDL_Init(SDL_INIT_VIDEO) == -1)
        return EXIT_FAILURE;
    if(TTF_Init() == -1)
        return EXIT_FAILURE;
    srand(time(NULL));
    return EXIT_SUCCESS;
}

// Ferme SDL / TTF
void Quit(){
    SDL_Quit();
    TTF_Quit();
}

// Blitte une surface
int blit(SDL_Surface *src, SDL_Surface *dest, int x, int y){
    SDL_Rect p;
    p.x = x;
    p.y = y;
    return SDL_BlitSurface(src, 0, dest, &p);
}

// Remplit une surface
int fill(SDL_Surface* src, SDL_Color color){
    return SDL_FillRect(src, 0, SDL_MapRGB(src->format, color.r, color.g, color.b));
}

C159

22 janvier 2011 à 22:03:14

@zenko l 46 de SDL.c ?

22 janvier 2011 à 22:40:28

Content de voir que des membres de la trempe de Joe78, suivent ce topic, et commentent!

Si on veut commenter un code sérieusement, ça prend vraiment du temps.
Pouet fait ça très bien, mais si les membres plus avancés, ont la la patience de commenter, c'est super!

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

22 janvier 2011 à 22:54:18

Re,

Correction des fautes qui m'ont été signalées :

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <time.h>
#include <SDL/SDL.h>

#define MAX 2
#define MIN 1
#define TAILLETAB 3
#define T_CASE 160

void affichage(char** tableau, SDL_Surface *ecran, SDL_Surface *c_vide, SDL_Surface *c_j1, SDL_Surface *c_j2);
int saisie(int joueur);
int testerCoup(int coord, char** tableau); // Si le coup est bon, il renvoie 1
void jouerCoup(char** tableau, int coord, int joueur);
void gagner(char** tableau, int* gagne, int joueur); //teste si un joueur a gagné, mais aussi si le tabealu est plein.
void rejouer(int* jouer);

int main(void)
{	
	int i = 0;

	srand(time(NULL));

	/*SDL*/
	if (SDL_Init(SDL_INIT_VIDEO) == -1)
		exit(EXIT_FAILURE);

	SDL_Surface *ecran = NULL;
	SDL_Surface *c_vide = NULL;
	SDL_Surface *c_j1 = NULL;
	SDL_Surface *c_j2 = NULL;
	
	ecran = SDL_SetVideoMode(T_CASE*TAILLETAB+20, T_CASE*TAILLETAB+20, 32, SDL_SWSURFACE);
	if (ecran == NULL)
		exit(EXIT_FAILURE);

	c_vide = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	c_j1 = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	c_j2 = SDL_CreateRGBSurface(SDL_SWSURFACE, T_CASE, T_CASE, 32, 0, 0, 0, 0);
	if (c_vide == NULL || c_j1 == NULL || c_j2 == NULL)
		exit(EXIT_FAILURE);
	
	SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
	SDL_FillRect(c_vide, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
	SDL_FillRect(c_j1, NULL, SDL_MapRGB(ecran->format, 255, 161, 0));
	SDL_FillRect(c_j2, NULL, SDL_MapRGB(ecran->format, 0, 71, 255));
	
	/*Tableau du morpion*/
	char** tableau = NULL;
	tableau = malloc(TAILLETAB * sizeof(char *));
	if (tableau == NULL)
		exit(EXIT_FAILURE);
		
	for (i = 0; i < TAILLETAB; i++)
	{
		tableau[i] = malloc(TAILLETAB * sizeof(char));
		if (tableau[i] == NULL)
			exit(EXIT_FAILURE);
	}

	int jouer = 1;
	
	/*boucle de jeu*/
	while (jouer == 1)
	{
		int coord = 0;
		int i = 0;
		int j = 0;
		int gagne = 0;
		int joueur = 1; //1 : joueur 1, 2 : joueur 2

		//Initialisation 
		for (i = 0 ; i < TAILLETAB; i++)
		{
			for (j = 0; j < TAILLETAB; j++)
				tableau[i][j] = '.';
		}

		//Tirage au sort
		joueur = (rand() % (MAX - MIN + 1)) + MIN;
		
		while (!gagne)
		{
			//Affichage du morpion
			affichage (tableau, ecran, c_vide, c_j1, c_j2);

			//Saisie des coordonnées et tester si le coup est permis
			do
				coord = saisie(joueur);
			while(testerCoup(coord, tableau) == 0);

			//On inscrit le coup dans le tableau
			jouerCoup(tableau, coord, joueur);

			//On change de joueur
			if (joueur == 1)
				joueur++;
			else if (joueur == 2)
				joueur--;
			
			//Un joueur a gagné ?	
			gagner(tableau, &gagne, joueur);
			
			if (gagne == 1)
				affichage (tableau, ecran, c_vide, c_j1, c_j2);

		}

		/*Rejouer ?*/
		rejouer(&jouer);
	}
	
	SDL_FreeSurface(c_vide);
	SDL_FreeSurface(c_j1);
	SDL_FreeSurface(c_j2);
	SDL_Quit();
	
	free(tableau);
	
	return EXIT_SUCCESS;
}

void affichage(char** tableau, SDL_Surface *ecran, SDL_Surface *c_vide, SDL_Surface *c_j1, SDL_Surface *c_j2)
{
	int i = 0;
	int j = 0;
		
	/*Blit*/

	SDL_Rect position;

	position.x = 0;
	position.y = 0;

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == '.')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;

				SDL_BlitSurface(c_vide, NULL, ecran, &position);
			}
			else if (tableau[i][j] == 'X')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;
				
				SDL_BlitSurface(c_j1, NULL, ecran, &position);
			}
			else if (tableau[i][j] == 'O')
			{
				position.x = j*T_CASE+j*5+5;
				position.y = i*T_CASE+i*5+5;

				SDL_BlitSurface(c_j2, NULL, ecran, &position);
			}
		}
	}
	SDL_Flip(ecran);
}

int saisie(int joueur)
{
	int x = 0, y = 0, continuer = 1;

	SDL_Event event;
	
	if (joueur == 1)
		SDL_WM_SetCaption("Joueur 1, à vous de jouer...", NULL);
	else if (joueur == 2)
		SDL_WM_SetCaption("Joueur 2, à vous de jouer...", NULL);
	
	while (continuer)
	{
		SDL_WaitEvent(&event);
		switch(event.type)
		{
			case SDL_MOUSEBUTTONUP:
				x = event.button.x/(T_CASE+20);
				y = event.button.y/(T_CASE+20);
				continuer = 0;
				break;
			case SDL_QUIT:
				continuer = 0;
				break;
		}
	}

	return x+(y*TAILLETAB);
}

void gagner(char** tableau, int* gagne, int joueur)
{
	int count_1 = 0;
	int count_2 = 0;
	int i = 0;
	int j = 0;
	int casesPl = 0;

	//Tests sur l'abscisse

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == 'X')
				count_1++;
			else if (tableau[i][j] == 'O')
				count_2++;

			if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			{	
				i = TAILLETAB;
				j = TAILLETAB;
				
				if (count_1 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
				else if (count_2 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

				*gagne = 1;
			}
		}
		count_1 = 0;
		count_2 = 0;		
	}
	
	count_1 = 0;
	count_2 = 0;

	//Tests sur l'ordonnée

	for (j = 0; j < TAILLETAB; j++)
	{
		for (i = 0; i < TAILLETAB; i++)
		{
			if (tableau[i][j] == 'X')
				count_1++;
			else if (tableau[i][j] == 'O')
				count_2++;

			if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			{
				if (count_1 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
				else if (count_2 == TAILLETAB)
					SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

				*gagne = 1;
				break;
			}
		}

		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
			break;
		count_2 = 0;
		count_1 = 0;
	}
	
	count_1 = 0;
	count_2 = 0;

	//Tests sur les diagonales

	for (i = 0; i < TAILLETAB; i++)
	{	
		if (tableau[i][i] == 'X')
			count_1++;
		else if (tableau[i][i] == 'O')
			count_2++;
		
		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
		{
			if (count_1 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
			else if (count_2 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

			*gagne = 1;
			break;
		
		}
	}
	count_2 = 0;
	count_1 = 0;

	for (i = 1; i < TAILLETAB; i++)
	{
		if (tableau[i-1][TAILLETAB-i] == 'X')
			count_1++;
		else if (tableau[i][TAILLETAB-i] == 'O')
			count_2++;
		
		if (count_1 == TAILLETAB || count_2 == TAILLETAB)
		{
			if (count_1 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 1, vous avez gagné ! Rejouer ? (O/N)", NULL);
			else if (count_2 == TAILLETAB)
				SDL_WM_SetCaption("Joueur 2, vous avez gagné ! Rejouer ? (O/N)", NULL);

			*gagne = 1;
			break;

		}
	}

	count_2 = 0;
	count_1 = 0;
	
	//Teste si toutes les cases sont pleines 

	for (i = 0; i < TAILLETAB; i++)
	{
		for (j = 0; j < TAILLETAB; j++)
		{
			if (tableau[i][j] == 'X' || tableau[i][j] == 'O')
				casesPl++;
		}
	}
			
	if (casesPl == (TAILLETAB*TAILLETAB) && *gagne != 0)
	{
		*gagne = 1;
		SDL_WM_SetCaption("Personne n'a gagné ! Rejouer ? (O/N)", NULL);
	}
}


int testerCoup(int coord, char** tableau)
{
	int x = 0, y = 0;

	x = coord%TAILLETAB;
	y = coord/TAILLETAB;

	if (tableau[y][x] == 'X' || tableau[y][x] == 'O')
		return 0;
	else
		return 1;
}

void jouerCoup(char** tableau, int coord, int joueur)
{
	int x = 0, y = 0;
	
	x = coord%TAILLETAB;
	y = coord/TAILLETAB;

	if (joueur == 1)
		tableau[y][x] = 'X';
	
	else if (joueur == 2)
		tableau[y][x] = 'O';
}

void rejouer(int* jouer)
{
	int continuer = 1;
	
	SDL_Event event;

	while (continuer)
	{
		SDL_WaitEvent(&event);

		switch(event.type)
		{
			case SDL_KEYDOWN:
				switch(event.key.keysym.sym)
				{
					case SDLK_o:
						*jouer = 1;
						continuer = 0;
						break;
					case SDLK_n:
						*jouer = 0;
						continuer = 0;
						break;
				}
		}
	}
}

23 janvier 2011 à 2:04:44

@zenko: tu à failli m'avoir j'ai cru que tu avais codé une IA. :lol:

Sinon chapeau pour le rendu, "angelina.ttf" à de la classe.

Sinon... :diable:

Tu ne testes aucun retour des fonctions style

TTF_Font *bigFont = TTF_OpenFont("fonts/angelina.TTF", 130),
*littleFont = TTF_OpenFont("fonts/angelina.TTF", 60),
*tinyFont = TTF_OpenFont("fonts/angelina.TTF", 40);

si il y a un problème, on segfault, sans renseignements.

Je ne pense pas que tu sois obligé de charger la fonte plusieurs fois.
A vérifier, j'utilise très peu SDL_ttf(j'utilise des fontes bmp.)

je n'aime pas cette ligne

int cells[3][3] = {
        {VIDE,VIDE,VIDE},
        {VIDE,VIDE,VIDE},
        {VIDE,VIDE,VIDE}
    }, quitGame = 0, gameOver = 0, winner = 0, i = 0, cellsLeft = 9, emptyCells[8]; // 8 car c'est toujours au joueur de commencer...

plusieurs déclarations sur une ligne c'est pas terrible, je trouve.
Pour ton tableau, tu peux faire, vu que EMPTY == 0.

int cells[3][3] = {{0]};

Je trouve que tu te compliques pour faire jouer l'ordi.
Tu veux tirer une case libre au hasard.
il suffit, de tirer une valeur au hasard entre 0 et le nombre de cases libres.
tu te places sur la case correspondant à la valeur tirée, et tu avances tant que la case est occupée.

Sinon, bravo pour le rendu encore une fois.

edit: ah, et la structure SDL_Color à 4 paramètre, le 4 ème est inutile, mais il faut le renseigner!

@sydzero: rapidement, il est tard :-°

dans tes switch d'events SDL pense au défault, sinon le compilateur te donne une avalanche de warnings.)

switch(event.type)
		{
			case SDL_MOUSEBUTTONUP:
				x = event.button.x/(T_CASE+20);
				y = event.button.y/(T_CASE+20);
				continuer = 0;
				break;
			case SDL_QUIT:
				continuer = 0;
				break;
                        default:
                        break;
		}

tu n'as pas besoin de créer des surfaces, pour chaque rectangle, fait un SDL_FillRect simplement, non?
Je ne suis pas sur que les mallocs soient bien obligatoires. un tableau de 3 x 3 ne suffit pas?
Tu libères mal ton tableau d'ailleurs:
il faut libérer chaque ligne de ton tableau et ensuite le tableau

Je pense que ta fonction gagner fait trop de choses.
Elle devrait juste tester s'il y a un gagnant, et surement pas faire l'affichage.

On ne peut pas quitter ton programme en cliquant sur la croix, c'est voulu?

Merci pour votre participation

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

23 janvier 2011 à 13:59:34

Citation : GurneyH

tu n'as pas besoin de créer des surfaces, pour chaque rectangle, fait un SDL_FillRect simplement, non?

C'est la première fois que je code avec la sdl

, je ne savais pas.

Citation : GurneyH

Je ne suis pas sur que les mallocs soient bien obligatoires. un tableau de 3 x 3 ne suffit pas?

A vrai dire, je fais ça pour m'entraîner un peu sur l'allocation dynamique.

Citation : GurneyH

Je pense que ta fonction gagner fait trop de choses.
Elle devrait juste tester s'il y a un gagnant, et surement pas faire l'affichage.

Mmm... c'est pas trop gênant comme c'est un code relativement court non ?

Citation : GurneyH

On ne peut pas quitter ton programme en cliquant sur la croix, c'est voulu?

Oops, oublié.

24 janvier 2011 à 13:31:27

J'ai une petite question, ne serait-il pas mieux de gérer les fonctions du menu et du jeu indépendemment ?
Par là, je veux dire, lancer la fonction d'affichage du menu, récupérer le résultat (et donc libérer ce qui est nécessaire) puis lancer le jeu (et faire de même). Ainsi, lorsque l'on quitte le jeu, on revient au menu mais toutes les SDL_Surfaces se rechargent...
Si vous ne comprenez pas, dites le, j'envoie mon nouveau code dès qu'il est fini

24 janvier 2011 à 17:23:44

Citation : zenko

J'ai une petite question, ne serait-il pas mieux de gérer les fonctions du menu et du jeu indépendemment ?

Tu pense à ce qui est fait dans le cours du site pour Mario Sokoban?

Si ton jeu utilise beaucoup de ressources, c'est probablement mieux de séparer les parties, oui.
Personnellement, j'utilise un système avec une seule boucle principale, mais des pointeurs de fonctions vers les différentes parties.
du style

while(!done)
{
    updateEvents();
    currentController->update();

    currentController->display();
    SDL_Delay(...);
    SDL_Flip(screen);
}

A chaque changement de partie, je libère les ressources change de controller, et passe au controller suivant.

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

24 janvier 2011 à 20:59:35

Je pense que l'on s'est compris oui

Je poste mon code tout à l'heure, il fonctionne à l'exception d'une erreur glibc -> free : invalid pointer. Je pense que c'est dû à un problème de libération de variable alloués dynamiquement. J'essaie de trouver l'erreur et je donne tout, j'ai, je pense, réussit à séparer correctement la SDL de la logique mais bon, vous me direz

EDIT : A y est, trouvé !

(Erreur d'allocation)

Et mon code, comme promis :

include.h

#ifndef INCLUDE_H
#define INCLUDE_H

// Valeur pouvant être modifiée
#define CELL_X 5
#define CELL_Y 5
#define WIN 4
#define CELL_LENGTH 120
#define CELL_SPACE 2

// Stop, on touche plus 
#define SCREEN_WIDTH CELL_LENGTH * CELL_X + CELL_SPACE * (CELL_X + 1)
#define SCREEN_HEIGHT CELL_LENGTH * CELL_Y + CELL_SPACE * (CELL_Y + 1)

#include <time.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>

enum {EMPTY, P1, P2};
enum {LITTLE, MEDIUM, BIG, GAME} fontSize;

// Pour les surfaces
enum {zMorp, by, msg} surfaceMenu;
enum {X, O, WINNER} surfaceGame;

typedef struct Coord {
    int x, y;
} Coord;

typedef struct {
    char key[SDLK_LAST];
    int mouseX, mouseY, quit;
} Input;

typedef struct Context {
    SDL_Surface *screen;    // L'écran
    TTF_Font **fonts;       // Les fonts
    Input in;               // Les évènnements
    SDL_Color black, white; // Couleurs utilisées...
    // Les surface, on gère nbS pour réinitialiser
    // les surfaces à chaque changement de fonction
    SDL_Surface **surfaces;
    int nbS;
} Context;

#include "SDL.h"
#include "game.h"

#endif

main.c

#include "include.h"

int main(int argc, char *argv[]){
    if(!InitSDL())
        return EXIT_FAILURE;
    if(!initGame())
        return EXIT_FAILURE;
    QuitSDL();
    return EXIT_SUCCESS;
}

SDL.h

#ifndef __SDL_H
#define __SDL_H

// Initialisation
int InitSDL();

// Ferme la SDL
void QuitSDL();

// Initialise le contexte
void initContext(Context*);

// Mets les évènnement à jour
void updateEvents(Input*);

// Blitte une surface
int blit(SDL_Surface*,SDL_Surface*,int,int);

// Remplit une surface
int fill(SDL_Surface*,SDL_Color);

// Crée une surface
SDL_Surface *createSurface(int,int);

// Charge une font
TTF_Font *openFont(char*, unsigned int);

// Charge un rendu de texte sur une surface (shaded)
void RenderText(Context*,int,int,char*,SDL_Color,SDL_Color);

// Initialise le context graphique
void initContext(Context*);

// Prepare le plateau du jeu
void prepareGame(Context*);

//Affiche une cellule
void displayCell(Context*,int,Coord);

//Initialise les surfaces du menu
void initSurfaceMenu(Context*);

// Initialise les surfaces du jeu
void initSurfaceGame(Context*);

// Libère les surfaces
void freeSurface(Context*);

// Libère tout le contexte
void freeContext(Context*);

// Affiche les surfaces
void flip(SDL_Surface*);
#endif

SDL.c

#include "include.h"

// Initialisation
int InitSDL(){
    if(SDL_Init(SDL_INIT_VIDEO) == -1)
        return 0;
    if(TTF_Init() == -1)
        return 0;
    srand(time(NULL));
    return 1;
}

// Ferme la SDL
void QuitSDL(){
    SDL_Quit();
    TTF_Quit();
}

// Mets les évènnement à jour
void updateEvents(Input *in){
    SDL_Event event;
    SDL_WaitEvent(&event);
    switch(event.type){
        case SDL_KEYDOWN:
            in->key[event.key.keysym.sym] = 1;
            break;
        case SDL_KEYUP:
            in->key[event.key.keysym.sym] = 0;
            break;
        case SDL_MOUSEBUTTONDOWN:
            in->key[event.button.button] = 1;
            break;
        case SDL_MOUSEBUTTONUP:
            in->key[event.button.button] = 0;
            break;
        case SDL_MOUSEMOTION:
            in->mouseX = event.motion.x;
            in->mouseY = event.motion.y;
            break;
        case SDL_QUIT:
            in->quit = 1;
            break;
    }
}

// Blitte une surface
int blit(SDL_Surface *src, SDL_Surface *dest, int x, int y){
    SDL_Rect p;
    p.x = x;
    p.y = y;
    p.w = p.h = 0;
    return SDL_BlitSurface(src, 0, dest, &p);
}

// Remplit une surface
int fill(SDL_Surface* src, SDL_Color color){
    return SDL_FillRect(src, 0, SDL_MapRGB(src->format, color.r, color.g, color.b));
}

// Crée une surface
SDL_Surface *createSurface(int w, int h){
    return SDL_CreateRGBSurface(SDL_HWSURFACE, w, h, 32, 0, 0, 0, 0);
}

// Charge une font
TTF_Font *openFont(char *name, unsigned int size){
    TTF_Font *f = TTF_OpenFont(name, size);
    if(!f){
        fprintf(stderr, "TTF : %s\n", TTF_GetError());
        exit(-1);
    }
    return f;
}

// Initialise le context graphique
void initContext(Context* C){
    C->screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("zMorp",0);
    memset(&C->in, 0, sizeof(C->in));
    C->fonts = malloc(sizeof(fontSize) * sizeof(TTF_Font*));
    C->fonts[LITTLE] = openFont("fonts/angelina.ttf", (int)(CELL_LENGTH * 0.25));
    C->fonts[MEDIUM] = openFont("fonts/angelina.ttf", (int)(CELL_LENGTH * 0.6));
    C->fonts[BIG] = openFont("fonts/angelina.ttf", (int)(CELL_LENGTH * 1.1));
    C->fonts[GAME] = openFont("fonts/angelina.ttf", (int)(CELL_LENGTH * 0.75));
    C->white.r = C->white.g = C->white.b = 255;
    C->black.r = C->black.g = C->black.b = C->black.unused = C->white.unused = 0;
    C->nbS = 0;
}

// Prépare le plateau du jeu
void prepareGame(Context *C){
    SDL_Surface *cell = createSurface(CELL_LENGTH, CELL_LENGTH);
    int i;
    fill(C->screen, C->black);
    fill(cell, C->white);
    for(i = 0; i < CELL_X * CELL_Y; i++)
        blit(cell, C->screen, (CELL_SPACE * (i % CELL_X + 1) + CELL_LENGTH * (i % CELL_X)), (CELL_SPACE * (i / CELL_Y + 1) + CELL_LENGTH * (i / CELL_Y)));
    initSurfaceGame(C);
    flip(C->screen);
}

// Affiche une cellule
void displayCell(Context *C, int i, Coord c){
    blit(C->surfaces[i], C->screen, ((CELL_SPACE * (c.x + 1) + CELL_LENGTH * c.x) + CELL_LENGTH / 2) - C->surfaces[i]->w / 2, ((CELL_SPACE * (c.y + 1) + CELL_LENGTH * c.y) + CELL_LENGTH / 2) - C->surfaces[i]->h / 2);
    flip(C->screen);
}

//Initialise les surfaces du menu
void initSurfaceMenu(Context *C){
    // Pour être sûr de pas faire de boulettes, on libère les surfaces allouées
    freeSurface(C);
    C->nbS = sizeof(surfaceMenu);
    if(C->nbS == 0){
        fprintf(stderr, "L'allocation des surfaces du menu a échouée.");
        exit(-1);
    }
    C->surfaces = malloc(C->nbS * sizeof(SDL_Surface*));
    RenderText(C, zMorp, BIG, "zMorp", C->white, C->black);
    RenderText(C, by, MEDIUM, "by Zenko", C->white, C->black);
    RenderText(C, msg, LITTLE, "Press \"Enter\" to play", C->white, C->black);
}

// Initialise les surface du jeu
void initSurfaceGame(Context *C){
    // De même, on est jamais trop prudent
    freeSurface(C);
    C->nbS = sizeof(surfaceGame);
    if(C->nbS == 0){
        fprintf(stderr, "L'allocation des surfaces du jeu a échouée.");
        exit(-1);
    }
    C->surfaces = malloc(C->nbS * sizeof(SDL_Surface*));
    RenderText(C, X, GAME, "X", C->black, C->white);
    RenderText(C, O, GAME, "O", C->black, C->white);
    C->surfaces[WINNER] = 0;
}

// Charge un rendu de texte sur une surface (shaded)
void RenderText(Context *C, int surf, int size, char *msg, SDL_Color color, SDL_Color bgc){
    C->surfaces[surf] = TTF_RenderText_Shaded(C->fonts[size], msg, color, bgc);
}

// Libère les surfaces
void freeSurface(Context *C){
    if(C->nbS > 0){
        int i;
        for(i = 0; i < C->nbS; i++)
            if(C->surfaces[i] != 0)
                SDL_FreeSurface(C->surfaces[i]);
        free(C->surfaces);
        C->nbS = 0;
    }
}

// Libère tout le contexte
void freeContext(Context *C){
    // Les surfaces
    freeSurface(C);
    // Et les fonts
    TTF_CloseFont(C->fonts[LITTLE]);
    TTF_CloseFont(C->fonts[MEDIUM]);
    TTF_CloseFont(C->fonts[BIG]);
    free(C->fonts);
}

// Affiche les surfaces
void flip(SDL_Surface *s){
    SDL_Flip(s);
}

game.h

#ifndef GAME_H
#define GAME_H

// Initialise ce qui a besoin d'être initialisé pour tout le jeu...
int initGame();

// Fonction du menu principal
int setMenu(Context*);

// Fonction du jeu
int play(Context*);

// Récupère les coordonnées de la cellule cliquée
Coord getCell(int,int);

// Indique si une case est vide
int isEmpty(Coord,int[]);

// Remplit une cellule par la valeur attribué au joueur
void fillCell(Coord,int[],int);

// Indique si le joueur à gagné => Pompé sur pouet_forever 
int hasWin(int[],Coord,int);

// Compte le nombre de cellule appartenant au joueur dans une direction donnée
int countDir(int[],Coord,int,int,int);

// Retourne une cellule vide aléatoire
Coord getRandomCell(int[],int);

#endif

game.c

#include "include.h"

// Initialisation (Gère le jeu)
int initGame(){
    int c = 1;
    Context C;

    // Si la taille du tableau ne permet pas
    // dans un sens de gagner, on quitte...
    if(WIN > CELL_X || WIN > CELL_Y)
        c = 0;

    initContext(&C);
    while(c){
        switch(c){
            case 1:
                c = setMenu(&C);
                break;
            case 2:
                c = play(&C);
                break;
        }
    }
    // On libère le contexte
    freeContext(&C);
    return 1;
}

// Fonction du menu principal
int setMenu(Context *C){
    int c = 0;
    initSurfaceMenu(C);

    // On affiche notre belle page
    fill(C->screen, C->black);
    blit(C->surfaces[zMorp], C->screen, (C->screen->w / 2 - C->surfaces[zMorp]->w / 2), 30);
    blit(C->surfaces[msg], C->screen, (C->screen->w / 2 - C->surfaces[msg]->w / 2), (C->screen->h / 2 - C->surfaces[msg]->h / 2));
    blit(C->surfaces[by], C->screen, (C->screen->w - C->surfaces[by]->w - 10), (C->screen->h - C->surfaces[by]->h - 20));
    flip(C->screen);
    // Réinitialisation des touches
    C->in.quit = C->in.key[SDLK_ESCAPE] = C->in.key[SDLK_RETURN] = 0;
    while(!C->in.key[SDLK_ESCAPE] && !C->in.key[SDLK_RETURN] && !C->in.quit){
        updateEvents(&C->in);
        c = !C->in.quit && !C->in.key[SDLK_ESCAPE];
        if(C->in.key[SDLK_RETURN]){
            c = 2;
        }
    }
    // Libération des surfaces
    freeSurface(C);
    return c;
}

// Fonction du jeu
int play(Context *C){
    int board[CELL_X * CELL_Y] = {EMPTY},
        play = 1,
        winner = 0,
        turn = CELL_X * CELL_Y;
    char winMsg[20];
    Coord currentCell;

    prepareGame(C);
    // Tant qu'on veut jouer et qu'il n'y a pas de vainqueur
    while(play && !winner && turn){
        updateEvents(&C->in);
        if(C->in.quit)
            play = 0;
        if(C->in.key[SDLK_ESCAPE]){
            // On déclare un forfait...
            winner = P2;
        }
        // S'il clique
        if(C->in.key[SDL_BUTTON_LEFT]){
            C->in.key[SDL_BUTTON_LEFT] = 0;
            // Si la cellule est vide (Et s'il est sur une cellule déjà...)
            if(isEmpty((currentCell = getCell(C->in.mouseX, C->in.mouseY)), board)){
                // Il a joué, donc, un tour en moins
                turn--;
                fillCell(currentCell, board, P1);
                displayCell(C, X, currentCell);
                // Il a gagné ?
                if(hasWin(board, currentCell, P1))
                    winner = P1;
                else
                    if(turn){
                        // Au tour de l'ordi
                        // Deja, on fait patienter le gentil joueur pour
                        // faire croire que le PC réfléchit
                        SDL_Delay(500);
                        // Et on fait de même
                        fillCell((currentCell = getRandomCell(board, turn--)), board, P2);
                        displayCell(C, O, currentCell);
                        if(hasWin(board, currentCell, P2))
                            winner = P2;
                    }
            }
        }
    }
    // S'il a pas cliqué sur la croix
    if(play){
        // On affiche le message
        SDL_Delay(800);
        if(winner)
            sprintf(winMsg, "Player %d wins !!", winner);
        else
            sprintf(winMsg, "Draw !!");
        fill(C->screen, C->black);
        RenderText(C, WINNER, MEDIUM, winMsg, C->white, C->black);
        blit(C->surfaces[WINNER], C->screen, C->screen->w / 2 - C->surfaces[WINNER]->w / 2, C->screen->h / 2 - C->surfaces[WINNER]->h / 2);
        flip(C->screen);
        // On attend une action
        while(!C->in.key[SDLK_ESCAPE] && !C->in.key[SDLK_RETURN] && !C->in.quit){
            updateEvents(&C->in);
        }
        play = !C->in.quit;
    }
    // Libération des surfaces
    freeSurface(C);
    return play;
}

// Récupère les coordonnées de la cellule cliquée
Coord getCell(int x, int y){
    int i;
    Coord c;
    c.x = c.y = CELL_X * CELL_Y; // On donne par defaut un chiffre impossible a atteindre...
    for(i = 0; i < CELL_X; i++)
        if(x > CELL_SPACE * (i % CELL_X + 1) + CELL_LENGTH * (i % CELL_X) && x < CELL_SPACE * (i % CELL_X + 1) + CELL_LENGTH * (i % CELL_X) + CELL_LENGTH){
            c.x = i;
            break;
        }
    for(i = 0; i < CELL_X; i++)
        if((i * CELL_LENGTH + CELL_SPACE * (i + 1)) < y && ((i * CELL_LENGTH + CELL_SPACE * (i + 1)) + CELL_LENGTH) > y){
            c.y = i;
            break;
        }
    return c;
}

// Indique si une case est vide
int isEmpty(Coord c, int board[]){
    return board[c.x + c.y * CELL_X] == EMPTY && c.x < CELL_X && c.y < CELL_Y;
}

// Remplit une cellule
void fillCell(Coord c, int board[], int p){
    board[c.x + c.y * CELL_X] = p;
}

// Vérifie si un joueur p à gagné => Pompé sur pouet_forever je l'avoue 
int hasWin(int b[], Coord c, int p){
    int i, count;
    Coord dir[4] = {
        {1,0}, // Horizontale
        {0,1}, // Verticale
        {1,1}, // Diagonale
        {1,-1} // Autre diagonale
    };
    for(i = 0; i < 4; i++){
        count = countDir(b, c, dir[i].x, dir[i].y, p);
        count += countDir(b, c, -dir[i].x, -dir[i].y, p);
        if(count + 1 == WIN)
            return 1;
    }
    return 0;
}

// Compte le nombre de cellule appartenant au joueur dans une direction donnée depuis une cellule X
int countDir(int b[], Coord c, int xDir, int yDir, int p){
    int i, j, counter = 0;
    for(i = c.x + xDir, j = c.y + yDir;(unsigned) i < CELL_X && (unsigned) j < CELL_Y && b[i + j * CELL_X] == p; i += xDir, j += yDir)
        counter++;
    return counter;
}

// Retourne une cellule vide aléatoire
Coord getRandomCell(int board[], int nb){
    int *emptyCells = malloc(nb * sizeof(int)),
        i, j = 0;
    Coord c;
    // On récupère les cellules vides
    for(i = 0; i < CELL_X * CELL_Y && j < nb; i++)
        if(board[i] == EMPTY)
            emptyCells[j++] = i;
    // Et on en choisi une au "hasard"
    i = (rand() % nb);
    c.x = emptyCells[i] % CELL_X;
    c.y = emptyCells[i] / CELL_Y;
    free(emptyCells);
    return c;
}

Alors, qu'en dites-vous ?
@GurneyH : C'est bein ce à quoi je faisais hallusion, l'histoire du menu et du jeu géré indéepndemment ?

25 janvier 2011 à 3:58:04

@Zenko:

J'ai juste regardé le code mais pas testé(c'est un peu lourd plusieurs fichiers, pour tester).

Ca me semble plutôt bien, juste attention, tu ne testes pas les retour de malloc.
Sinon, la structure context, et les tableaux de surfaces, et TTF_FONT, c'est bien.

Dès que j'ai le temps(et le courage:-° ), je teste, et je regarde plus attentivement.

Mais je trouve ton code bien mieux que le premier.

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

25 janvier 2011 à 8:37:35

Citation : GurneyH

Mais je trouve ton code bien mieux que le premier.

Merci beaucoup

Citation : GurneyH

Ca me semble plutôt bien, juste attention, tu ne testes pas les retour de malloc.

J'ai mis l'action du test mais pas sur la bonne variable :-°

:
J'ai mis :

C->nbS = sizeof(surfaceMenu);
if(C->nbS == 0){
    fprintf(stderr, "L'allocation des surfaces du menu a échouée.");
    exit(-1);
}
C->surfaces = malloc(C->nbS * sizeof(SDL_Surface*));

au lieu de

C->nbS = sizeof(surfaceMenu);
C->surfaces = malloc(C->nbS * sizeof(SDL_Surface*));
if(C->surfaces == 0){
    fprintf(stderr, "L'allocation des surfaces du menu a échouée.");
    exit(-1);
}

Tu veux que je mette tous sur un seul fichier ? ou que j'up le projet Code::Block ?

25 janvier 2011 à 12:06:13

Citation : zenko

ou que j'up le projet Code::Block ?

Bonne idée.
Lorsque qu'il y a plusieurs fichiers, je pense que c'est le plus simple.

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

25 janvier 2011 à 15:01:04

zMorp sur MegaUpload

Les liens sont dynamique

Pouet_forever

25 janvier 2011 à 18:11:42

Tu n'as pas de lien direct, tu es obligé d'attendre.

J'ai amélioré mon morpion, si jamais on veut jouer tout seul... :-°

Un bête alpha/beta sans fonction d'évaluation et sans optimisation, on explore l'arbre jusqu'aux feuilles. Ca implique qu'il ne faut pas, ou peu augmenter la taille de la grille (ou avoir un supercalculateur :lol:

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "SDL.h"

enum {
  TAB_H = 3,                /* Hauteur  */
  TAB_W = TAB_H,            /* Largeur  */
  TAB_T = TAB_H * TAB_W,    /* Nbre total de cases      */
  NBR_P = 3,                /* Nbre de pions à aligner  */
  NBR_M = NBR_P + NBR_P - 1 /* Nbre min de pions pour tester la grille */
};

enum {
  SCR_CEL = 80,
  SCR_H   = TAB_H * SCR_CEL,
  SCR_W   = TAB_W * SCR_CEL,
  PCT_B   = 2               /* Pourcentage de SCR_CEL pour la bordure */
};

enum {
  IA_DIFF = TAB_T,
  IA_MAX  = 10000,
  IA_MID  = 0,
  IA_MIN  = -IA_MAX,
  INF     = IA_MAX * 2
};

enum {
  VIDE  = 0,
  J1    = 1,
  J2    = 2,
  JIA   = J1    /* Modifier cette variable pour le joueur IA */
};

typedef struct Coord_ {
  int x;
  int y;
} Coord;

/* >>>>> Variable globale <<<<< */
/* Variable qui sert de fond à chaque blit de surface */
static SDL_Surface * bckgrnd;


int testerGrille(int * tab, Coord * c, int joueur);
int jouerCoup(int * tab, Coord * c, int joueur);
int delCoup(int * tab, Coord * c);
int estCoupValide(int * tab, Coord * c);

void attendreClic(void) {
  SDL_Event e;
  int done = 0;
  
  while (!done) {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      exit(EXIT_SUCCESS);
    if (e.type == SDL_MOUSEBUTTONDOWN)
      done = 1;
  }
}

int alphaBeta(int * tab, Coord * c, int joueur, int pce, int prof,
              int alpha, int beta) {
  Coord ij;
  
  if (pce >= TAB_T)
    return IA_MID;
  
  for (ij.y = 0; ij.y < TAB_H; ij.y++) {
    for (ij.x = 0; ij.x < TAB_W; ij.x++) {
      if (estCoupValide(tab, &ij)) {
        int tmp;
        
        jouerCoup(tab, &ij, joueur);
        
        if (testerGrille(tab, &ij, joueur))
          tmp = (IA_MAX - (pce + 1));
        else
          tmp = -alphaBeta(tab, c, 3 - joueur, pce + 1, prof - 1,
                              -beta, -alpha);
        delCoup(tab, &ij);
        
        if (tmp >= beta) {
          if (prof == IA_DIFF)
            *c = ij;
          return beta;
        }
        if (tmp > alpha) {
          if (prof == IA_DIFF)
            *c = ij;
          alpha = tmp;
        }
      }
    }
  }
  
  return alpha;
}

int saisieIA(int * tab, Coord * c, int joueur, int pce) {
  alphaBeta(tab, c, joueur, pce, IA_DIFF, -INF, INF);
  return 0;
}

int saisieCoord(int * tab, Coord * c, int joueur, int pce) {
  SDL_Event e;
  int done = 0;
  
  while (!done) {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      exit(EXIT_SUCCESS);
    if (e.type == SDL_MOUSEBUTTONDOWN) {
      c->x = e.motion.x / SCR_CEL;
      c->y = e.motion.y / SCR_CEL;
      done = estCoupValide(tab, c);
    }
  }
  return 0;
}

int jouerCoup(int * tab, Coord * c, int joueur) {
  tab[c->y * TAB_W + c->x] = joueur;
  return 0;
}

int delCoup(int * tab, Coord * c) {
  tab[c->y * TAB_W + c->x] = VIDE;
  return 0;
}

int estCoupValide(int * tab, Coord * c) {
  if ((unsigned) c->x >= TAB_W || (unsigned) c->y >= TAB_H ||
      tab[c->y * TAB_W + c->x] != VIDE)
    return 0;
  else
    return 1;
}

SDL_Surface * creerBckgrnd(void) {
  int i, j, pct;
  SDL_Surface * s = SDL_CreateRGBSurface(SDL_HWSURFACE,
                                         SCR_W, SCR_H, 32, 0, 0, 0, 0);
  SDL_Rect r, t;
  
  if (s == NULL) {
    fprintf(stderr, "%s\n", SDL_GetError());
    exit(EXIT_FAILURE);
  }
  
  SDL_FillRect(s, NULL, ~0U);
  pct = (SCR_CEL * PCT_B) / 100;
  r.h = SCR_CEL;
  r.w = SCR_CEL;
  t.h = SCR_CEL - 2 * pct;
  t.w = SCR_CEL - 2 * pct;
  for (i = 0; i < TAB_H; i++) {
    for (j = 0; j < TAB_W; j++) {
      r.x = i * SCR_CEL;
      r.y = j * SCR_CEL;
      SDL_FillRect(s, &r, 0U);
      
      t.x = i * SCR_CEL + pct;
      t.y = j * SCR_CEL + pct;
      SDL_FillRect(s, &t, ~0U);
    }
  }
  return s;
}

void affiche(int * tab) {
  SDL_Surface * scr = SDL_GetVideoSurface();
  SDL_Rect r;
  Uint32 c[2] = { 0x00FF00FF, 0x0000FF00 };
  int i, j;
  static int pct = (SCR_CEL * PCT_B) / 100;
  
  SDL_BlitSurface(bckgrnd, NULL, scr, NULL);
  
  r.h = SCR_CEL - 2 * pct;
  r.w = SCR_CEL - 2 * pct;
  for (i = 0; i < TAB_H; i++) {
    for (j = 0; j < TAB_W; j++) {
      if (tab[i * TAB_W + j] != VIDE) {
        r.x = j * SCR_CEL + pct;
        r.y = i * SCR_CEL + pct;
        SDL_FillRect(scr, &r, c[tab[i * TAB_W + j] - 1]);
      }
    }
  }
  
  SDL_Flip(scr);
}

int compterDir(int * tab, Coord * c, int x, int y, int joueur) {
  int cnt, i, j;
  
  cnt = 0;
  for (j = c->x + x, i = c->y + y;
       (unsigned) j < TAB_W && (unsigned) i < TAB_H &&
       tab[i * TAB_W + j] == joueur; i += y, j += x)
    cnt++;
  
  return cnt;
}

int testerGrille(int * tab, Coord * c, int joueur) {
  Coord dir[4] = {
    { 0, 1 }, { 1,  0 },
    { 1, 1 }, { 1, -1 }
  };
  int cnt, i;
  
  for (i = 0; i < 4; i++) {
    cnt =  compterDir(tab, c, dir[i].x,  dir[i].y,  joueur);
    cnt += compterDir(tab, c, -dir[i].x, -dir[i].y, joueur);
    if (cnt + 1 >= NBR_P)
      return 1;
  }
  
  return 0;
}

int estGagnant(int ret, int joueur, int pce) {
  char s[50];
  
  if (ret)
    sprintf(s, "J%d gagne !", joueur);
  else if (pce >= TAB_T)
    sprintf(s, "Match nul !");
  else
    return 0;
  
  SDL_WM_SetCaption(s, NULL);
  attendreClic();
  return 1;
}

void jouer(int nbreJoueurs, int joueur) {
  int tab[TAB_T] = { 0 };
  int done, pce, ret;
  char s[50];
  Coord c;
  
  affiche(tab);
  
  pce = 0;
  ret = 0;
  done = 0;
  while (!done) {
    sprintf(s, "J%d joue", joueur);
    SDL_WM_SetCaption(s, NULL);
    if (nbreJoueurs == 0 || (nbreJoueurs == 1 && joueur == JIA))
      saisieIA(tab, &c, joueur, pce);
    else
      saisieCoord(tab, &c, joueur, pce);
    jouerCoup(tab, &c, joueur);
    pce++;
    if (pce >= NBR_M) {
      ret = testerGrille(tab, &c, joueur);
    }
    affiche(tab);
    done = estGagnant(ret, joueur, pce);
    joueur = 3 - joueur;
  }
}

int rejouer(void) {
  SDL_Event e;
  int c;
  
  SDL_WM_SetCaption("Voulez-vous rejouer (o)ui/(n)on ?", NULL);
  
  c = 0;
  do {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      return 0;
    if (e.type == SDL_KEYDOWN) {
      c = e.key.keysym.sym;
      c = toupper(c);
    }
  } while (c != 'N' && c != 'O');
  return c == 'O';
}

int init(void) {
  static int estInit = 0;
  
  if (estInit)
    return 0;
  srand(time(NULL));
  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
    fprintf(stderr, "%s\n", SDL_GetError());
    return -1;
  }
  atexit(SDL_Quit);
  if (SDL_SetVideoMode(SCR_W, SCR_H, 32, SDL_HWSURFACE) == NULL) {
    fprintf(stderr, "%s\n", SDL_GetError());
    return -1;
  }
  SDL_FillRect(SDL_GetVideoSurface(), NULL, 0);
  SDL_EnableUNICODE(1);
  
  bckgrnd = creerBckgrnd();
  
  estInit = 1;
  return 0;
}

void release(void) {
  if (bckgrnd) {
    free(bckgrnd);
    bckgrnd = NULL;
  }
}

int demandeNbreJoueur(void) {
  SDL_Event e;
  int c;
  
  SDL_WM_SetCaption("Nbre de joueurs : 0, 1, 2 ?", NULL);
  
  c = 0;
  do {
    SDL_WaitEvent(&e);
    if (e.type == SDL_QUIT)
      return -1;
    if (e.type == SDL_KEYDOWN) {
      c = e.key.keysym.sym;
      if (c >= SDLK_KP0 && c <= SDLK_KP9)
        c = (c - SDLK_KP0) + '0';
    }
  } while (c != '0' && c != '1' && c != '2');
  return c - '0';
}

int main(int argc, char ** argv) {
  int nbreJoueurs, joueur;
  
  if (init() < 0)
    return EXIT_FAILURE;
  
  nbreJoueurs = demandeNbreJoueur();
  if (nbreJoueurs < 0)
    return EXIT_SUCCESS;
  
  joueur = rand() % 2 + 1;
  do {
    jouer(nbreJoueurs, joueur);
    joueur = 3 - joueur;
  } while (rejouer());
  
  release();
  return EXIT_SUCCESS;
}

25 janvier 2011 à 22:31:45

Citation : Pouet_forever

Tu n'as pas de lien direct, tu es obligé d'attendre.

Ce n'est pas exactement vrai, le lien réél se situe dans la page en display:none; soit caché, j'ai créé un petit script qui me récupère le lien et comme ça, plus besoin d'attendre

Pouet_forever

25 janvier 2011 à 22:43:01

Quand je clique sur les 2 liens, j'attends. :-°

26 janvier 2011 à 1:43:22

Citation : Pouet_forever

Quand je clique sur les 2 liens, j'attends.

<?php

if(isset($_POST['mu'])){
    if(preg_match('#http://www[\d]+\.megaupload.com/files/[a-z0-9]+/(.|[^"]+)"#', file_get_contents($_POST['mu']), $m)){
        $link = substr($m[0], 0, (strlen($m[0]) - 1));
        echo '<a href="' . $link . '" title="' . $link . '">Telecharger</a>';
    } else {
        echo 'Le lien est incorrect';
    }
} else {
    echo '<form action="" method="post">
    <label for="mu">URL MegaUpload</label> : <input type="text" name="mu" />
    <input type="submit" value="Analyser" />
    </form>';
}

?>

Tiens, essaie, ce code fonctionne depuis quelques mois hez moi

Au cas où, il te faut apache et PHP (Linux) ou Wamp (Windows) ou Mamp (Mac OS) (ou un serveur en ligne

)
PS : Donner le vrai lien MU : http://www.megaupload.com/?d=600K914J

26 janvier 2011 à 4:01:23

@Pouet:
Tes fonctions de saisie clavier ne fonctionnent pas chez moi.

@Zenko:
Juste un truc, si l'utilisateur(de mauvaise volonté :ange:

), laisse le doigt appuyer sur le bouton gauche de la souris et se déplace, c'est un peu le bazar.

Tu devrais libérer ce bouton après un clic.

if(C->in.key[SDL_BUTTON_LEFT]){
            C->in.key[SDL_BUTTON_LEFT] = 0;

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

Pouet_forever

26 janvier 2011 à 7:49:19

Et si tu rajoutes un SDL_EnableUNICODE(1) dans init ? (et que tu vires le toupper de la fonction de saisie de joueur :-°)
Edit: Code modifié, dites moi si ça fonctionne.

26 janvier 2011 à 19:46:17

Citation : GurneyH

@Zenko:
Juste un truc, si l'utilisateur(de mauvaise volonté ), laisse le doigt appuyer sur le bouton gauche de la souris et se déplace, c'est un peu le bazar.

Tu devrais libérer ce bouton après un clic.
if(C->in.key[SDL_BUTTON_LEFT]){
            C->in.key[SDL_BUTTON_LEFT] = 0;

Voilà qui est fait

(Je ne l'ai pas mis dans le projet uploadé...)
Sinon, d'autres critiques à faire sur mon code ?
Je pense partir sur un autre petit projet, mais je ne sais pas encore quoi, ptet bien un pong mais l'idée d'une "IA" m'effraie un peu :-°

. Un pong 2 joueur ?

Istarill

28 janvier 2011 à 2:56:09

Salut,

J'apporte ma petite contribution de (très) débutant. Tout fonctionne... sauf ma tentative d'IA ratée :-°

Si quelqu'un à des commentaires, ne vous gênez pas. AI_ChooseBox peut vous rendre fou, vous êtes prévenus.

#ifndef DEF_CONSTANTES
#define DEF_CONSTANTES

    #define WINDOW_MEASURE      450
    #define BOX_MEASURE         150

    enum {EMPTY, PLAYERTAKEN, AITAKEN};

#endif

int main(int argc, char** argv)
{
    SDL_Surface *screen = NULL;

    SDL_Init(SDL_INIT_VIDEO);
    screen = SDL_SetVideoMode(WINDOW_MEASURE, WINDOW_MEASURE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
    SDL_WM_SetCaption("Tic Tac Toe", NULL);

    game(screen); // Launching the game...

    SDL_Quit();
    return EXIT_SUCCESS;
}

#include <stdio.h>
#include <stdlib.h>
#include <SDL.h>
#include <SDL_Image.h>
#include <time.h>
#include "const.h"
#include "display.h"

void game(SDL_Surface *screen)
{
    SDL_Event event;
    int boxes[3][3] = {EMPTY};
    int running = 1;

    srand(time(NULL));

    while(running)
    {
        // Player's turn
        SDL_WaitEvent(&event);
        switch(event.type)
        {
            case SDL_QUIT:
                running = 0;
                break;

            case SDL_MOUSEBUTTONUP:
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    chooseBox(boxes, event.button.x, event.button.y);
                }
        }

        // AI's turn
        AI_ChooseBox(boxes);

        // Screen updating
        SDL_FillRect(screen, NULL, SDL_MapRGB(screen->format, 255, 255, 255));
        drawPieces(screen, boxes);
        drawLines(screen);
        SDL_Flip(screen);
    }
}

void chooseBox(int boxes[][3], int x, int y)
{
    // 1st box
    if(x > 0 && x < (WINDOW_MEASURE / 3) && y > 0 && y < (WINDOW_MEASURE / 3))
    {
        if(boxes[0][0] == EMPTY) // Only if the box is empty
        {
            boxes[0][0] = PLAYERTAKEN;
        }
    }

    // 2nd box
    if(x > 0 && x < (WINDOW_MEASURE / 3) && y > (WINDOW_MEASURE / 3) && y < (WINDOW_MEASURE * 2 / 3))
    {
        if(boxes[0][1] == EMPTY)
        {
            boxes[0][1] = PLAYERTAKEN;
        }
    }

    // 3rd box
    if(x > 0 && x < (WINDOW_MEASURE / 3) && y > (WINDOW_MEASURE * 2 / 3) && y < WINDOW_MEASURE)
    {
        if(boxes[0][2] == EMPTY)
        {
            boxes[0][2] = PLAYERTAKEN;
        }
    }

    // 4th box
    if(x > (WINDOW_MEASURE / 3) && x < (WINDOW_MEASURE * 2 / 3) && y > 0 && y < (WINDOW_MEASURE / 3))
    {
        if(boxes[1][0] == EMPTY)
        {
            boxes[1][0] = PLAYERTAKEN;
        }
    }

    // 5th box
    if(x > (WINDOW_MEASURE / 3) && x < (WINDOW_MEASURE * 2 / 3) && y > (WINDOW_MEASURE / 3) && y < (WINDOW_MEASURE * 2 / 3))
    {
        if(boxes[1][1] == EMPTY)
        {
            boxes[1][1] = PLAYERTAKEN;
        }
    }

    // 6th box
    if(x > (WINDOW_MEASURE / 3) && x < (WINDOW_MEASURE * 2 / 3) && y > (WINDOW_MEASURE * 2 / 3) && y < WINDOW_MEASURE)
    {
        if(boxes[1][2] == EMPTY)
        {
            boxes[1][2] = PLAYERTAKEN;
        }
    }

    // 7th box
    if(x > (WINDOW_MEASURE * 2 / 3) && x < WINDOW_MEASURE && y > 0 && y < (WINDOW_MEASURE / 3))
    {
        if(boxes[2][0] == EMPTY)
        {
            boxes[2][0] = PLAYERTAKEN;
        }
    }

    // 8th box
    if(x > (WINDOW_MEASURE * 2 / 3) && x < WINDOW_MEASURE && y > (WINDOW_MEASURE / 3) && y < (WINDOW_MEASURE *2 / 3))
    {
        if(boxes[2][1] == EMPTY)
        {
            boxes[2][1] = PLAYERTAKEN;
        }
    }

    // 9th box
    if(x > (WINDOW_MEASURE * 2 / 3) && x < WINDOW_MEASURE && y > (WINDOW_MEASURE * 2 / 3) && y < WINDOW_MEASURE)
    {
        if(boxes[2][2] == EMPTY)
        {
            boxes[2][2] = PLAYERTAKEN;
        }
    }
}

void AI_ChooseBox(int boxes[][3])
{
    int MAX = 2;
    int MIN = 1;
    int i = 0;
    int j = 0;

    if((boxes[0][0] == AITAKEN && boxes[1][1] == AITAKEN && boxes[2][2] == EMPTY) || (boxes[0][0] == AITAKEN && boxes[2][2] && boxes[1][1] == EMPTY) || (boxes[1][1] == AITAKEN && boxes[2][2] == AITAKEN && boxes[0][0] == EMPTY))
    {
        // 1st diagonal
        if(boxes[0][0] == EMPTY)
            boxes[0][0] = AITAKEN;

        if(boxes[1][1] == EMPTY)
            boxes[1][1] = AITAKEN;

        if(boxes[2][2] == EMPTY)
            boxes[2][2] = AITAKEN;
    }
    else if((boxes[0][2] == AITAKEN && boxes[1][1] == AITAKEN && boxes[2][0] == EMPTY) || (boxes[0][2] == AITAKEN && boxes[2][0] == AITAKEN && boxes[1][1] == EMPTY) || (boxes[1][1] == AITAKEN && boxes[2][0] == AITAKEN && boxes[0][2] == EMPTY))
    {
        // 2nd diagonal
        if(boxes[0][2] == EMPTY)
            boxes[0][2] = AITAKEN;

        if(boxes[1][1] == EMPTY)
            boxes[1][1] = AITAKEN;

        if(boxes[2][0] == EMPTY)
            boxes[2][0] = AITAKEN;
    }
    else if((boxes[0][0] == AITAKEN && boxes[0][1] == AITAKEN && boxes[0][2] == EMPTY) || (boxes[0][1] == AITAKEN && boxes[0][2] == AITAKEN && boxes[0][0] == EMPTY) || (boxes[0][0] == AITAKEN && boxes[0][2] == AITAKEN && boxes[0][1] == EMPTY))
    {
        // 1st column
        if(boxes[0][0] == EMPTY)
            boxes[0][0] = AITAKEN;

        if(boxes[0][1] == EMPTY)
            boxes[0][1] = AITAKEN;

        if(boxes[0][2] == EMPTY)
            boxes[0][2] = AITAKEN;
    }
    else if((boxes[1][0] == AITAKEN && boxes[1][1] == AITAKEN && boxes[1][2] == EMPTY) || (boxes[1][1] == AITAKEN && boxes[1][2] == AITAKEN && boxes[1][0] == EMPTY) || (boxes[1][0] == AITAKEN && boxes[1][2] == AITAKEN && boxes[1][1] == EMPTY))
    {
        // 2nd column
        if(boxes[1][0] == EMPTY)
            boxes[1][0] = AITAKEN;

        if(boxes[1][1] == EMPTY)
            boxes[1][1] = AITAKEN;

        if(boxes[1][2] == EMPTY)
            boxes[1][2] = AITAKEN;
    }
    else if((boxes[2][0] == AITAKEN && boxes[2][1] == AITAKEN && boxes[2][2] == EMPTY ) || (boxes[2][1] == AITAKEN && boxes[2][2] == AITAKEN && boxes[2][0] == EMPTY) || (boxes[2][0] == AITAKEN && boxes[2][2] == AITAKEN && boxes[2][1] == EMPTY))
    {
        // 3rd column
        if(boxes[2][0] == EMPTY)
            boxes[2][0] = AITAKEN;

        if(boxes[2][1] == EMPTY)
            boxes[2][1] = AITAKEN;

        if(boxes[2][2] == EMPTY)
            boxes[2][2] = AITAKEN;
    }
    else if((boxes[0][0] == AITAKEN && boxes[0][1] == AITAKEN && boxes[0][2] == EMPTY) || (boxes[0][1] == AITAKEN && boxes[0][2] == AITAKEN && boxes[0][0] == EMPTY) || (boxes[0][0] == AITAKEN && boxes[0][2] == AITAKEN && boxes[0][1] == EMPTY))
    {
        // 1st row
        if(boxes[0][0] == EMPTY)
            boxes[0][0] = AITAKEN;

        if(boxes[0][1] == EMPTY)
            boxes[0][1] = AITAKEN;

        if(boxes[0][2] == EMPTY)
            boxes[0][2] = AITAKEN;
    }
    else if((boxes[1][0] == AITAKEN && boxes[1][1] == AITAKEN && boxes[1][2] == EMPTY) || (boxes[1][1] == AITAKEN && boxes[1][2] == AITAKEN && boxes[1][0] == EMPTY) || (boxes[1][0] == AITAKEN && boxes[1][2] == AITAKEN && boxes[1][1] == EMPTY))
    {
        // 2nd row
        if(boxes[1][0] == EMPTY)
            boxes[1][0] = AITAKEN;

        if(boxes[1][1] == EMPTY)
            boxes[1][1] = AITAKEN;

        if(boxes[1][2] == EMPTY)
            boxes[1][2] = AITAKEN;
    }
    else if((boxes[2][0] == AITAKEN && boxes[2][1] == AITAKEN && boxes[2][2] == EMPTY) || (boxes[2][1] == AITAKEN && boxes[2][2] == AITAKEN && boxes[2][0] == EMPTY) || (boxes[2][0] == AITAKEN && boxes[2][2] == AITAKEN && boxes[2][1] == EMPTY))
    {
        // 3rd row
        if(boxes[2][0] == EMPTY)
            boxes[2][0] = AITAKEN;

        if(boxes[2][1] == EMPTY)
            boxes[2][1] = AITAKEN;

        if(boxes[2][2] == EMPTY)
            boxes[2][2] = AITAKEN;
    }
    else // Chooses a random box
    {
        do
        {
            i = (rand() % (MAX - MIN + 1)) + MIN;
            j = (rand() % (MAX - MIN + 1)) + MIN;
            boxes[i][j] = AITAKEN;
        }
        while(boxes[i][j] != EMPTY); // Repeats until he finds an empty box
    }
}

#include <stdlib.h>
#include "display.h"
#include "const.h"

void drawLines(SDL_Surface *screen)
{
    SDL_Surface *verticalLine = SDL_CreateRGBSurface(SDL_HWSURFACE, 4, WINDOW_MEASURE, 32, 0, 0, 0, 0);
    SDL_Surface *horizontalLine = SDL_CreateRGBSurface(SDL_HWSURFACE, WINDOW_MEASURE, 4, 32, 0, 0, 0, 0);
    SDL_Rect position;
    position.x = 0;
    position.y = 0;
    int i = 1;

    // Colors the lines in black
    SDL_FillRect(verticalLine, NULL, SDL_MapRGB(screen->format, 0, 0, 0));
    SDL_FillRect(horizontalLine, NULL, SDL_MapRGB(screen->format, 0, 0, 0));

    for(i = 1 ; i < 3 ; i++)
    {
        position.x = (i * BOX_MEASURE) - (verticalLine->w / 2);
        SDL_BlitSurface(verticalLine, NULL, screen, &position);
    }

    position.x = 0; // Resets x to 0 (because of the previous loop...)

    for(i = 1 ; i < 3 ; i++)
    {
        position.y = (i * BOX_MEASURE) - (horizontalLine->h / 2);
        SDL_BlitSurface(horizontalLine, NULL, screen, &position);
    }

    SDL_FreeSurface(verticalLine);
    SDL_FreeSurface(horizontalLine);
}

void drawPieces(SDL_Surface *screen, int boxes[][3])
{
    SDL_Surface *circle = NULL, *ex = NULL;
    SDL_Rect position;
    position.x = 0;
    position.y = 0;
    int i = 0;
    int j = 0;

    circle = IMG_Load("circle.bmp");
    ex = IMG_Load("ex.bmp");

    for(j = 0 ; j < 3 ; j++)
    {
        for(i = 0 ; i < 3 ; i++)
        {
            if(boxes[i][j] == PLAYERTAKEN)
            {
                position.x = i * 150;
                position.y = j * 150;
                SDL_BlitSurface(circle, NULL, screen, &position);
            }

            if(boxes[i][j] == AITAKEN)
            {
                position.x = i * 150;
                position.y = j * 150;
                SDL_BlitSurface(ex, NULL, screen, &position);
            }
        }
    }
}

À la prochaine

28 janvier 2011 à 4:23:38

@Istarill:
tu as testé ton programme? o_O

J'ai tout collé dans un seul fichier, c'est probablement moi qui fait une erreur, mais le programme part en boucle infini sans rien afficher.
Dans ta fonction AI_ChooseBox, tu fais

else // Chooses a random box
    {
        do
        {
            i = (rand() % (MAX - MIN + 1)) + MIN;
            j = (rand() % (MAX - MIN + 1)) + MIN;
            boxes[i][j] = AITAKEN;
        }
        while(boxes[i][j] != EMPTY); // Repeats until he finds an empty box
    }

Tu remplis, la case, et ensuite tu boucles tant que la case n'est pas vide.
:-°

Une fois le problème corrigé, le programme rempli la grille complète avec des croix.

Je réessaye dans le week end, en gardant ta structure pour voir.

@Zenko:
Oui un Pong, après le morpion, c'est une bonne idée.
Pour l'IA d'un pong ne te casse pas la tête, dans un premier temps, je pense que tu peux te contenter de faire en sorte que la raquette se dirige vers la balle.
Après tu pourras toujours améliorer(gestion des rebonds sur les cotés, essayer de battre le joueur, etc...)
Bon courage!

@Pouet: Pareil, j'essaye de faire fonctionner ton programme sur mon ordi ce week-end.

Et, j'essaierai de proposer une version du zMorp SDL.

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

Istarill

28 janvier 2011 à 4:51:25

Il faut plusieurs fichiers, désolé d'avoir rien précisé. (const.h, game.c, display.c et headers associés)
En effet, comme je l'ai dit précédemment, l'AI pose réellement problème et je planche dessus

Je crois avoir cerné le problème des croix, l'évènement MOUSEMOTION fait continuer le programme.
Pour le truc de la boucle, je boucle tant que la case n'est pas une case vide, car je peux pas placer une croix sur une autre ou un cercle, non? Oo