/**
\fn : jeu
\brief : Cette fonction gère l'initialisation du jeu & son fonctionnement.
\param : ecran (la surface SDL activée précédemment)
**/
void jeu(SDL_Surface *ecran)
{
SDL_Event event;
SDL_Event event3;
/**
* Cet indice empêche le programme de quitter la boucle de jeu.
**/
int jeu_en_cours = PARTIE_EN_COURS;
/**
* Cet indice indique dans quelle position de l'écran le curseur se trouve. 9 positions sont possibles (indicées de 0 à 8 de gauche à droite, de haut en bas), c'est-à-dire les 3x3 cases visibles au centre de l'écran.
**/
int numero_tuile_curseur=0;
int curseur_visible = 4;
int curseur_pion_visible = 0;
int x_curseur = CURSEUR_DEBUT;
int y_curseur = CURSEUR_DEBUT;
int x_visible = CURSEUR_DEBUT;
int y_visible = CURSEUR_DEBUT;
int pioche_restante = 72;
struct tuile*** plateau_graphe = initialise_plateau(LARGEUR_PLATEAU);
struct tuile*** plateau_visible = initialise_plateau(LARGEUR_PLATEAU_VISIBLE);
struct pioche* pioche = init_pioche();
struct tuile* tuiles[NB_TUILES];
for (int i=0; i<NB_TUILES; i++)
{
tuiles[i]=NULL;
}
tuile_parseur(tuiles, "tuiles.txt");
int num_tuile_courante = update_pioche(pioche, tuiles);
struct tuile* tuile_initiale = NULL;
tuile_initiale = init_tuile();
dupliquer_tuiles(tuiles[14],tuile_initiale);
plateau_graphe[72][71] = tuile_initiale;
struct graphe_global* graphe_global = init_graphe_global(tuile_initiale);
int pions_possibles[9];
int pion_impossible = 0;
struct joueurs* joueurs = initialise_joueurs();
a_qui_le_tour(joueurs);
/**
* Cette variable vaut 1 lorsque la tuile actuelle ne peut être posée à la place actuelle du curseur.
**/
int statut_place = 0;
int statut_rotation = 0;
int phase_jeu = 0;
int pose_pion_result = EXIT_FAILURE;
calcul_visible(plateau_graphe, plateau_visible, x_curseur, y_curseur);
numero_tuile_curseur = pioche->tuile_pioche->image;
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
while(jeu_en_cours == PARTIE_EN_COURS)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
jeu_en_cours = QUITTER_PARTIE;
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
free_plateau(plateau_visible, LARGEUR_PLATEAU_VISIBLE);
free_plateau(plateau_graphe, LARGEUR_PLATEAU);
free_graphe_global(graphe_global);
free_pioche(pioche);
free_tuiles(tuiles);
free_joueurs(joueurs);
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_ESCAPE:
jeu_en_cours = 0;
break;
/**
*Lorsqu'une touche directionnelle est pressée, on vérifie en premier lieu que ce dernier ne va pas dépasser le bord du plateau de jeu; on peut alors modifier la coordonnée correspondante du curseur.
*Ensuite, si le curseur se trouve au bord de la zone dans laquelle il peut se déplacer, on modifie la coordonnée correspondante du repère de l'écran, de manière à déplacer l'écran vers une direction (ce qui revient dans SDL à déplacer toutes les tuiles dans l'autre !)
*Dans le cas contraire, on modifie seulement l'indice indiquant dans quelle "case" de l'écran visible le curseur se trouve.
**/
case SDLK_UP:
if (y_curseur!=1)
{
y_curseur--;
if (curseur_visible <= 2)
{
y_visible--;
calcul_visible(plateau_graphe, plateau_visible, x_visible, y_visible);
}
else
curseur_visible = curseur_visible - 3;
}
break;
case SDLK_DOWN:
if (y_curseur!=143)
{
y_curseur++;
if (curseur_visible >= 6)
{
y_visible++;
calcul_visible(plateau_graphe, plateau_visible, x_visible, y_visible);
}
else
curseur_visible = curseur_visible + 3;
}
break;
case SDLK_LEFT:
/**
*Evenement pour rotation
**/
if (event.key.keysym.mod & KMOD_SHIFT)
{
tuile_rotation(pioche, 'g');
numero_tuile_curseur = pioche->tuile_pioche->image;
statut_rotation = GAUCHE;
}
else
{
/**
*Evenement pour déplacement
**/
if (x_curseur!=1)
{
x_curseur--;
if (curseur_visible==0 || curseur_visible==3 || curseur_visible==6)
{
x_visible--;
calcul_visible(plateau_graphe, plateau_visible, x_visible, y_visible);
}
else
curseur_visible--;
}
}
break;
case SDLK_RIGHT:
/**
*Evenement pour rotation
**/
if (event.key.keysym.mod & KMOD_SHIFT)
{
tuile_rotation(pioche, 'd');
numero_tuile_curseur = pioche->tuile_pioche->image;
statut_rotation = DROITE;
}
else
{
/**
*Evenement pour déplacement
**/
if (x_curseur!=143)
{
x_curseur++;
if (curseur_visible==2 || curseur_visible==5 || curseur_visible==8)
{
x_visible++;
calcul_visible(plateau_graphe, plateau_visible, x_visible, y_visible);
}
else
curseur_visible++;
}
}
break;
case SDLK_TAB:
pioche->nb_carte[num_tuile_courante]--;
num_tuile_courante = update_pioche(pioche, tuiles);
numero_tuile_curseur = pioche->tuile_pioche->image;
if (joueurs->courant->score >= 4)
joueurs->courant->score -= 4;
else if (joueurs->courant->score >= 1)
joueurs->courant->score -= 3;
a_qui_le_tour(joueurs);
break;
case SDLK_a:
jeu_en_cours = FIN_DE_PARTIE;
if (joueurs->bleu->score >= joueurs->rouge->score)
joueurs->courant = joueurs->bleu;
else
joueurs->courant = joueurs->rouge;
break;
case SDLK_SPACE:
if (poser_tuile(plateau_graphe, pioche->tuile_pioche, y_curseur, x_curseur) == EXIT_SUCCESS)
{
update_graphe_global(plateau_graphe, graphe_global, pioche->tuile_pioche, y_curseur, x_curseur);
plateau_graphe[y_curseur][x_curseur]->joueur = joueurs->courant;
calcul_visible(plateau_graphe, plateau_visible, x_visible, y_visible);
struct tuile* temp_tuile = pioche->tuile_pioche;
num_tuile_courante = update_pioche(pioche, tuiles);
if (num_tuile_courante == EXIT_ANY_TILE_AVAILLABLE) {
if (joueurs->bleu->score >= joueurs->rouge->score)
joueurs->courant = joueurs->bleu;
else
joueurs->courant = joueurs->rouge;
jeu_en_cours = FIN_DE_PARTIE;
}
else if (joueurs->courant->nb_partisans > 0)
{
phase_jeu = 1;
SDL_Event event2;
calcul_pions_possibles(pions_possibles, plateau_graphe, x_curseur, y_curseur);
do
{
if(curseur_pion_visible == 8)
curseur_pion_visible = 0;
else
curseur_pion_visible++;
}while (pions_possibles[curseur_pion_visible] == VIDE);
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
while(phase_jeu)
{
SDL_WaitEvent(&event2);
switch(event2.type)
{
case SDL_KEYDOWN:
switch(event2.key.keysym.sym)
{
case SDLK_LCTRL:
phase_jeu = 0;
break;
case SDLK_RIGHT:
do
{
if(curseur_pion_visible == 8)
curseur_pion_visible = 0;
else
curseur_pion_visible++;
}while (pions_possibles[curseur_pion_visible] == VIDE);
break;
case SDLK_LEFT:
do
{
if(curseur_pion_visible == 0)
curseur_pion_visible = 8;
else
curseur_pion_visible--;
}while (pions_possibles[curseur_pion_visible] == VIDE);
break;
case SDLK_SPACE:
switch(curseur_pion_visible)
{
case 0:
if (pions_possibles[0] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[0]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[0]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 16;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 16;
}
else
pion_impossible = 1;
break;
case 1:
if (pions_possibles[1] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[0]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else if (pions_possibles[1] == ROUTE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->routes[0]);
plateau_graphe[y_curseur][x_curseur]->type_pion = ROUTE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[0]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 16;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 51;
}
else
pion_impossible = 1;
break;
case 2:
if (pions_possibles[2] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[1]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[1]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 16;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 86;
}
else
pion_impossible = 1;
break;
case 3:
if (pions_possibles[3] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[3]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else if (pions_possibles[3] == ROUTE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->routes[3]);
plateau_graphe[y_curseur][x_curseur]->type_pion = ROUTE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[3]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 51;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 16;
}
else
pion_impossible = 1;
break;
case 5:
if (pions_possibles[5] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[1]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else if (pions_possibles[5] == ROUTE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->routes[1]);
plateau_graphe[y_curseur][x_curseur]->type_pion = ROUTE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[1]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 51;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 86;
}
else
pion_impossible = 1;
break;
case 6:
if (pions_possibles[6] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[3]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[3]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 86;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 16;
}
else
pion_impossible = 1;
break;
case 7:
if (pions_possibles[7] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[2]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else if (pions_possibles[7] == ROUTE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->routes[2]);
plateau_graphe[y_curseur][x_curseur]->type_pion = ROUTE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[2]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 86;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 51;
}
else
pion_impossible = 1;
break;
case 8:
if (pions_possibles[8] == VILLE)
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->villes[2]);
plateau_graphe[y_curseur][x_curseur]->type_pion = VILLE;
}
else
{
pose_pion_result = poser_pion(graphe_global, joueurs, plateau_graphe[y_curseur][x_curseur]->graphe->champs[2]);
plateau_graphe[y_curseur][x_curseur]->type_pion = CHAMP;
}
if (pose_pion_result == EXIT_SUCCESS)
{
plateau_graphe[y_curseur][x_curseur]->pos_pion.y = 86;
plateau_graphe[y_curseur][x_curseur]->pos_pion.x = 86;
}
else
pion_impossible = 1;
break;
}
if (pion_impossible != 1)
phase_jeu = 0;
break;
}
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
pion_impossible = 0;
}
}
}
numero_tuile_curseur = pioche->tuile_pioche->image;
pioche_restante--;
a_qui_le_tour(joueurs);
compter_points_ville_route(graphe_global, temp_tuile, joueurs);
}
else
{
statut_place = 1;
}
break;
}
}
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
statut_place = 0;
statut_rotation = 0;
}
while(jeu_en_cours == FIN_DE_PARTIE)
{
SDL_WaitEvent(&event3);
switch(event3.type)
{
case SDL_QUIT:
jeu_en_cours = QUITTER_PARTIE;
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
free_plateau(plateau_visible, LARGEUR_PLATEAU_VISIBLE);
free_plateau(plateau_graphe, LARGEUR_PLATEAU);
free_graphe_global(graphe_global);
free_pioche(pioche);
free_tuiles(tuiles);
free_joueurs(joueurs);
break;
case SDL_KEYDOWN:
switch(event3.key.keysym.sym)
{
case SDLK_SPACE:
affichage(ecran, plateau_visible, curseur_visible, numero_tuile_curseur, jeu_en_cours, pioche_restante, statut_place, statut_rotation, phase_jeu, curseur_pion_visible, pions_possibles, pion_impossible, joueurs->rouge, joueurs->bleu, joueurs->courant);
free_plateau(plateau_visible, LARGEUR_PLATEAU_VISIBLE);
free_plateau(plateau_graphe, LARGEUR_PLATEAU);
free_graphe_global(graphe_global);
free_pioche(pioche);
free_tuiles(tuiles);
free_joueurs(joueurs);
jeu_en_cours = QUITTER_PARTIE;
break;
}
}
}
}
int main(void)
{
#if defined (WIN32)
WSADATA WSAData;
int erreur = WSAStartup(MAKEWORD(2,2), &WSAData);
#else
int erreur = 0;
#endif
int i,k,j,tour=0;
Obj_sock client;
int port=23,pioche[104];
Paquet paq;
if(!erreur)
{
client = create_sock_obj();
init_pioche(pioche);
//127.0.0.1 est le serveur local pour tous les ordi!
client=client_config(client,"127.0.0.1",port);
do{
if(tour%9 == 0)
tour=0;
reception_pqt(client,&paq);
making_pioche_b(pioche,paq);//tiens a jour ce qui reste dans la pioche du serveur
printf("Nombre de tete de boeuf :%d\nN_dec =%d\n",paq.moi.tete_partie,paq.moi.n_deck);
if(paq.etat==1)
{
printf("\nNouvelle manche!\n");
reception_pqt(client,&paq);
printf("Etat du jeu :%d\n",paq.etat);
init_pioche(pioche);
making_pioche_b(pioche,paq);
}
if(paq.etat<2)
{
affichage_grille(paq);
afficher_carte_main(paq);
printf("meilleure carte :%d\n",best_card(paq,pioche,paq.nb_client,tour));
/*do{
printf("\nChoisir une carte:\n");
scanf("%d",&paq.moi.num_carte);
getchar();
}while(validite_carte(paq)==-1);*/
paq.moi.num_carte= best_card(paq,pioche,paq.nb_client,tour);
//paq.moi.num_carte = random_card(paq);
//on supprime la carte choisie
paq=supprimer_carte(paq);
//Envoie le paquet modifié
envoie_pqt(client,paq);
sleep(1);
}
tour++;
}while(paq.etat!=2);
printf("Fin du jeu\n");
reception_pqt(client,&paq);
affichage_grille(paq);
/* On ferme la socket précédemment ouverte */
closesocket(client.sock);
#if defined (WIN32)
WSACleanup();
#endif
}
return EXIT_SUCCESS;
}
