SHARE
TWEET

gobblerS3

a guest Dec 6th, 2019 109 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //gcc main.c board.o -o main
  2.  
  3. #include <stdio.h>
  4. #include "board.h"
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <ctype.h>
  8.  
  9. #define MAX 100
  10.  
  11. void espaces(int nbr)
  12. {
  13.     for (int i = 0; i < nbr; i++)
  14.     {
  15.         printf(" ");
  16.     }
  17. }
  18.  
  19. void affichage_placer_piece(board game, int currentPlayer)
  20. {
  21.     int line = -1, col = -1;
  22.     do
  23.     {
  24.         if (get_piece_size(game, line - 1, col - 1) == 3 && line != -1 && col != -1)
  25.         {
  26.             printf("\033[0;31mIl y a déjà une pièce et vous ne pouvez pas la recouvrir\033[00m \n");
  27.         }
  28.         do
  29.         {
  30.             printf("Entrez un numéro de ligne (entre 1 et 3) : ");
  31.             scanf("%d", &line);
  32.             while ((getchar()) != '\n')
  33.                 ;
  34.         } while (line < 1 || line > 3);
  35.         do
  36.         {
  37.             printf("Entrez un numéro de colonne (entre 1 et 3) : ");
  38.             scanf("%d", &col);
  39.             while ((getchar()) != '\n')
  40.                 ;
  41.         } while (col < 1 || col > 3);
  42.         if (get_piece_size(game, line, col) == 3)
  43.         {
  44.             printf("Il y a déjà une pièce dans la case séléctionnée, et vous ne pouvez pas la recouvrir\n");
  45.         }
  46.     } while (get_piece_size(game, line - 1, col - 1) == 3);
  47.  
  48.     int taille = -1;
  49.     do
  50.     {
  51.         if (taille != -1 && get_nb_piece_in_house(game, currentPlayer, taille) == 0)
  52.         {
  53.             printf("\033[0;31mVous avez utilisé toutes vos pièces de taille %ls, veuillez choisir une autre taille\033[00m \n", &taille);
  54.         }
  55.         if (taille != -1 && (taille <= get_piece_size(game, line - 1, col - 1)))
  56.         {
  57.             printf("\033[0;31mVous ne pouvez pas recouvrir la pièce\033[00m \n");
  58.         }
  59.         printf("\n─────────── Quelle est la taille de la pièce à placer dans la case (%d,%d) ?───────────\n", line, col);
  60.         printf("                   Petite (1) - Moyenne (2) - Grande (3)\n");
  61.         printf("─────────────────────────────────────────────────────────────────────────────────────\n");
  62.         scanf("%d", &taille);
  63.         while ((getchar()) != '\n')
  64.             ;
  65.     } while (taille < 1 || taille > 3 || taille <= get_piece_size(game, line - 1, col - 1) || get_nb_piece_in_house(game, currentPlayer, taille) == 0);
  66.  
  67.     place_piece(game, currentPlayer, taille, line - 1, col - 1);
  68. }
  69.  
  70. void affichage_deplacer_piece(board game, int currentPlayer)
  71. {
  72.     int line = -1, col = -1, line2 = -1, col2 = -1;
  73.     if (get_nb_piece_in_house(game, currentPlayer, 1) == 2 && get_nb_piece_in_house(game, currentPlayer, 2) == 2 && get_nb_piece_in_house(game, currentPlayer, 3) == 2)
  74.     {
  75.         printf("\033[0;31mVous n'avez pas encore placer de pièces, il faut en placer une d'abord\033[00m \n");
  76.         affichage_placer_piece(game, currentPlayer);
  77.     }
  78.     else
  79.     {
  80.         do
  81.         {
  82.             if (get_piece_size(game, line - 1, col - 1) == 0 && line != -1 && col != -1)
  83.             {
  84.                 printf("\033[0;31mIl y a pas de pièce dans la case séléctionnée\033[00m\n");
  85.             }
  86.             else if (get_place_holder(game, line - 1, col - 1) != currentPlayer && line != -1 && col != -1)
  87.             {
  88.                 printf("\033[0;31mLa pièce dans cette case ne vous appartient pas, vous ne pouvez pas la déplacer\033[00m\n");
  89.             }
  90.  
  91.             do
  92.             {
  93.                 printf("Entrez le numéro de ligne de la pièce à déplacer (entre 1 et 3) : ");
  94.                 scanf("%d", &line);
  95.                 while ((getchar()) != '\n')
  96.                     ;
  97.             } while (line < 1 && line > 3);
  98.             do
  99.             {
  100.                 printf("Entrez le numéro de colonne de la pièce à déplacer (entre 1 et 3) : ");
  101.                 scanf("%d", &col);
  102.                 while ((getchar()) != '\n')
  103.                     ;
  104.             } while (col < 1 && col > 3);
  105.         } while (get_place_holder(game, line - 1, col - 1) != currentPlayer || get_piece_size(game, line - 1, col - 1) == 0);
  106.         do
  107.         {
  108.             if (get_piece_size(game, line - 1, col - 1) <= get_piece_size(game, line2 - 1, col2 - 1))
  109.             {
  110.                 printf("\033[0;31mVous ne pouvez pas déplacer la pièce dans la case selectionnée car votre pièce ne permet pas de recouvrir celle déjà présente\033[00m\n");
  111.             }
  112.             do
  113.             {
  114.                 printf("Entrez le numéro de ligne de la case où vous voulez déplacer la pièce (entre 1 et 3) : ");
  115.                 scanf("%d", &line2);
  116.                 while ((getchar()) != '\n')
  117.                     ;
  118.             } while (line2 < 1 && line2 > 3);
  119.             do
  120.             {
  121.                 printf("Entrez le numéro de colonne de la case où vous voulez déplacer la pièce (entre 1 et 3) : ");
  122.                 scanf("%d", &col2);
  123.                 while ((getchar()) != '\n')
  124.                     ;
  125.             } while (col2 < 1 && col2 > 3);
  126.         } while (get_piece_size(game, line - 1, col - 1) <= get_piece_size(game, line2 - 1, col2 - 1));
  127.  
  128.         move_piece(game, line - 1, col - 1, line2 - 1, col2 - 1);
  129.     }
  130. }
  131.  
  132. void couleurTaillePion(player joueur, size taille)
  133. {
  134.     if (joueur == 1)
  135.     {
  136.         printf("\033[0;36m");
  137.         switch (taille)
  138.         {
  139.         case SMALL:
  140.             printf(".");
  141.             break;
  142.         case MEDIUM:
  143.             printf("x");
  144.             break;
  145.         case LARGE:
  146.             printf("#");
  147.             break;
  148.         default:
  149.             printf(" ");
  150.             break;
  151.         }
  152.     }
  153.     else
  154.     {
  155.         printf("\033[0;31m");
  156.         switch (taille)
  157.         {
  158.         case SMALL:
  159.             printf(".");
  160.             break;
  161.         case MEDIUM:
  162.             printf("o");
  163.             break;
  164.         case LARGE:
  165.             printf("0");
  166.             break;
  167.         default:
  168.             printf(" ");
  169.             break;
  170.         }
  171.     }
  172.     printf("\033[00m");
  173. }
  174.  
  175. void pointsRestants(board jeu, player joueur)
  176. {
  177.     //---------------       SMALL          ---------------//
  178.     int small = get_nb_piece_in_house(jeu, joueur, SMALL); // Détermination du nombre de pièce SMALL
  179.     for (int i = 0; i < small; i++)
  180.     {
  181.         printf("."); // Affichage de x caractères en fonction de pieces restantes (joueur 1 et joueur 2)
  182.     }
  183.     for (int i = 0; i < 2 - small; i++)
  184.     {
  185.         printf(" "); // Affichage de x espaces, en fonction des piosn déjà placés
  186.     }
  187.     //---------------       MEDIUM          ---------------//
  188.     int medium = get_nb_piece_in_house(jeu, joueur, MEDIUM); // Détermination du nombre de pièce MEDIUM
  189.     for (int i = 0; i < medium; i++)
  190.     {
  191.         if (joueur == 1)
  192.         {
  193.             printf("X"); // Affichage de x caractères en fonction de pieces restantes (joueur 1)
  194.         }
  195.         else
  196.         {
  197.             printf("o"); // Affichage de x caractères en fonction de pieces restantes (joueur 2)
  198.         }
  199.     }
  200.     for (int i = 0; i < 2 - medium; i++)
  201.     {
  202.         printf(" "); // Affichage de x espaces, en fonction des piosn déjà placés
  203.     }
  204.     //---------------       LARGE          ---------------//
  205.     int large = get_nb_piece_in_house(jeu, joueur, LARGE); // Détermination du nombre de pièce LARGE
  206.     for (int i = 0; i < large; i++)
  207.     {
  208.         if (joueur == 1)
  209.         {
  210.             printf("#"); // Affichage de x caractères en fonction de pieces restantes (joueur 1)
  211.         }
  212.         else
  213.         {
  214.             printf("0"); // Affichage de x caractères en fonction de pieces restantes (joueur 2)
  215.         }
  216.     }
  217.     for (int i = 0; i < 2 - large; i++)
  218.     {
  219.         printf(" "); // Affichage de x espaces, en fonction des piosn déjà placés
  220.     }
  221. }
  222.  
  223. void affichagePion(board jeu, int pion, int line)
  224. {
  225.     for (int col = 0; col < 3; col++) //  Affichage des trois cases
  226.     {
  227.         for (int i = 0; i < 10; i++) //  Strucure du plateau
  228.         {
  229.             if (i % 5 == 0 && i % 10 != 0 && pion == 1)
  230.             {
  231.                 // Récupération du joueur et de la taille du pion de la case (line,col)
  232.                 couleurTaillePion(get_place_holder(jeu, line, col), get_piece_size(jeu, line, col));
  233.             }
  234.             else if (i % 5 == 0 && i % 10 == 0)
  235.             {
  236.                 //Structure plateau
  237.                 printf("║");
  238.             }
  239.             else
  240.             {
  241.                 //Structure plateau
  242.                 printf(" ");
  243.             }
  244.         }
  245.     }
  246.     //Structure plateau
  247.     printf("║");
  248. }
  249.  
  250. void affichageInfoGauche(int line, char *pseudo_current_player, player current_player)
  251. {
  252.     int tailleNom = 0;
  253.     tailleNom = strlen(pseudo_current_player);
  254.     switch (line)
  255.     {
  256.     case 1:
  257.         for (int i = 0; i < 15 - tailleNom / 2; i++)
  258.         {
  259.             printf("─");
  260.         }
  261.         if (current_player == 1)
  262.         {
  263.             printf(" \033[0;36m%s\033[00m - Faites un choix ", pseudo_current_player);
  264.         }
  265.         else
  266.         {
  267.             printf(" \033[0;31m%s\033[00m - Faites un choix ", pseudo_current_player);
  268.         }
  269.         if (tailleNom % 2 != 0)
  270.         {
  271.             tailleNom += 1;
  272.         }
  273.         for (int i = 0; i < 15 - tailleNom / 2; i++)
  274.         {
  275.             printf("─");
  276.         }
  277.         break;
  278.     case 2:
  279.         printf("    1)  Placer une pièce");
  280.         break;
  281.     case 3:
  282.         printf("    2)  Déplacer une pièce");
  283.         break;
  284.     case 4:
  285.         printf("    3)  Quitter la partie");
  286.         break;
  287.     case 5:
  288.         for (int i = 0; i < 50; i++)
  289.         {
  290.             printf("─");
  291.         }
  292.         break;
  293.     default:
  294.         break;
  295.     }
  296. }
  297.  
  298. void affichageInfoDroite(board jeu, int line, char *pseudo_j1, char *pseudo_j2)
  299. {
  300.     int tailleNom1 = 0;
  301.     int tailleNom2 = 0;
  302.     tailleNom1 = strlen(pseudo_j1);
  303.     tailleNom2 = strlen(pseudo_j2);
  304.     switch (line)
  305.     {
  306.     case 1:
  307.         for (int i = 0; i < 17; i++)
  308.         {
  309.             printf("─");
  310.         }
  311.         printf(" Pions Restants ");
  312.         for (int i = 0; i < 17; i++)
  313.         {
  314.             printf("─");
  315.         }
  316.         break;
  317.     case 2:
  318.         for (int i = 0; i < 11 - tailleNom1 / 2; i++)
  319.         {
  320.             printf(" ");
  321.         }
  322.         printf("\033[0;36m%s\033[00m", pseudo_j1);
  323.         for (int i = 0; i < (9 - tailleNom1 / 2) + 15 + (9 - tailleNom2 / 2); i++)
  324.         {
  325.             printf(" ");
  326.         }
  327.         printf("\033[0;31m%s\033[00m", pseudo_j2);
  328.         for (int i = 0; i < 9 - tailleNom2 / 2; i++)
  329.         {
  330.             printf(" ");
  331.         }
  332.         printf("\n");
  333.         break;
  334.     case 3:
  335.         espaces(8);
  336.         printf("\033[0;36m");
  337.         pointsRestants(jeu, 1);
  338.         printf("\033[00m");
  339.         espaces(27);
  340.         printf("\033[0;31m");
  341.         pointsRestants(jeu, 2);
  342.         printf("\033[00m");
  343.         printf("\n");
  344.         break;
  345.     case 4:
  346.         espaces(3);
  347.         for (int i = 0; i < 50; i++)
  348.         {
  349.             printf("─");
  350.         }
  351.         printf("\n");
  352.         break;
  353.     default:
  354.         break;
  355.     }
  356. }
  357.  
  358. void titreJeu()
  359. {
  360.     //---------------       Affichage du Titre          ---------------//
  361.     espaces(47);
  362.     printf("\033[0;36m╔═╗\033[00m┌─┐┌┐ ┌┐ ┬  ┌─┐┌┬┐  \033[0;31m╔═╗\033[00m┌─┐┌┐ ┌┐ ┬  ┌─┐┬─┐┌─┐\n");
  363.     espaces(47);
  364.     printf("\033[0;36m║ ╦\033[00m│ │├┴┐├┴┐│  ├┤  │   \033[0;31m║ ╦\033[00m│ │├┴┐├┴┐│  ├┤ ├┬┘└─┐\n");
  365.     espaces(47);
  366.     printf("\033[0;36m╚═╝\033[00m└─┘└─┘└─┘┴─┘└─┘ ┴   \033[0;31m╚═╝\033[00m└─┘└─┘└─┘┴─┘└─┘┴└─└─┘\n");
  367. }
  368.  
  369. void affichagePlateau(board jeu, char *pseudo_j1, char *pseudo_j2, char *pseudo_current_player, player current_player)
  370. {
  371.     system("clear");                             //  Clear de la console
  372.     titreJeu();                                  //  Affichage du titre du jeu
  373.     espaces(53);                                 //  Espaces
  374.     printf("╔═════════╦═════════╦═════════╗\n"); //  Affichage de la première ligne du plateau
  375.     espaces(53);
  376.     printf("║         ║         ║         ║\n"); //  Affichage de la deuxième ligne du plateau
  377.     espaces(53);
  378.     affichagePion(jeu, 1, 0); //  Affichage de la troisième ligne du plateau, comportant les pions
  379.     printf("\n");
  380.     espaces(53);
  381.     printf("║         ║         ║         ║\n");                   //  Affichage de la première ligne du plateau
  382.     affichageInfoGauche(1, pseudo_current_player, current_player); //  Affichage de la première ligne d'informations à gauche
  383.     espaces(3);
  384.     printf("╠═════════╬═════════╬═════════╣");
  385.     printf("   ");
  386.     affichageInfoDroite(jeu, 1, pseudo_j1, pseudo_j2); //  Affichage de la première ligne d'informations à droite
  387.     printf("\n");
  388.     /*******        Pareil que précédement, mais avec la suite du plateau, et d'autres informations     *****/
  389.     affichageInfoGauche(2, pseudo_current_player, current_player);
  390.     espaces(29);
  391.     printf("║         ║         ║         ║");
  392.     affichageInfoDroite(jeu, 2, pseudo_j1, pseudo_j2);
  393.     affichageInfoGauche(3, pseudo_current_player, current_player);
  394.     espaces(27);
  395.     affichagePion(jeu, 1, 1);
  396.     printf("\033[0m\n");
  397.     affichageInfoGauche(4, pseudo_current_player, current_player);
  398.     espaces(28);
  399.     printf("║         ║         ║         ║");
  400.     affichageInfoDroite(jeu, 3, pseudo_j1, pseudo_j2);
  401.     affichageInfoGauche(5, pseudo_current_player, current_player);
  402.     espaces(3);
  403.     printf("╠═════════╬═════════╬═════════╣");
  404.     affichageInfoDroite(jeu, 4, pseudo_j1, pseudo_j2);
  405.     espaces(53);
  406.     printf("║         ║         ║         ║\n");
  407.     espaces(53);
  408.     affichagePion(jeu, 1, 2);
  409.     printf("\n");
  410.     espaces(53);
  411.     printf("║         ║         ║         ║\n");
  412.     espaces(53);
  413.     printf("╚═════════╩═════════╩═════════╝\n");
  414. }
  415. int quitter()
  416. {
  417.     return (0);
  418. }
  419. void jeu(board game, char *pseudo_j1, char *pseudo_j2, player current_player)
  420. {
  421.     int choix;
  422.     char pseudo_current_player[12] = {""}; //   Variable stockant le pseudo du joueur qui doit jouer ( pour l'affichage )
  423.     if (current_player == 1)               //   Si c'est au joueur 1 de jouer
  424.     {
  425.         strcpy(pseudo_current_player, pseudo_j1); //    Copie du pseudo_j1 dans la variable pseudo_current_player
  426.     }
  427.     else
  428.     {
  429.         strcpy(pseudo_current_player, pseudo_j2);
  430.     } //    Copie du pseudo_j2 dans la variable pseudo_current_player
  431.     do
  432.     {
  433.         system("clear");                                                                     //  Clear de la console
  434.         affichagePlateau(game, pseudo_j1, pseudo_j2, pseudo_current_player, current_player); //  Affichage du plateau de jeu
  435.         scanf("%d", &choix);
  436.         while ((getchar()) != '\n')
  437.             ; //  Clear du buffer
  438.     } while (choix < 1 || choix > 3);
  439.     switch (choix)
  440.     {
  441.     case 1:
  442.         affichage_placer_piece(game, current_player);                                                  //  Appel de la fonction pour placer une pièce
  443.         affichagePlateau(game, pseudo_j1, pseudo_j2, pseudo_current_player, current_player); //  Affichage du plateau de jeu
  444.         if (get_winner(game) != 0)
  445.         {
  446.             printf("%s A GAGNE", pseudo_current_player);
  447.         }
  448.         else
  449.         {
  450.             current_player = next_player(current_player);    //  Changement de joueur
  451.             jeu(game, pseudo_j1, pseudo_j2, current_player); //  Retour au début de la boucle pour un nouveau tour
  452.         }
  453.         break;
  454.     case 2:
  455.         affichage_deplacer_piece(game, current_player);                                                //  Appel de la fonction pour déplacer une pièce
  456.         affichagePlateau(game, pseudo_j1, pseudo_j2, pseudo_current_player, current_player); //  Affichage du plateau ded jeu
  457.  
  458.         if (get_winner(game) != 0)
  459.         {
  460.             printf("%s A GAGNE", pseudo_current_player);
  461.         }
  462.         else
  463.         {
  464.             current_player = next_player(current_player);    //  Changement de joueur
  465.             jeu(game, pseudo_j1, pseudo_j2, current_player); //  Retour au début de la boucle pour un nouveau tour
  466.         }
  467.         break;
  468.     case 3:
  469.         destroy_game(game); //  Déstruction du plateau de jeu
  470.         quitter();
  471.         break; //  Break pour quitter la partie, et le programme
  472.     default:
  473.         break;
  474.     }
  475. }
  476.  
  477. void start_new_game()
  478. {
  479.     board grille_de_jeu = new_game(); //      Creation d'une nouvelle grille de jeu
  480.     //Pseudos
  481.     char pseudo_j1[12], pseudo_j2[12];
  482.     printf("Pseudo du\033[0;36m Joueur 1\033[00m : "); //      Pseudo Joueur 1
  483.     scanf("%s", pseudo_j1);
  484.     printf("Pseudo du\033[0;31m Joueur 2\033[00m : "); //      Pseudo Joueur 2
  485.     scanf("%s", pseudo_j2);
  486.     jeu(grille_de_jeu, pseudo_j1, pseudo_j2, 1); //      Appel de la fonction de la fonction jeu
  487. }
  488.  
  489. int main(int args, char **argv)
  490. {
  491.     int choix;
  492.     do
  493.     {
  494.         system("clear"); //      Remise à Zéro de la Console
  495.         choix = 0;       //      Réinitialisation du choix, en cas de boucle
  496.         /**********             Affichage de l'interface de choix             **********/
  497.         printf("            ─────────── Faites un choix ───────────\n");
  498.         printf("              1)  Commencez une Partie\n");
  499.         printf("              2)  Quittez le programme\n");
  500.         printf("            ───────────────────────────────────────\n");
  501.         /*******************************************************************************/
  502.         scanf("%d", &choix); //      Scan du choix de l'utilisateur
  503.         while ((getchar()) != '\n')
  504.             ;            //      Remise à Zéro du Buffer d'entrée
  505.         system("clear"); //      Clear de la console
  506.  
  507.     } while (choix != 1 && choix != 2); //      Boucle tant que l'utilisateur ne choisit pas entre les deux choix
  508.     switch (choix)                      //      Switch suivant le choix de l'utilisateur
  509.     {
  510.     case 1:
  511.         start_new_game(); //      Appel de la fonction pour commencer une nouvelle partie
  512.         break;
  513.     default:
  514.         break; //      Sinon, fin du programme
  515.     }
  516.     return (0);
  517. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top