je voudrais savoir comment afficher une image, comment installer le clavier et la souris.
et comment initialiser.

svp

. ..je pense que si tu recherches de la doc sur google, tu trouvera, mais je ne suis pas sur.

je te conseille d´aller sur le site suivant :

http://www.libsdl.org/index.php

d´aller dans download/games

de télécharger NOID 1.0

tu verras le code n´est pas trop trop long et le jeu est pas mal

Etudie le code maintenant que tu sais un peu comme marche le C

essaie surtout de réussir a le compiler chez toi, c´est la 1ere étape, puis ensuite essaie de modifier un ou 2 trucs pour voir ce que ça change ( en faisant une copie avant)

merci

j comprend rien à la SDL ! !!!!!!!!!!!

pk qd on initialise il faut mettre print error ?

connaissez vous de bons tuto ou des scripts commentés? ( je préfère les scripts).

sinon existe-t-il de bons livres ds le commerce?

sinon mailez moi.
SVP!
SSSSSSSSSSVVVVVVVVVVPPPPPPPPPP!!!!!!!!!!

t´arrive a le lancer compiler déja ?

regarde les docs qui sont fournies avec.

et pour les lignes du genre :

if ( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0)
{
printf( " Video initialization failed: %s\n", SDL_GetError() ) ;
die();
}

cela est simple :
la commande SDL_Init va tenter d´initialiser SDL, puis elle va te retourner un nombre, un résultat
si ce nombre est < 0, ça veut dire que ça a foiré : donc dans ce cas, il affiche l´erreur.

c´est ce qu´on appelle les valeurs de retour des fonctions : la fonction fait quelque chose, mais ça peut foirer pour de diverses raisons, c´est pour ça qu´il faut tester le code de retour pour savoir.

le code du dessus est équivalent à :

int code_de_retour;
code_de_retour = SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
if ( code_de_retour < 0)
{
printf( " Video initialization failed: %s\n", SDL_GetError() ) ;
die();
}

je pense que tu vois mieux comme ça

pour savoir comment marche une fonction, regarde sa notice ( elle y es dans les docs de SDL) elle te dis comment est marche, et le code de retour qu´elle renvoit

vous connaissez pas un site avec la notice de la SDL en Français?

tu veux pas 100 Euro et un twix ?

Faut te mettre a l´anglais mon vieux
la doc de SDL qu´il y a à télécharger sur le net avec les libs est tres bien faite : elle est en anglais, mais y´a pas de blabla, donc elle est facile à comprendre !

tu n´as pas répondu a ma question : ARRIVES TU DEJA A Y COMPILER ?
Est ce que tu y as installé correctement.

Autre remarque, mais C toi qui voit : je ne pense pas que tu sois déja pret a sauter sur le graphisme...

. ..Ca me rappelle quelque chose...

je crois que je v continuer à faire des petits jeux.

sinon qd je compile ( g Dev-C++) g d erreurs de linkers.

Ah ben faut jamais essayer de programmer a l´aveuglettre, faut réussir a compiler pour pouvoir modifier

en téléchargeant SDL, tu dois pouvoir le compiler pour pouvoir faire une LIB, que tu copies dans ton répertoire LIB, copier le . h dans ton repertoire include, et mettre le . DLL dans le meme repertoire que ton futur fichier EXE
renseigne toi pour DEV C++, moi j´ai fait ça avec Visual C++.

Il est vrai qu´avant cela, il serait bien pour toi d´apprendre encore d´autres structures de controle du C :

tu connais déja ( essaie de maitriser : )
les variables simples
les tableaux
les if / else
les for
les while

il te faut maintenant connaitre
les struct
les appels de fonctions
les pointeurs

et surtout bien prendre en main tout ça

pour créer un tableau de 7 case horyzonthales et 6 verticales, je rentre " int tableau [6] [7]" ou " int tableau [7] [6]" ?

voila g le script d´un morpion:

//ce script réprésente un Morpion où le joueur joue
//contre l´ordinateur grâce à une heuristique testant les meilleurs
//possibilités de l´ordinateur à jouer

1. include < iostream>

