@interrupt void bouton(void)
{
if ((GPIOC->IDR & 0x02) == GPIO_PIN_1)
jouer(&(tabJoueur[0]));
else if ((GPIOC->IDR & 0x04) == GPIO_PIN_2)
jouer(&(tabJoueur[1]));
else if ((GPIOC->IDR & 0x08) == GPIO_PIN_3)
jouer(&(tabJoueur[2]));
return;
}
void Warcraft::run(){
//demande à l'utilisateur de choisir le mode, si celui demande un mode non-disponible elle se réitère
ecr->effacerEcranV(NOIR);
ecr->afficherMot("Bienvenue dans Warcraft\n Deux modes de jeu sont disponible \n");
ecr->afficherMot("a:Classique\nb:Tour de defense\n");
ecr->afficherMot("Pour lancer le mode de votre choix taper la numero correspondant");
char i=clavier->getChar();
if(i=='a'){
warClassic();
}
else if(i=='b'){
warTD();
}
else{
warClassic();
}
horloge=0;
int previous=0;
while(1){
if (gettime()>(previous+frequence)) {
previous=gettime();
horloge=0;
jouer();
}
}
}
void Pause(SDL_Surface *ecran)//boucle + fermeture avec x + 1 lancement du jeu
{
int continuer = 1;
SDL_Event event;
while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_a:
jouer(ecran);
break;
default:
break;
}
break;
}
}
}
/**
* Affiche le menu du joueur, puis execute l'action que le joueur souhaite faire :
* jouer, afficher ses pions en main, sauvegarde ou quitter
* Renvoie 0 si le joueur souhaite quitter, 1 sinon
*/
int JoueurReel::jouerTour(Plateau* p, Affichage* affichage, Partie partie){
int jeu;
// Affichage du menu du joueur
do{
jeu = affichage->menuJoueur(this);
// Si jeu = 2 ==> le joueur joue
if(jeu == 2){
bool joue = false;
do{
joue = jouer(p, affichage);
}while(!joue);
break;
}
// Le joueur ne joue pas mais fait une autre action
else{
string filename;
switch(jeu){
// Le joueur souhaite afficher sa liste de pions
case 1 : affichage->afficheListAnimal(getListAnimaux()); break;
// Le joueur souhaite sauvegarder la partie
case 3 :
filename = affichage->saisieFileSauvegarde();
Sauvegarde::sauvegarderPartie(partie,filename, getId());
affichage->afficheSauvegarde(filename);
break;
// Le joueur souhaite quitter la partie
case 4 : return 0;
}
}
}while(jeu!=2);
return 1;
}
int _tmain(int argc, char *argv[])
{
jouer();
getchar();
return 0;
}
int
main ()
{
menuJeu();
g = generer_grille(g.tab);
if(isGameReloaded == NO) {
menuJoueur();
}
time(&debut);
afficher_grille(g.tab, game);
strncpy(joueur, game->nomJoueur1, PLAYER_NAME_SIZE);
liste = initialisation();
while (g.statut == VIDE)
{
printf("Joueur %s, a vous de jouer !\n", joueur);
if(game->mode == MULTI) {
jouer(tour);
} else {
if(tour == 0) {
jouer(tour);
} else {
struct Coup coup = ordijouer(g.tab);
g.tab[coup.ligne][coup.colonne] = 'X';
/* TEST WRITE DATA
writeData(liste, game);*/
}
}
g.nb_vide--;
/* Test si 3 pions sont allignés */
char signe = (tour == 0) ? 'O' : 'X';
int result = verifier_grille(g.tab, signe);
printf("\n----- result: %d\n ", result);
misAJourScore(result);
/* Vérifie si la partie est finie */
verifierFinPartie();
}
return 0;
}
/*Ici les fantomes accélèrent de plus en plus
* et le but est de tenir le plus longtemps
* sans se faire dévorer*/
void survivor(int level, config *cfg)
{
if(level>=NB_LEVEL) return;
int selection, counter=SDL_GetTicks(), tmp=counter, elapsed;
SAVE_ENABLE=0;
play_menu(level);
Pacman pac;
Fantome ftm[NB_MAX_GHOSTS];
score_message *msg_list = NULL;
Input in;
init_pacman(&pac, cfg);
init_level();
init_blocks();
load_level(level);
pac_restart(&pac);
pac.nb_lives=1;
init_ghosts(ftm, cfg);
memset(&in,0,sizeof(in));
DELAY = 40;
while(pac.nb_lives && POINTS)
{
elapsed = SDL_GetTicks()-tmp;
if(elapsed > 10000)
{
//On accélere les fantomes
speed_up(ftm, 1);
tmp=SDL_GetTicks();
}
UpdateEvents(&in);
if(in.quit) //Si clique sur croix
{
delete(&pac, ftm);
exit(EXIT_SUCCESS);
}
while(in.key[SDLK_ESCAPE])
{
selection=game_menu();
if(selection==0) in.key[SDLK_ESCAPE]=0;
else if(selection==2) //Retour menu principal
{
delete(&pac, ftm);
return;
}
}
jouer(&pac, ftm, in, cfg, level, &msg_list);
}
counter = SDL_GetTicks() - counter;
fprintf(stderr, "Wouaw tu as tenu %d ms!\n", counter);
if(pacmanIsHuman(cfg)) draw_result("data/survivor.txt", counter);
delete(&pac, ftm);
}
/*Permet de jouer un seul niveau
* choisi dans la liste des niveaux
* disponibles*/
void one_level(int level, config *cfg)
{
if(level>=NB_LEVEL) return;
int selection;
SAVE_ENABLE=0;
play_menu(level);
Pacman pac;
Fantome ftm[NB_MAX_GHOSTS];
score_message *msg_list = NULL;
Input in;
init_pacman(&pac, cfg);
init_level();
init_blocks();
load_level(level);
pac_restart(&pac);
init_ghosts(ftm, cfg);
memset(&in,0,sizeof(in));
DELAY = 40-level;
while(POINTS) //Tant que l'on a pas mangé toutes les pac-gommes
{
UpdateEvents(&in);
if(in.quit) //Si clique sur croix
{
delete(&pac, ftm);
exit(EXIT_SUCCESS);
}
while(in.key[SDLK_ESCAPE])
{
selection=game_menu();
if(selection==0) in.key[SDLK_ESCAPE]=0;
else if(selection==2) //Retour menu principal
{
delete(&pac, ftm);
return;
}
}
if (in.key[SDLK_w]) POINTS=0; //cheat code for winning!!
else if (in.key[SDLK_l] || !(pac.nb_lives)) //cheat code for loosing!!
{
lost_menu();
delete(&pac, ftm);
if(pacmanIsHuman(cfg)) draw_result("data/results.txt", pac.score);
return;
}
jouer(&pac, ftm, in, cfg, level, &msg_list);
}
win_menu();
if(pacmanIsHuman(cfg)) draw_result("data/results.txt", pac.score);
delete(&pac, ftm);
}
void menu (void) {
SDL_Surface *ecran=NULL, *fond=NULL;
SDL_Rect positionFond;
ecran = SDL_SetVideoMode(840,680, 32,SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE ); // resolution a revoir
SDL_Event evente;
positionFond.x=0;
positionFond.y=0;
fond = IMG_Load("Images/menu.png");
while (!globall.finn)
{
while(SDL_PollEvent(&evente)){
switch(evente.type)
{
case SDL_QUIT:
globall.finn=1;
break;
case SDL_MOUSEBUTTONUP:
if (evente.button.button == SDL_BUTTON_LEFT){
if (evente.button.x >= 335 && evente.button.x <= 454 && evente.button.y >= 179 && evente.button.y <= 205){
jouer();
break;
}
if (evente.button.x >= 335 && evente.button.x <= 454 && evente.button.y >= 266 && evente.button.y <= 290){
menuscore();
break;
}
if (evente.button.x >= 324 && evente.button.x <= 469 && evente.button.y >= 338 && evente.button.y <= 364){
menuoption();
break;
}
}
break;
default:break;
}
}
SDL_BlitSurface(fond, NULL, ecran, &positionFond);
SDL_Flip(ecran);
}
SDL_FreeSurface(fond);
}
int main(){
int continuer = 1;
Character character[2];
int i;
int choix;
for(i =0;i<2;i++){
character[i] = malloc(sizeof(struct character));
}
while(continuer){
printf("-----------------------Menu----------------------\n");
printf("1- Se connecter à un serveur\n");
printf("2- Quitter\n");
while(choix != 1 && choix != 2){
scanf("%d",&choix);
switch(choix){
case 1:
if(jouer(character) == 1) {
printf("Fin de la partie, vous avez gagné !");
}
else {
printf("Fin de la partie, vous avez perdu !");
}
choix = 3;
continuer = 0;
break;
case 2:
system("clear");
printf("Merci d'avoir participé, à bientot\n");
continuer = 0;
break;
case 3:
return 0;
break;
default:
printf("Commande invalide");
break;
}
}
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
SDL_Surface *ecran=NULL, *menu=NULL;
SDL_Rect positionMenu;
SDL_Event event;
int continuer=1;
initialisationSDL(&ecran);
chargementMenu(&menu, &positionMenu);
while(continuer) {
SDL_WaitEvent(&event);
switch(event.type) {
case SDL_QUIT:
continuer=0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_ESCAPE:
continuer=0;
break;
case SDLK_j:
jouer(ecran);
break;
case SDLK_h:
histoire(ecran);
break;
case SDLK_c:
credits(ecran);
break;
default:
break;
}
break;
}
affichageMenu(ecran, menu, positionMenu);
}
fermetureSDL(ecran, menu);
return EXIT_SUCCESS;
}
void jouer_ui(jeu_s jeu, aff_s aff)
{
coup_s c;
int erreur=0;
int x, y;
while(!is_end(jeu))
{
maj_affichage(jeu, aff);
if (jeu->participant[jeu->g->joueur].is_ai)
c = choix_coup_ai(jeu);
else
c = saisir_coups(jeu, aff);
erreur = jouer(jeu, c);
if(!erreur == 0)
{
char buf[256];
snprintf(buf, sizeof buf, "%s %d|%d -> %d|%d", error[erreur-1],
c->source[ORD], c->source[ABS], c->destination[ORD], c->destination[ABS]);
afficher_message(aff, buf);
}
else
{
clear_message(aff);
}
}
clear();
getmaxyx(stdscr, y, x);
attron(A_BOLD | A_REVERSE);
keypad(stdscr, FALSE);
if (jeu->participant[TIGRE].score == 7)
mvprintw((y/2), (x/2)-23, "Les tigres ont gagnés !");
else
mvprintw((y/2), (x/2)-24, "Les chèvres ont gagnés !");
getch();
}
/**
* \fn void jouer()
* \brief Launch the game
*
* \author Dzik Timothee
* \return
*/
void jouer(){
char *token;
char userAnswer[40]="", secondAnswer[40]="",result[40]="";
char rep[300]="";
printf("COUCOUC\n");
strcpy(rep, creation_message("question|"));
token = strtok(rep, "|");
printf("Question : %s\n", token);
token = strtok(NULL,"|");
printf(" %s \n", token);
token = strtok(NULL,"|");
printf("Your answer ?\n");
scanf("%s", userAnswer); fflush(stdin);
printf("bonne reponse token0 :%c\n", token[0]);
printf("user rep :%s\n", userAnswer);
if(token[0] == userAnswer[0]){
printf("Bonne reponse\n");
strcat(result, "win|");
strcat(result, pseudo);
printf("%s\n", creation_message(result));
}
else{
printf("Mauvaise reponse\n");
strcat(result, "loose|");
strcat(result, pseudo);
printf("%s\n", creation_message(result));
}
printf("Autre question ? (o/n) \n");
scanf("%s", secondAnswer); fflush(stdin);
if(strcmp(secondAnswer, "o") == 0) {
jouer();
}
}
//Cette fonction est appelée s'il y a coup fourré.
void coup_fourre(Tptpartie partie, int obstacle, int botte, char* raison_refus, char* raison_refus2)
{
Tptcarte carte_piochee = NULL;
partie -> autre_joueur -> nb_coups_fourres_joues++;
printf("\n\nCOUP FOURRÉ !\n");
printf("'%s', vous venez de jouer une carte '", partie -> joueur_selectionne -> nom);
cartes_type2francais(obstacle);
printf("', mais '%s' détient la carte botte '", partie -> autre_joueur -> nom);
cartes_type2francais(botte);
printf("' dans son jeu et il se trouve qu'il a déclaré « coup fourré ».\n");
printf(" Votre coup n'a donc aucun effet. ");
printf("'%s' joue sa carte '", partie -> autre_joueur -> nom);
cartes_type2francais(botte);
printf("', il a donc cinq cartes et va en piocher deux.\n");
/* On inverse le tour. L'adversaire devient le joueur sélectionné maintenant
(ceci est obligatoire pour que l'appel à la fonction jouer fasse jouer le bon joueur).*/
switch_tour(partie);
//On fait jouer au joueur sa carte botte.
if(jouer(partie, botte, 0, raison_refus, raison_refus2) != 1)
printf("Erreur à la fonction jouer pour le coup fourré. :/\n");
//On fait piocher une carte au joueur, pour qu'il ait à nouveau six cartes
if(partie -> joueur_selectionne -> deck -> taille > 0)
{
carte_piochee = cartes_changer_deck(partie -> deck, partie -> deck -> premier, partie -> joueur_selectionne -> deck);
printf("'%s' vient de piocher une carte '", partie -> joueur_selectionne -> nom);
cartes_type2francais(carte_piochee -> valeur); //On affiche le nom de la carte en français
printf("'.\n\n");
}
//On réinverse les deux deux joueurs, car ils vont être réinversés par la fonction jeu après la fin de cette fonction !
switch_tour(partie);
}
/**
* \fn void lancerMenu()
* \brief Menu
*
* \author Dzik Timothee
*
* \return
*/
void lancerMenu() {
printf("%s\n", pseudo);
int choix = 0;
while (choix != 5) {
printf("Que voulez vous faire ?\n 1- Voir mon profil\n 2- Mon score\n 3- Best Score ! \n4- Jouer !\n5- Quitter\n");
scanf("%d", &choix); fflush(stdin);
switch (choix) {
case 1:
myProfile(pseudo);
break;
case 2:
score_joueur(pseudo);
break;
case 3:
bestScore();
break;
case 4:
jouer();
break;
default:
break;
}
}
}
int jouer(SDL_Surface *ecran, SDL_Rect tab[], Partie *partie, Phase *phase, bool tab_joueur[]) {
mise_a_jour_phase_actuel(ecran, phase->phase);
int mise_en_cours[2] = {0, 0};
int miseur = partie->nb_tours % 4;
int mise;
int compteur = 0;
bool joueur_dispo = true;
if (tab_joueur[0] + tab_joueur[1] + tab_joueur[2] + tab_joueur[3] == 0 && phase->phase == 2) {//Aucun joueur
phase->gagnant = NOJOUEUR;
phase->mise = 0;
mise_en_cours[0] = -4;
joueur_dispo = false;
}
if (tab_joueur[0] + tab_joueur[1] + tab_joueur[2] + tab_joueur[3] == 0 && phase->phase == 3) {//Aucun joueur donc faux jeu
for (int i = 0; i < 4; i++) {
tab_joueur[i] = true;
}
phase->phase = FAUXJEU;
return jouer(ecran, tab, partie, phase, tab_joueur);
}
if (tab_joueur[0] + tab_joueur[1] + tab_joueur[2] + tab_joueur[3] == 1) { //1 joueur
if (tab_joueur[0] || tab_joueur[2]) {
phase->gagnant = 0;
phase->mise = 0;
}
if (tab_joueur[1] || tab_joueur[3]) {
phase->gagnant = 1;
phase->mise = 0;
}
mise_en_cours[0] = -4;
joueur_dispo = false;
}
if (tab_joueur[0] + tab_joueur[1] + tab_joueur[2] + tab_joueur[3] == 2) {
if (tab_joueur[0] + tab_joueur[2] == 2) {
phase->gagnant = 0;
phase->mise = 0;
mise_en_cours[0] = -4;
joueur_dispo = false;
}
if (tab_joueur[1] + tab_joueur[3] == 2) {
phase->gagnant = 1;
phase->mise = 0;
mise_en_cours[0] = -4;
joueur_dispo = false;
}
}
while (joueur_dispo && !est_fini_tour(mise_en_cours) && !(mise_en_cours[1] == 0 && miseur == partie->nb_tours % 4 && compteur != 0)) {
if (tab_joueur[miseur] == 1) {
mise = graphique_phase_de_mise(ecran, tab, partie, mise_en_cours[1], miseur);
if (mise > 1) { //le joueur surenchérit
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = mise;
}
else {
if (mise == -3) { //le joueur fait idoki
if (tab_joueur[ (miseur + 2) % 4 ] == 1) {
mise = graphique_phase_de_mise(ecran, tab, partie, mise_en_cours[1], (miseur + 2) % 4); //on demande à son collègue
if (mise == -3) { //son collègue veut aussi idoki
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = -3;
}
else { //son collègue veut surenchérir ou hordago
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = mise;
}
}
else {
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = -3;
}
}
else {
if (mise == 1) { //le joueur veut tira
if (tab_joueur[ (miseur + 2) % 4 ] == 1) {
mise = graphique_phase_de_mise(ecran, tab, partie, mise_en_cours[1], (miseur + 2) % 4); //on demande à son collègue
if (mise == 1) { //son collègue veut aussi tira
if (mise_en_cours[0] == 0) {
mise_en_cours[0] = 1;
mise_en_cours[1] = 1;
}
mise_en_cours[1] = mise;
}
else {
if (mise == -3) { //son collègue veut idoki
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = -3;
}
else if (mise == -2) { //son collègue veut kanta
mise_en_cours[1] = mise;
return 1;
}
else { //son collègue surenchérit ou hordago
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = mise;
}
}
}
else {
if (mise_en_cours[0] == 0) {
mise_en_cours[0] = 1;
mise_en_cours[1] = 1;
}
mise_en_cours[1] = mise;
}
}
else {
if (mise == -1) { //le joueur veut hordago
mise_en_cours[0] += mise_en_cours[1];
mise_en_cours[1] = mise;
}
else {
if (mise == -2) { //le joueur veut kanta
mise_en_cours[1] = mise;
return 1;
}
}
}
}
}
}
if (mise > 1) {
if (tab_joueur[(miseur + 1) % 4] == false)
miseur = (miseur + 3) % 4;
else
miseur = (miseur + 1) % 4;
}
else {
miseur = (miseur + 1) % 4;
}
compteur ++;
}
compte_point_phase(partie, phase, mise_en_cours, miseur);
mise_a_jour_phase_score(ecran, *phase);
graphique_mise_a_jour_score(ecran, partie);
return 0;
}
int main()
{
system("TITLE Pendu");
// ================== VARIABLES ========================= //
int i = 0, mot_correct, nb_mot = 0, choix;
char *pt_nb_mot = &nb_mot;
char mot_saisie[100];
char reponse;
char *mot = mot_saisie;
// ================== INSTRUCTIONS ========================= //
nbMot(pt_nb_mot);
printf("Pendu\n");
do
{
printf("\n\n+---------------------------------+");
printf("\n| Mode 1 joueur | taper 1 |");
printf("\n+---------------------------------+");
printf("\n| Mode 2 joueur | taper 2 |");
printf("\n+---------------------------------+");
printf("\n| Editer Dictionnaire | taper 3 |");
printf("\n+---------------------------------+");
printf("\n| Quitter | taper 0 |");
printf("\n+---------------------------------+\n");
printf("\nVotre choix : ");
scanf("%d", &choix);
fflush(stdin);
switch (choix)
{
case 1:
choisirUnMot(pt_nb_mot, mot);
system("cls");
jouer(mot);
break;
case 2:
do
{
printf("\n\nQuel est le mot a faire deviner ? ");
scanf("%s", mot_saisie);
fflush(stdin);
mot = &mot_saisie[0];
strcpy(mot, mot_saisie);
mot_correct = verifMot(mot); // On vérifie que le mot est correct (que des lettres minuscules ou majuscules et rien d'autre)
} while (mot_correct != 1);
system("cls");
jouer(mot);
break;
case 3:
menuEditerDictionnaire(pt_nb_mot);
break;
default :
printf("\n\nMauvaise touche ! Veuillez taper 0, 1, 2 ou 3\n");
break;
}
} while (choix != 0);
return 0;
}
/**
* \fn void Lancer_Jeu()
* \brief fonction qui permet de lancer et enregistrer la partie dans un fichier .
*/
void Lancer_Jeu()
{
Pion grille[N][M];
FILE * fichier; /*fichier de sauvegarde nom des joueurs et resultats partie !*/
fichier=fopen("resultats.txt","a+");
int joueur,j=0, colonne, compteur=0,rep=0,score, total,choix;
char pion;
printf("\n");
initialiser_grille(grille);
afficher_grille(grille);
printf(" \n Bienvenue dans le mode jeu puissance 4++ \n ");
do
{
printf("\n Combien de joueurs vont jouer ? (maximum 4) : ");
scanf("%i",&joueur);
}while(joueur<2 || joueur>MAX_JOUEUR);
printf(" \33[31m /! Pour rappel, un systeme d'aide a était mit en place, si vous demandez de l'aide \n");
printf(" alors que tous vos pions sont encerclés, ou aucun de vos pion n'est placé, \n");
printf(" vous serez alors pénalisé, votre tour sautera ! Bonne Partie ! / \33[30m \n");
while (compteur !=42) //tant que la grille n est pas remplie
{
j=joueursuivant(j,joueur);
printf("\n\n\t\t==============## Joueur \33[31m %i\33[30m ##================\n\n",j);
do{
printf("Tapez 1 si vous avez besoin d'aide sinon Tapez 2 : ");
scanf("%i",&choix);
}while(choix!=1 && choix!=2);
switch(choix){
case 1:
Help_Me(j,grille);
afficher_grille(grille);
rep=victoire(j,grille);
if (rep==1)
{
printf("\n Le joueur %i a gagné ! \n", j);
fprintf(fichier,"%i %i %i \n",j,1,1);
};
break;
case 2:
printf("Dans quelle colonne voulez-vous jouez et quel type de pièce? \n Pleine (p), Creuse (c), Bloquante (b) ");
scanf("%i%c",&colonne,&pion);
while (colonne>M || colonne<1 ||( pion !='b' && pion !='c'&& pion!='p')) /*cas erreur*/
{
printf("veuillez ressaisir le numero de la colonne (entre 1 et 7) et le type de la pièce ");
scanf("%i%c",&colonne,&pion);
}
if (colonne_pleine(pion,colonne,grille))//on regarde si la colonne est pleine
{
printf("La colonne est pleine, ressaisissez la colonne et le type de piece ");
scanf("%i%c",&colonne,&pion);
}
jouer(grille,colonne,pion,j) ;
rep=victoire(j,grille);
afficher_grille(grille);
compteur++;
if (rep==1){
printf("\n Le joueur %i a gagné ! \n", j);
fprintf(fichier,"%i %i %i \n",j,1,1);
};
break;
}
}
if (compteur ==42){ // si la grille est remplie
printf(" Match nul, la grille est remplie sans detection de victoire \n ");
for(j=1;j<5;j++){
fprintf(fichier,"%i %i %i \n",j,0,0);
}
}else{
switch(j){
case 1:fprintf(fichier,"%i %i %i \n",2,0,0);fprintf(fichier,"%i %i %i \n",3,0,0);fprintf(fichier,"%i %i %i \n",4,0,0);break;
case 2:fprintf(fichier,"%i %i %i \n",1,0,0);fprintf(fichier,"%i %i %i \n",3,0,0);fprintf(fichier,"%i %i %i \n",4,0,0);break;
case 3:fprintf(fichier,"%i %i %i \n",1,0,0);fprintf(fichier,"%i %i %i \n",2,0,0);fprintf(fichier,"%i %i %i \n",4,0,0);break;
case 4:fprintf(fichier,"%i %i %i \n",1,0,0);fprintf(fichier,"%i %i %i \n",2,0,0);fprintf(fichier,"%i %i %i \n",2,0,0);break;
}
}
rewind(fichier);/*met le pointeur du fichier au debut*/
while(!feof(fichier))
{
fscanf(fichier,"%i",&j);// afficher les joueurs et leur score mis a jour a voir
fscanf(fichier,"%i",&score);
fscanf(fichier,"%i",&total);
printf ("joueur %i : score %i total %i \n",j,score,total);
break;
}
fclose(fichier);
}
int main(int argc, char *argv[])
{ SDL_Surface *ico =NULL ;
SDL_Surface *ecran = NULL, *Menu = NULL, *Background = NULL;
SDL_Rect positionBackground, positionMenu;
SDL_Event event;
//Initialisation de l'API Mixer
if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 1024) == -1) //Initialisation de l'API Mixer
{ printf("Probleme de chargement audio: %s\n", Mix_GetError());
SDL_Quit();
}
int continuer = 1;
// lecture des images
ico = IMG_Load("images/ico.png"); Background = IMG_Load("images/backgroud.jpg"); Menu = IMG_Load("images/menu.png");
if( ( ico == NULL ) || ( Background == NULL ) || ( Menu == NULL ) ){
printf("Probleme de chargement ressourse: %s\n", SDL_GetError());
SDL_Quit(); }
if( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)== -1 ){
printf( "Echec lors du chargement de la video : %s", SDL_GetError() );
SDL_Quit();
}
SDL_WM_SetIcon(ico, NULL); // L'icone doit etre chargee avant SDL_SetVideoMode
ecran = SDL_SetVideoMode(LARGEUR_FENETRE, HAUTEUR_FENETRE, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Tetris Clone", NULL);
SDL_ShowCursor(SDL_DISABLE);
positionBackground.x = 0;
positionBackground.y = 0;
// pas besoin car png et SDL_image.h
/* SDL_SetColorKey(Menu, SDL_SRCCOLORKEY, SDL_MapRGB(Menu->format, 0,0,0)); */
positionMenu.x = 30;
positionMenu.y = 180;
while (continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE: // Veut sortir
continuer = 0;
break;
case SDLK_j: // Demande à jouer
jouer(ecran);
break;
}
break;
}
// Effacement de l'ecran puis affichage
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
SDL_BlitSurface(Background, NULL, ecran, &positionBackground);
SDL_BlitSurface(Menu, NULL, ecran, &positionMenu);
SDL_Flip(ecran);
}
// Libération des surfaces chargées et de l audio
SDL_FreeSurface(Menu);
SDL_FreeSurface(Background);
SDL_FreeSurface(ecran);
Mix_CloseAudio();
SDL_Quit();
return EXIT_SUCCESS;
}
int main(int argc, char** argv){
char* outPl[NB_PLAYER] = {NULL, NULL}; // Les sorties pour chaque joueur
linkedlist_t listResp = NULL;
int pipeW;
int J1 = 0;
int J2 = 1;
int i;
int jGagne = -1;
int jPerdu;
int plein = 0;
int choix;
char caract[NB_PLAYER];
caract[0] = 'X';
caract[1] = 'O';
char plateau[HAUTEUR][LARGEUR];
if(argc >= 1){
pipeW = atoi(argv[0]);
}
else{
perror("Erreur, arguments incorrects.\n");
exit(EXIT_FAILURE);
}
init_plateau(plateau);
while(jGagne == -1 && !plein){
for(i=0; i < NB_PLAYER; i++){
systemc(&outPl[J1], "clear");
outc(&outPl[J1], "%s", "======= Morpion =======\n\n");
dessinerPlateau(&outPl[J1], plateau);
outc(&outPl[J1], "%s", "Entrez un numero de case (1, 2, ...) : ");
inc(&outPl[J1], "%d");
systemc(&outPl[J2], "clear");
outc(&outPl[J2], "%s", "======= Morpion =======\n\n");
dessinerPlateau(&outPl[J2], plateau);
outc(&outPl[J2], "%s", "C'est a votre adversaire de jouer.\n");
flushc(pipeW, outPl, NB_PLAYER);
choix = (int)getResp(&listResp, INT);
if(jouer(plateau, choix, caract[J1])){
if(gagner(plateau, caract[J1])){
jGagne = J1;
break;
}
if(estPlein(plateau)){
plein = 1;
break;
}
}
reversePlayer(&J1, &J2);
}
}
systemc(&outPl[J1], "clear");
systemc(&outPl[J2], "clear");
if(!plein && jGagne != -1){
jPerdu = nextPlayer(jGagne);
outc(&outPl[jGagne], "%s", "======= Morpion =======\n\n");
outc(&outPl[jGagne], "%s", "Vous avez gagne, felicitation !!\n");
outc(&outPl[jPerdu], "%s", "======= Morpion =======\n\n");
outc(&outPl[jPerdu], "%s", "Vous avez perdu, votre adversaire etait peut etre plus intelligent...\n");
}
else{
outc(&outPl[J1], "%s", "======= Morpion =======\n\n");
outc(&outPl[J1], "%s", "Vous etes aussi fort (ou mauvais) que votre adversaire...\n");
outc(&outPl[J2], "%s", "======= Morpion =======\n\n");
outc(&outPl[J2], "%s", "Vous etes aussi fort (ou mauvais) que votre adversaire...\n");
}
flushc(pipeW, outPl, NB_PLAYER);
// On attend un peut avant de quitter
waitc(&outPl[J1], 3);
waitc(&outPl[J2], 3);
quitc(&outPl[J1]); // Fermera le jeu pour le client
quitc(&outPl[J2]);
flushc(pipeW, outPl, NB_PLAYER);
quit(pipeW);
close(pipeW);
close_out_players(outPl, NB_PLAYER);
return EXIT_SUCCESS;
}
/*Permet de jouer tout les niveaux
* à la suite*/
void campagne(config *cfg, int cmp_level)
{
int selection=0, level;
SAVE_ENABLE=1;
Pacman pac;
Fantome ftm[NB_MAX_GHOSTS];
score_message *msg_list = NULL;
Input in;
init_pacman(&pac, cfg);
init_blocks();
memset(&in,0,sizeof(in));
while(cmp_level < CAMPAGNE_LEVEL)
{
level=0;
while(strcmp(LEVEL_FILE[level], CAMPAGNE[cmp_level]) && level < NB_LEVEL)
{
level++;
}
DELAY = 40-cmp_level;
play_menu(cmp_level);
init_level();
load_level(level);
pac_restart(&pac);
init_ghosts(ftm, cfg);
while(POINTS) //Tant que l'on a pas mangé toutes les pac-gommes
{
UpdateEvents(&in);
if(in.quit) //Si clique sur croix
{
delete(&pac, ftm);
exit(EXIT_SUCCESS);
}
while(in.key[SDLK_ESCAPE])
{
selection=game_menu();
if(selection==0) in.key[SDLK_ESCAPE]=0;
else if(selection==1) save_game(cmp_level);
else if(selection==2) //Retour menu principal
{
delete(&pac, ftm);
return;
}
}
if (in.key[SDLK_w])
{
in.key[SDLK_w]=0;
POINTS=0; //cheat code for winning!!
}
else if (in.key[SDLK_l] || !(pac.nb_lives)) //cheat code for loosing!!
{
lost_menu();
draw_result("data/results.txt", pac.score);
delete(&pac, ftm);
return;
}
jouer(&pac, ftm, in, cfg, cmp_level, &msg_list);
}
cmp_level++;
win_menu();
}
draw_result("data/results.txt", pac.score);
delete(&pac, ftm);
}
int main() {
if(-1 == SDL_Init(SDL_INIT_VIDEO)) {
std::cerr << "Unable to initialize SDL" << std::endl;
return EXIT_FAILURE;
}
if(NULL == SDL_SetVideoMode(WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BPP, SDL_OPENGL)) {
std::cerr << "Unable to open the window and get an OpenGL context" << std::endl;
return EXIT_FAILURE;
}
SDL_WM_SetCaption("OpenGL4Imacs", NULL);
GLenum glewCode = glewInit();
if(GLEW_OK != glewCode) {
std::cerr << "Unable to initialize GLEW : " << glewGetErrorString(glewCode) << std::endl;
return EXIT_FAILURE;
}
Button2D jouer(-1,-1,0.5,0.2);
// Initialisation VBO
glimac::LowLevelVBO vbo(jouer.getVertices(), 8 * sizeof(GLfloat), GL_STATIC_DRAW, GL_ARRAY_BUFFER);
// Initialisation VAO
glimac::VAO vao;
// Binder le vao
vao.bind();
glEnableVertexAttribArray(0);
// Binder le vbo
vbo.bind();
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (const GLvoid*) (0 * sizeof(GLfloat)));
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Debinder le vao
glBindVertexArray(0);
bool done = false;
while(!done) {
Uint32 tStart = SDL_GetTicks();
// Rendering code goes here
glClear(GL_COLOR_BUFFER_BIT);
vao.bind();
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
// Application code goes here
SDL_Event e;
while(SDL_PollEvent(&e)) {
switch(e.type) {
default:
break;
case SDL_QUIT:
done = true;
break;
}
}
// Mise à jour de la fenêtre (synchronisation implicite avec OpenGL)
SDL_GL_SwapBuffers();
Uint32 tEnd = SDL_GetTicks();
Uint32 d = tEnd - tStart;
if(d < FRAME_DURATION) {
SDL_Delay(FRAME_DURATION - d);
}
}
// Destruction des ressources
SDL_Quit();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
freopen("CON", "w", stdout); //commandes pour afficher dans la console
freopen("CON", "r", stdin);
freopen("CON", "w", stderr);
SDL_Surface *ecran = NULL;
SDL_Event event;
int continuerMain = 1;
SDL_Init(SDL_INIT_EVERYTHING); //initialisation de la SDL
//SDL_WM_SetIcon(SDL_LoadBMP("icone.bmp"), NULL); // chargement de l'icone de fenêtre
ecran = SDL_SetVideoMode(1340 , 670, 32, SDL_HWSURFACE | SDL_DOUBLEBUF); //Chargement de la fenetre et ses options
SDL_WM_SetCaption("zombie project", NULL); //changement du nom de la fenêtre
/*while (continuerMain) //boucle principale
{
SDL_WaitEvent(&event); //boucle event de main.c
switch(event.type)
{
case SDL_QUIT:
continuerMain = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuerMain = 0;
break;
case SDLK_UP:
jouer(ecran); //lancer le jeu
break;
default:
break;
}
}
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
SDL_Flip(ecran);
}*/
while (continuerMain) //boucle principale
{
SDL_WaitEvent(&event); //boucle event de main.c
switch(event.type)
{
case SDL_QUIT:
continuerMain = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
continuerMain = 0;
break;
case SDLK_UP:
jouer(ecran); //lancer le jeu
break;
default:
break;
}
}
SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 255, 255, 255));
SDL_Flip(ecran);
}
SDL_Quit();
return 0;
}
//Cette fonction est la fonction globale qui gère une partie (reprise en cours ou nouvellement commencée).
//Grâce aux paramètres joueur_selectionne et autre_joueur, on sait à qui c'est de jouer.
void jeu(Tptpartie partie)
{
int partie_est_terminee = partie_terminee(partie);
int choix_carte = -1, choix_jeter = -1;
int resultat_jouer = -1, resultat_jouer_passer_tour = -1;
char nomFichier[TAILLE_MAX_NOM_FICHIER];
char raison_refus[TAILLE_MAX_REFUS] = "";
char raison_refus2[TAILLE_MAX_REFUS] = "";
Tptjoueur gagnant = NULL;
Tptcarte carte_piochee = NULL;
Tptdeck les_coups_possibles = NULL;
while(!partie_est_terminee && choix_carte != ARRETER_PARTIE && choix_carte != ENREGISTRER)
{
choix_carte = -1;
choix_jeter = -1;
printf("\nIl reste %d cartes dans le deck principal.\n", partie -> deck -> taille);
printf("\nC'est à '%s' de jouer.\n", partie -> joueur_selectionne -> nom);
if(partie -> deck -> taille > 0)
{
//On fait piocher une carte au joueur
carte_piochee = cartes_changer_deck(partie -> deck, partie -> deck -> premier, partie -> joueur_selectionne -> deck);
//On affiche la carte que le joueur vient de piocher que si ça n'est pas un ordinateur
if(!partie -> joueur_selectionne -> est_ordinateur)
{
printf("'%s' vient de piocher une carte '", partie -> joueur_selectionne -> nom);
cartes_type2francais(carte_piochee -> valeur); //On affiche le nom de la carte en français
printf("'.\n");
demander_appuyez_sur_une_touche_pour_continuer();
}
else
{
printf("'%s' vient de piocher une carte.\n", partie -> joueur_selectionne -> nom);
}
}
//On n'affiche les infos que si le joueur n'est pas un ordinateur.
if(!partie -> joueur_selectionne -> est_ordinateur)
{
printf("\nÉTAT DE VOTRE ADVERSAIRE :");
joueur_afficher_infos_utiles(partie -> autre_joueur);
demander_appuyez_sur_une_touche_pour_continuer();
printf("\nVOTRE ÉTAT :");
joueur_afficher_infos_utiles(partie -> joueur_selectionne);
demander_appuyez_sur_une_touche_pour_continuer();
//Affiche la main du joueur
printf("\nVOTRE MAIN :\n");
printf("Vous avez %d cartes en main : \n", partie -> joueur_selectionne -> deck -> taille);
cartes_deck_afficher(partie -> joueur_selectionne -> deck);
printf("\n");
demander_appuyez_sur_une_touche_pour_continuer();
les_coups_possibles = lister_coups_possibles(partie -> joueur_selectionne, partie -> autre_joueur);
printf("\nIl y a %d COUPS POSSIBLES :\n", les_coups_possibles -> taille);
cartes_deck_afficher(les_coups_possibles);
printf("\n");
}
//Demande au joueur de choisir une carte à jouer (si c'est un humain seulement)
if(!partie -> joueur_selectionne -> est_ordinateur)
{
resultat_jouer = -1;
while(resultat_jouer != 1)
{
menu_demander_choix_carte(&choix_carte, les_coups_possibles -> taille);
if(choix_carte != ARRETER_PARTIE && choix_carte != ENREGISTRER)
{
if(choix_carte != PASSER_SON_TOUR)
{
//Appel de la fonction jouer
resultat_jouer = jouer(partie, choix_carte, 0, raison_refus, raison_refus2);
switch(resultat_jouer)
{
case ERREUR_COUP_NON_PERMIS:
printf("\nCe coup n'est pas permis ! Voici une explication : \n\n");
if(strlen(raison_refus) > 0)
{
printf("%s", raison_refus);
if(strlen(raison_refus2) > 0)
printf("%s", raison_refus2);
}
memset (raison_refus, 0, sizeof (raison_refus));
memset (raison_refus2, 0, sizeof (raison_refus2));
printf("\n\nVeuillez choisir une autre carte.\n\n");
break;
case ERREUR_CARTE_PAS_DANS_MAIN:
printf("\nErreur, carte invalide. Soit ce type de carte n'existe pas, soit vous n'avez pas de carte de ce type dans votre main.\n");
printf("Merci de choisir une carte valide.\n\n");
break;
}
}
else
{
resultat_jouer_passer_tour = -1;
while(resultat_jouer_passer_tour != 1)
{
menu_demander_choix_carte_jeter(&choix_jeter);
if(choix_jeter != ANNULER_PASSER_SON_TOUR)
{
resultat_jouer_passer_tour = jouer(partie, choix_jeter, 1, raison_refus, raison_refus2);
if(resultat_jouer_passer_tour == ERREUR_CARTE_PAS_DANS_MAIN)
{
printf("\nErreur, carte invalide. Soit ce type de carte n'existe pas, soit vous n'avez pas de carte de ce type dans votre main.\n");
printf("Merci de choisir une carte valide.\n\n");
}
}
else
resultat_jouer_passer_tour = 1;
}
if(choix_jeter != ANNULER_PASSER_SON_TOUR)
{
printf("'%s' passe son tour et jette une carte.\n", partie -> joueur_selectionne -> nom);
resultat_jouer = 1;
}
else if(les_coups_possibles -> taille > 0)
{
choix_jeter = -1;
printf("\nVous avez changé d'avis et ne souhaitez plus passer votre tour.\n");
printf("Vous allez être réinvité à sélectionner la carte que vous désirez jouer.\n\n");
}
}
}
else
resultat_jouer = 1;
}
}
//C'est un ordinateur, on demande à l'IA de jouer
else
{
switch(partie -> joueur_selectionne -> difficulte_ordinateur)
{
case ARCHI_DEBUTANT:
ia_archi_debutant(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
case DEBUTANT:
ia_debutant(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
case COURSE:
ia_course(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
case AGRESSIF:
ia_agressif(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
case DEFENSIF:
ia_defensif(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
case EXPERT:
ia_expert(partie -> joueur_selectionne, partie -> autre_joueur, &choix_carte, &choix_jeter);
break;
default:
printf("Erreur, la difficulté de l'IA est invalide (jeu.c).");
exit(0);
}
if(DEBUG_IA)
{
printf("Voici sa main : \n");
cartes_deck_afficher(partie -> joueur_selectionne -> deck);
}
/* Le choix de la carte a été fait par l'ordinateur. On joue sa carte. */
if(choix_carte == PASSER_SON_TOUR)
{
resultat_jouer = jouer(partie, choix_jeter, 1, raison_refus, raison_refus2);
printf("\n'%s' passe son tour et jette une carte.\n", partie -> joueur_selectionne -> nom);
if(DEBUG_IA)
{
printf("La carte qu'il vient de JETER est : '");
cartes_type2francais(choix_jeter);
printf("'.\n");
}
demander_appuyez_sur_une_touche_pour_continuer();
}
else
resultat_jouer = jouer(partie, choix_carte, 0, raison_refus, raison_refus2);
if(resultat_jouer != 1)
{
printf("Erreur : l'ordinateur a choisi une carte qui n'est pas valide.\n");
printf("Code de l'erreur : %d. ", resultat_jouer);
printf("L'ordinateur avait essayé de jouer : '");
cartes_type2francais(choix_carte);
printf(" %d", choix_carte);
printf("'.\n");
exit(0);
}
}
if( choix_carte != ENREGISTRER && choix_carte != ARRETER_PARTIE
&& choix_jeter != ANNULER_PASSER_SON_TOUR && resultat_jouer == 1)
{
if(choix_carte != PASSER_SON_TOUR)
{
printf("\n'%s' vient de jouer une carte '", partie -> joueur_selectionne -> nom);
cartes_type2francais(choix_carte);
printf("'.\n");
demander_appuyez_sur_une_touche_pour_continuer();
}
//« Y a-t-il coup fourré ? »
if( choix_carte == PANNE_ESSENCE &&
partie -> autre_joueur -> en_panne_dessence &&
joueur_possede_carte(partie -> autre_joueur, CITERNE) != NULL)
{
menu_demander_coup_fourre(partie, PANNE_ESSENCE, CITERNE, raison_refus, raison_refus2);
}
else if(choix_carte == CREVE &&
partie -> autre_joueur -> est_creve &&
joueur_possede_carte(partie -> autre_joueur, INCREVABLE) != NULL)
{
menu_demander_coup_fourre(partie, CREVE, INCREVABLE, raison_refus, raison_refus2);
}
else if(choix_carte == ACCIDENT &&
partie -> autre_joueur -> a_accident &&
joueur_possede_carte(partie -> autre_joueur, AS_DU_VOLANT) != NULL)
{
menu_demander_coup_fourre(partie, ACCIDENT, AS_DU_VOLANT, raison_refus, raison_refus2);
}
else if(choix_carte == LIMITE_VITESSE &&
partie -> autre_joueur -> est_limite_par_vitesse &&
joueur_possede_carte(partie -> autre_joueur, PRIORITAIRE) != NULL)
{
menu_demander_coup_fourre(partie, LIMITE_VITESSE, PRIORITAIRE, raison_refus, raison_refus2);
}
else if(choix_carte == STOP &&
partie -> autre_joueur -> est_arrete &&
joueur_possede_carte(partie -> autre_joueur, PRIORITAIRE) != NULL)
{
menu_demander_coup_fourre(partie, STOP, PRIORITAIRE, raison_refus, raison_refus2);
}
/* Si le joueur vient de jouter une carte 'botte', il a le droit de rejouer
Il ne faut donc pas switcher les joueurs dans ce cas */
if(choix_carte >= CITERNE && choix_carte <= PRIORITAIRE)
{
printf("\n");
printfEx(COULEUR_BOTTES, "'%s' vient de jouer une carte 'botte', c'est donc encore une fois à lui de jouer !\n", partie -> joueur_selectionne -> nom);
}
else
switch_tour(partie);
partie_est_terminee = partie_terminee(partie);
}
}
//On souhaite enregistrer la partie pour la reprendre plus tard
if(choix_carte == ENREGISTRER)
{
//Le joueur vient de piocher une carte et en a sept. On annule sa pioche et on replace la carte dans le dessus du deck.
//Lorsqu'il reprendra la partie plus tard, il repiochera cette carte puisqu'elle sera restée au début du deck. :)
cartes_changer_deck(partie -> joueur_selectionne -> deck, carte_piochee, partie -> deck);
menu_enregistrer_partie(nomFichier);
if(enregistrer_partie(nomFichier, partie))
printf("La partie a été sauvegardée avec succès !\n");
else
printf("Une erreur est survenue lors de l'enregistrement de la partie.\n");
}
else if(choix_carte == ARRETER_PARTIE)
{
printf("On arrête la partie !\n");
}
//La partie est réellement terminée
else if(partie_est_terminee)
{
printf("\n\nPARTIE TERMINÉE !\n\n");
gagnant = detecter_gagnant(partie -> joueur_selectionne, partie -> autre_joueur);
if(gagnant != NULL)
printf("'%s' gagne la partie !", gagnant -> nom);
else
printf("Match nul, vous avez fait le même nombre de points !\n");
}
//Nettoyage de fin de partie.
partie_vider(partie);
}
int phase_de_jeu(SDL_Surface *ecran, Partie *partie, SDL_Rect carte_graphique[]) {
bool tab_joueur[4];
init_tab_joueur(tab_joueur);
if (jouer(ecran, carte_graphique, partie, &partie->phase[0], tab_joueur)) { //Hordago
if (meilleur_grand(partie) == 0) {
partie->score[0] = 40;
partie->manche[0] ++;
}
else {
partie->score[1] = 40;
partie->manche[1] ++;
}
return 1;
}
if (partie->score[0] >= 40) {
partie->score[0] = 40;
partie->manche[0] ++;
return 1;
}
if (partie->score[1] >= 40) {
partie->score[1] = 40;
partie->manche[1] ++;
return 1;
}
if (jouer(ecran, carte_graphique, partie, &partie->phase[1], tab_joueur)) { //Hordago
if (meilleur_petit(partie) == 0) {
partie->score[0] = 40;
partie->manche[0] ++;
}
else {
partie->score[1] = 40;
partie->manche[1] ++;
}
return 1;
}
if (partie->score[0] >= 40) {
partie->score[0] = 40;
partie->manche[0] ++;
return 1;
}
if (partie->score[1] >= 40) {
partie->score[1] = 40;
partie->manche[1] ++;
return 1;
}
tab_pair(partie, tab_joueur);
message_oui_non(ecran, partie, tab_joueur);
if (jouer(ecran, carte_graphique, partie, &partie->phase[2], tab_joueur)) { //Hordago
if (meilleur_pair(partie) == 0) {
partie->score[0] = 40;
partie->manche[0] ++;
}
else {
partie->score[1] = 40;
partie->manche[1] ++;
}
return 1;
}
if (partie->score[0] >= 40) {
partie->score[0] = 40;
partie->manche[0] ++;
return 1;
}
if (partie->score[1] >= 40) {
partie->score[1] = 40;
partie->manche[1] ++;
return 1;
}
tab_jeu(partie, tab_joueur);
message_oui_non(ecran, partie, tab_joueur);
if (jouer(ecran, carte_graphique, partie, &partie->phase[3], tab_joueur)) { //Hordago
if (partie->phase[3].phase == JEU) {
if (meilleur_jeu(partie) == 0) {
partie->score[0] = 40;
partie->manche[0] ++;
}
else {
partie->score[1] = 40;
partie->manche[1] ++;
}
}
else {
if (meilleur_fauxjeu(partie) == 0) {
partie->score[0] = 40;
partie->manche[0] ++;
}
else {
partie->score[1] = 40;
partie->manche[1] ++;
}
}
return 1;
}
if (partie->score[0] >= 40) {
partie->score[0] = 40;
partie->manche[0] ++;
return 1;
}
if (partie->score[1] >= 40) {
partie->score[1] = 40;
partie->manche[1] ++;
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
printf ("\nDemarage du programme\n");
// Declaration de variables.
SDL_Surface *ecran = NULL, *Fond = NULL, *titre = NULL, *texte1 = NULL, *texte2 = NULL, *texte3 = NULL, *texte4 = NULL;
SDL_Rect positionFond;
SDL_Rect positiontitre;
SDL_Rect positiontexte1;
SDL_Rect positiontexte2;
SDL_Rect positiontexte3;
SDL_Rect positiontexte4;
SDL_Event event;
positionFond.x = 0;
positionFond.y = 0;
TTF_Font *police = NULL, *police1 = NULL;
SDL_Color blanc = {255, 255, 255};
int continuer = 1;
int enpause = 0;
struct options options = {0};
// Fin de la declaration de variables
SDL_Init(SDL_INIT_VIDEO);
TTF_Init();
SDL_WM_SetCaption("CHESS", NULL);
SDL_WM_SetIcon(IMG_Load("img/icon.gif"), NULL);
ecran = SDL_SetVideoMode(400, 400, 32, SDL_HWSURFACE);
Fond = IMG_Load("img/background.png");
police = TTF_OpenFont("img/police.ttf", 15);
police1 = TTF_OpenFont("img/police.ttf", 50);
chargeroption (&options);
while (continuer)
{
SDL_BlitSurface(Fond, NULL, ecran, &positionFond);
if ( enpause == 0)
{
titre = TTF_RenderText_Blended(police1, "CHESS", blanc);
}
else if ( enpause == 1 )
{
titre = TTF_RenderText_Blended(police1, "PAUSE", blanc);
}
positiontitre.x = (( 400 - titre->w) / 2);
positiontitre.y = 20;
SDL_BlitSurface(titre, NULL, ecran, &positiontitre);
texte1 = TTF_RenderText_Blended(police, "[A] Nouvelle partie", blanc);
texte2 = TTF_RenderText_Blended(police, "[Z] Continuer", blanc);
texte3 = TTF_RenderText_Blended(police, "[E] Options", blanc);
texte4 = TTF_RenderText_Blended(police, "[R] Quitter", blanc);
positiontexte1.x = (( 400 - texte1->w) / 2);
positiontexte1.y = 100;
positiontexte2.x = positiontexte1.x;
positiontexte2.y = 150;
positiontexte3.x = positiontexte1.x;
positiontexte3.y = 200;
positiontexte4.x = positiontexte1.x;
positiontexte4.y = 250;
SDL_BlitSurface(texte1, NULL, ecran, &positiontexte1);
SDL_BlitSurface(texte2, NULL, ecran, &positiontexte2);
SDL_BlitSurface(texte3, NULL, ecran, &positiontexte3);
SDL_BlitSurface(texte4, NULL, ecran, &positiontexte4);
SDL_Flip(ecran);
SDL_WaitEvent(&event); // Récupèration de l'évènement dans event
switch(event.type) // Test du type d'évènement
{
case SDL_QUIT: // Si c'est un évènement de type "Quitter"
continuer = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE: // ECHAP
continuer = 0;
break;
case SDLK_SPACE: // (SPACE) ==> Jouer
if (options.o2 > 0) {printf ("\nLancement d'une nouvelle partie.\n"); }
jouer(ecran, options, &enpause, 0);
break;
case SDLK_o: //(O) ==> Options
option(ecran, &options);
break;
case SDLK_a: // (A) ==> Jouer
if (options.o2 > 0) {printf ("\nLancement d'une nouvelle partie.\n"); }
jouer(ecran, options, &enpause, 0);
break;
case SDLK_z: // (E) ==> Continuer
if (options.o2 > 0) {printf ("\nReprise d'une partie en cours.\n"); }
jouer(ecran, options, &enpause, 1);
break;
case SDLK_e: // (E) ==> Option
option(ecran, &options);
break;
case SDLK_r: //(R) ==> Quitter
if (options.o2 > 0) { printf ("\nFermeture du programme.\n"); }
continuer = 0;
break;
}
break;
}
}
SDL_FreeSurface(Fond);
SDL_Quit();
return EXIT_SUCCESS;
}