//évite la répétition de std:: lors de l´emploie de ces fonctions
using std::cin;
using std::cout;
using std::endl;

1. include < cstdlib>
2. include < ctime>

class morpion
{
public :
morpion();
void jouer(int);

private :
//cette fonction est une nouvelle fonction qui sert à placer un pion
//pour " l´ordinateur"
void placePionOrdi();
int verif();
void afficher();
void reini();
int jeu[3][3];
int joueur;
};

morpion::morpion()
{
for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
jeu[y][x] = 0;
joueur = rand()%2 + 1;
cout < <
"\n----------------------------------MORPION------
----------------------------\n\n";
jouer(joueur);
}

void morpion::placePionOrdi()
{
//cette fonction va donc servir à placer un pion pour l´ordinateur
//l´algorithme a pour but de faire plusieurs conditions, les premières
//ont pour but de voir si l´ordinateur peut placer un pion dans une case de
//façon à gagner directement, il va donc tester tout les possibilités
if ( jeu[0][0] == 2 && jeu[1][1] == 2 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[0][0] == 2 && jeu[1][1] == 0 && jeu[2][2] == 2)
jeu[1][1] = 2;
else
if ( jeu[0][0] == 0 && jeu[1][1] == 2 && jeu[2][2] == 2)
jeu[0][0] = 2;
else
if ( jeu[2][0] == 2 && jeu[1][1] == 2 && jeu[0][2] == 0)
jeu[0][2] = 2;
else
if ( jeu[2][0] == 2 && jeu[1][1] == 0 && jeu[0][2] == 2)
jeu[1][1] = 2;
else
if ( jeu[2][0] == 0 && jeu[1][1] == 2 && jeu[0][2] == 2)
jeu[2][0] = 2;
else
if ( jeu[2][0] == 2 && jeu[2][1] == 2 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[2][0] == 2 && jeu[2][1] == 0 && jeu[2][2] == 2)
jeu[2][1] = 2;
else
if ( jeu[2][0] == 0 && jeu[2][1] == 2 && jeu[2][2] == 2)
jeu[2][0] = 2;
else
if ( jeu[1][0] == 2 && jeu[1][1] == 2 && jeu[1][2] == 0)
jeu[1][2] = 2;
else
if ( jeu[1][0] == 2 && jeu[1][1] == 0 && jeu[1][2] == 2)
jeu[1][1] = 2;
else
if ( jeu[1][0] == 0 && jeu[1][1] == 2 && jeu[1][2] == 2)
jeu[1][0] = 2;
else
if ( jeu[0][0] == 2 && jeu[0][1] == 2 && jeu[0][2] == 0)
jeu[0][2] = 2;
else
if ( jeu[0][0] == 2 && jeu[0][1] == 0 && jeu[0][2] == 2)
jeu[0][1] = 2;
else
if ( jeu[0][0] == 0 && jeu[0][1] == 2 && jeu[0][2] == 2)
jeu[0][0] = 2;
else
if ( jeu[0][0] == 2 && jeu[1][0] == 2 && jeu[2][0] == 0)
jeu[2][0] = 2;
else
if ( jeu[0][0] == 2 && jeu[1][0] == 0 && jeu[2][0] == 2)
jeu[1][0] = 2;
else
if ( jeu[0][0] == 0 && jeu[1][0] == 2 && jeu[2][0] == 2)
jeu[0][0] = 2;
else
if ( jeu[0][1] == 2 && jeu[1][1] == 2 && jeu[2][1] == 0)
jeu[2][1] = 2;
else
if ( jeu[0][1] == 2 && jeu[1][1] == 0 && jeu[2][1] == 2)
jeu[1][1] = 2;
else
if ( jeu[0][1] == 0 && jeu[1][1] == 2 && jeu[2][1] == 2)
jeu[0][1] = 2;
else
if ( jeu[0][2] == 2 && jeu[1][2] == 2 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[0][2] == 2 && jeu[1][2] == 0 && jeu[2][2] == 2)
jeu[1][2] = 2;
else
if ( jeu[0][2] == 0 && jeu[1][2] == 2 && jeu[2][2] == 2)
jeu[0][2] = 2;
else
//les conditions suivantes servent a voir si au contraire le joueur " humain"
//peut gagner d´un coup en mettant un juste pion dans un case, l´ordinateur
//va donc placer son pion dans cette case de façon à ne pas laisser
//le joueur " humain" gagner
if ( jeu[0][0] == 1 && jeu[1][1] == 1 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[0][0] == 1 && jeu[1][1] == 0 && jeu[2][2] == 1)
jeu[1][1] = 2;
else
if ( jeu[0][0] == 0 && jeu[1][1] == 1 && jeu[2][2] == 1)
jeu[0][0] = 2;
else
if ( jeu[2][0] == 1 && jeu[1][1] == 1 && jeu[0][2] == 0)
jeu[0][2] = 2;
else
if ( jeu[2][0] == 1 && jeu[1][1] == 0 && jeu[0][2] == 1)
jeu[1][1] = 2;
else
if ( jeu[2][0] == 0 && jeu[1][1] == 1 && jeu[0][2] == 1)
jeu[2][0] = 2;
else
if ( jeu[2][0] == 1 && jeu[2][1] == 1 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[2][0] == 1 && jeu[2][1] == 0 && jeu[2][2] == 1)
jeu[2][1] = 2;
else
if ( jeu[2][0] == 0 && jeu[2][1] == 1 && jeu[2][2] == 1)
jeu[2][0] = 2;
else
if ( jeu[1][0] == 1 && jeu[1][1] == 1 && jeu[1][2] == 0)
jeu[1][2] = 2;
else
if ( jeu[1][0] == 1 && jeu[1][1] == 0 && jeu[1][2] == 1)
jeu[1][1] = 2;
else
if ( jeu[1][0] == 0 && jeu[1][1] == 1 && jeu[1][2] == 1)
jeu[1][0] = 2;
else
if ( jeu[0][0] == 1 && jeu[0][1] == 1 && jeu[0][2] == 0)
jeu[0][2] = 2;
else
if ( jeu[0][0] == 1 && jeu[0][1] == 0 && jeu[0][2] == 1)
jeu[0][1] = 2;
else
if ( jeu[0][0] == 0 && jeu[0][1] == 1 && jeu[0][2] == 1)
jeu[0][0] = 2;
else
if ( jeu[0][0] == 1 && jeu[1][0] == 1 && jeu[2][0] == 0)
jeu[2][0] = 2;
else
if ( jeu[0][0] == 1 && jeu[1][0] == 0 && jeu[2][0] == 1)
jeu[1][0] = 2;
else
if ( jeu[0][0] == 0 && jeu[1][0] == 1 && jeu[2][0] == 1)
jeu[0][0] = 2;
else
if ( jeu[0][1] == 1 && jeu[1][1] == 1 && jeu[2][1] == 0)
jeu[2][1] = 2;
else
if ( jeu[0][1] == 1 && jeu[1][1] == 0 && jeu[2][1] == 1)
jeu[1][1] = 2;
else
if ( jeu[0][1] == 0 && jeu[1][1] == 1 && jeu[2][1] == 1)
jeu[0][1] = 2;
else
if ( jeu[0][2] == 1 && jeu[1][2] == 1 && jeu[2][2] == 0)
jeu[2][2] = 2;
else
if ( jeu[0][2] == 1 && jeu[1][2] == 0 && jeu[2][2] == 1)
jeu[1][2] = 2;
else
if ( jeu[0][2] == 0 && jeu[1][2] == 1 && jeu[2][2] == 1)
jeu[0][2] = 2;
//le reste de cette fonction utilise un algorithme plus complexe que celui
//utilisé précédement, il va créer un tableau vide et va mettre des valeur
//négatives au même emplacement que dans le jeu là où le joueur 1 et l´ordinateur
//a mis des pions, il va augmenter chaque case du nombre de possibilités
//que cette case peut faire gagner l´ordinateur
else
{
int tb[3][3] = { 0 };
//initialisation des cases où des pions ne peuvent y mettre mis
for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
if ( jeu[y][x] == 1 )
tb[y][x] = -2;
else
if ( jeu[y][x] == 2 )
tb[y][x] = -1;

//les conditions suivantes vont donc ajouter 1 à chaque cases du tableau
//temporaire à chaque fois que si on met un pions dans cette case
//il peut y avoir une possibilités que l´ordinateur gagne
if ( jeu[0][0] ! = 1 && jeu[1][1] ! = 1 && jeu[2][2] ! = 1 )
{
++tb[0][0];
++tb[1][1];
++tb[2][2];
}
if ( jeu[2][0] ! = 1 && jeu[1][1] ! = 1 && jeu[0][2] ! = 1 )
{
++tb[2][0];
++tb[1][1];
++tb[0][2];
}
if ( jeu[2][0] ! = 1 && jeu[2][1] ! = 1 && jeu[2][2] ! = 1 )
{
++tb[2][0];
++tb[2][1];
++tb[2][2];
}
if ( jeu[1][0] ! = 1 && jeu[1][1] ! = 1 && jeu[1][2] ! = 1 )
{
++tb[1][0];
++tb[1][1];
++tb[1][2];
}
if ( jeu[0][0] ! = 1 && jeu[0][1] ! = 1 && jeu[0][2] ! = 1 )
{
++tb[0][0];
++tb[0][1];
++tb[0][2];
}
if ( jeu[0][0] ! = 1 && jeu[1][0] ! = 1 && jeu[2][0] ! = 1 )
{
++tb[0][0];
++tb[1][0];
++tb[2][0];
}
if ( jeu[0][1] ! = 1 && jeu[1][1] ! = 1 && jeu[2][1] ! = 1 )
{
++tb[0][1];
++tb[1][1];
++tb[2][1];
}
if ( jeu[0][2] ! = 1 && jeu[1][2] ! = 1 && jeu[2][2] ! = 1 )
{
++tb[0][2];
++tb[1][2];
++tb[2][2];
}
//on définit une variable qui stoquera la case de tableau temporaire
//qui donne un maximum de possibilités à l´ordinateur de gagner
int max = 0;

for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
if ( tb[y][x] > = max )
max = tb[y][x];

//après avoir trouvé la case précédente, on va placer le pion de
//l´ordinateur à l´intérieur en vérifiant avant que cette case est libre
for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
if ( tb[y][x] == max && jeu[y][x] == 0)
{
jeu[y][x] = 2;
//permet de quitter la boucle
x = 3, y = 3;
}
}
}

void morpion::reini()
{
for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
jeu[y][x] = 0;
}

int morpion::verif()
{
int pp = 0;
//on change un peu cette fonction, au lieu de marquer que c´est le joueur
//2 qui gagne on met que c´est l´ordinateur grâce à 2 pointeurs qui pointent
//vers des chaînes de caractères
char *ord = " L´ordinateur a";
char *vous = " Vous avez";
cout < < endl < < endl;
for ( int player = 1; player < = 2; ++player)
{
if ( jeu[0][0] == player && jeu[1][1] == player && jeu[2][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " X - -\n"
< < " - X -\n"
< < " - - X\n"
< < " Bravo ! !!" < < endl;
return ( 0 + player);
}
else
if ( jeu[2][0] == player && jeu[1][1] == player && jeu[0][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " - - X\n"
< < " - X -\n"
< < " X - -\n"
< < " Bravo ! !!" < < endl;
return ( 3 + player);
}
else
if ( jeu[2][0] == player && jeu[2][1] == player && jeu[2][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " - - -\n"
< < " - - -\n"
< < " X X X\n"
< < " Bravo ! !!" < < endl;
return ( 6 + player);
}
else
if ( jeu[1][0] == player && jeu[1][1] == player && jeu[1][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " - - -\n"
< < " X X X\n"
< < " - - -\n"
< < " Bravo ! !!" < < endl;
return ( 9 + player);
}
else
if ( jeu[0][0] == player && jeu[0][1] == player && jeu[0][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " X X X\n"
< < " - - -\n"
< < " - - -\n"
< < " Bravo ! !!" < < endl;
return ( 12 + player);
}
else
if ( jeu[0][0] == player && jeu[1][0] == player && jeu[2][0] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " X - -\n"
< < " X - -\n"
< < " X - -\n"
< < " Bravo ! !!" < < endl;
return ( 15 + player);
}
else
if ( jeu[0][1] == player && jeu[1][1] == player && jeu[2][1] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " - X -\n"
< < " - X -\n"
< < " - X -\n"
< < " Bravo ! !!" < < endl;
return ( 18 + player);
}
else
if ( jeu[0][2] == player && jeu[1][2] == player && jeu[2][2] == player)
{
cout < < ( ( player == 1) ? vous : ord ) < < " gagne en alignant ainsi :\n"
< < " - - X\n"
< < " - - X\n"
< < " - - X\n"
< < " Bravo ! !!" < < endl;
return ( 21 + player);
}
else
if ( player == 2)
{
for ( int y = 0; y < 3; ++y)
for ( int x = 0; x < 3; ++x)
if ( jeu[y][x] == 0)
{
pp = 1;
y = 3, x = 3;
}
else
{
pp = 5;
}
if ( pp == 1)
{
return 24;
}
else
{
cout < < endl < < endl < < " Desole mais il n´y a pas de gagnant : il y a egalite . " < < endl < < endl;
return 25;
}
}
}
}

void morpion::afficher()
{
cout < < endl;
for ( int y = 0; y < 3; ++y)
{
for ( int x = 0; x < 3; ++x)
cout < < jeu[y][x] < < ´ ´;
cout < < endl;
}
cout < < endl;
}

void morpion::jouer(int player)
{
int a = 0, b = 0, termine = 24;
if ( player == 1 || player == 2)
joueur = player;
else
{
player = rand()%2 + 1;
joueur = player;
}

while(termine == 24)
{
//on modifie aussi cette fonction de façon que si c´est l´ordinateur
//qui commence une partie et bien le joueur 1 ne puisse pas jouer, on
//met donc une condition toute simple :
if ( joueur == 1)
{
afficher();
do{
cout < < " Entrer la ligne ( 1 a 3) puis la colonne ( 1 a 3) : " < < endl;
cin > > a > > b;
if ( jeu[a - 1][b - 1] ! = 0)
cout < < " Desole mais cette case est deja occupe . " < < endl;}
while(jeu[a - 1][b - 1] ! = 0 || a < 1 || a > 3 || b < 1 || b > 3 ) ;
jeu[a - 1][b - 1] = joueur;

termine = verif();

joueur = 2;
}
//comme avant, il a été déterminé si le joueur 1 a gagné alors cette
//condition a pour but de ne pas faire jouer l´ordinateur si le joueur
//1 a déjà gagné
if ( termine == 24 )
{
afficher();
//appel de cette fonction qui va faire jouer l´ordinateur
placePionOrdi();
termine = verif();

joueur = 1;
}
}
cout < < endl < < endl < < " Voici l´etat du jeu a la fin : " < < endl < < endl;
afficher();
reini();
}

void main()
{
//début de f. main
srand( time(0) ) ;

morpion jeu;

//invite l´utilisateur à entrer un nombre pour quitter le programme afin de ralentir
//la sortie de celui-çi
cout<<"\nEntrer q pour quitter : " ;
int zz;
cin>>zz;
}

je voudrais modifier le tableau pour qu´il est une taiile comme ds la question juste avant mais je ne sais pas comment faire.

PS: je veux transformer ce morpion en un puissance 4.

up

pour le tableau, c´est toi qui décide :

int a[7][6] ou int a[6][7], c´est différent, mais sans etre important :
le tout est que tu ne te gourres pas dans tes appels de a[i][j] derriere

dans ton exemple, ta colonie de " if" peut surement etre remplacé soit pas un " switch"
mais je suis sur que tu peux trouver une logique à ça en mettant un for, et un seul if en boucle derriere

ça sert à quoi le " switch"?

et le " for"? j´ai oublié!

switch

--> au lieu de mettre des milion de if tu mes un switch

switch(varialbe a evaluer){
case 1:
consequence 1
case 2:
consequence 2
default:
par defaut
}

note que le 1 , 2 pres des case son changer par a condition voulu . .. exemple tu veu savoir si la varible = m ou n tu remplace 1 par m , et 2 par n . ..

--> for ces une boucle . ..