G2A Many GEOs
SHARE
TWEET

Untitled

a guest Jul 7th, 2015 243 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. struct carte
  6. {
  7.         int valeur;
  8.         int couleur;
  9. };
  10.  
  11. int pioche(int nbr_joueur);
  12. void tas_carte(int cartes[]);
  13. void affichage_carte(int cartes[], struct carte pioche[], int nbr_joueur);
  14.  
  15.  
  16.  
  17. int main(int argc, char** argv)
  18. {
  19.     int nbr_joueur = 0;
  20.  
  21.     printf("Entrez le nombre de joueurs :\n");
  22.     scanf("%d",&nbr_joueur);
  23.     pioche(nbr_joueur);
  24.     return (EXIT_SUCCESS);
  25. }
  26.  
  27. int pioche(int nbr_joueur)
  28. {
  29.     srand(time(NULL));
  30.     int i, cartes[51];
  31.     tas_carte(cartes);
  32.    
  33.     struct carte pioche[24];
  34.     for (i = 0 ; i < 24 ; i++)
  35.     {
  36.         pioche[i].valeur = 333;
  37.         pioche[i].couleur = 333;
  38.     }
  39.     affichage_carte(cartes, pioche, nbr_joueur);
  40.     for (i = 0 ; i < 24 ; i++)
  41.     {
  42.         printf("%d\n",pioche[i].valeur);
  43.         printf("%d\n",pioche[i].couleur);
  44.     }
  45.     return 0;
  46. }
  47.  
  48. void tas_carte(int cartes[])
  49. {
  50.     srand(time(NULL));
  51.  
  52.     int i,a,b,c;
  53.     for (i = 0 ; i < 52 ; i++)
  54.     {
  55.         cartes[i] = i;
  56.     }
  57.    
  58.     for (i = 0 ; i <= 100 ; i++)
  59.     {
  60.         a = (rand() % (51 - 0 + 1)) + 0;
  61.         b = (rand() % (51 - 0 + 1)) + 0;
  62.         c = cartes[a];
  63.         cartes[a] = cartes[b];
  64.         cartes[b] = c;
  65.     }
  66.    
  67. }
  68.  
  69. void affichage_carte(int cartes[], struct carte pioche[], int nbr_joueur)
  70. {
  71.     int i,j,k = 0;
  72.     for (j = 1 ; j <= nbr_joueur+3 ; j++)
  73.     {
  74.         if (j <= nbr_joueur)
  75.         {
  76.            printf("Joueur %d :\n", j);
  77.            i = 0;
  78.         }
  79.         else if (j == nbr_joueur+1)
  80.         {
  81.             printf("Flop :\n");
  82.             k++;
  83.             i = -1;
  84.         }
  85.         else if (j == nbr_joueur+2)
  86.         {
  87.             printf("Turn :\n");
  88.             k++;
  89.             i = 1;
  90.         }
  91.         else if (j == nbr_joueur+3)
  92.         {
  93.             printf("River :\n");
  94.             k++;
  95.             i = 1;
  96.         }
  97.         for (i; i < 2 ; i++)
  98.         {
  99.             switch (cartes[k])
  100.             {
  101.                 case 0:
  102.                 printf("As de Pique\n");
  103.                 pioche[k].valeur = 1;
  104.                 pioche[k].couleur = 1;
  105.                 break;
  106.                 case 1:
  107.                 printf("2 de Pique\n");
  108.                 pioche[k].valeur = 2;
  109.                 pioche[k].couleur = 1;
  110.                 break;
  111.                 case 2:
  112.                 printf("3 de Pique\n");
  113.                 pioche[k].valeur = 3;
  114.                 pioche[k].couleur = 1;
  115.                 break;
  116.                 case 3:
  117.                 printf("4 de Pique\n");
  118.                 pioche[k].valeur = 4;
  119.                 pioche[k].couleur = 1;
  120.                 break;
  121.                 case 4:
  122.                 printf("5 de Pique\n");
  123.                 pioche[k].valeur = 5;
  124.                 pioche[k].couleur = 1;
  125.                 break;
  126.                 case 5:
  127.                 printf("6 de Pique\n");
  128.                 pioche[k].valeur = 6;
  129.                 pioche[k].couleur = 1;
  130.                 break;
  131.                 case 6:
  132.                 printf("7 de Pique\n");
  133.                 pioche[k].valeur = 7;
  134.                 pioche[k].couleur = 1;
  135.                 break;
  136.                 case 7:
  137.                 printf("8 de Pique\n");
  138.                 pioche[k].valeur = 8;
  139.                 pioche[k].couleur = 1;
  140.                 break;
  141.                 case 8:
  142.                 printf("9 de Pique\n");
  143.                 pioche[k].valeur = 9;
  144.                 pioche[k].couleur = 1;
  145.                 break;
  146.                 case 9:
  147.                 printf("10 de Pique\n");
  148.                 pioche[k].valeur = 10;
  149.                 pioche[k].couleur = 1;
  150.                 break;
  151.                 case 10:
  152.                 printf("Valet de Pique\n");
  153.                 pioche[k].valeur = 11;
  154.                 pioche[k].couleur = 1;
  155.                 break;
  156.                 case 11:
  157.                 printf("Dame de Pique\n");
  158.                 pioche[k].valeur = 1;
  159.                 pioche[k].couleur = 12;
  160.                 break;
  161.                 case 12:
  162.                 printf("Roi de Pique\n");
  163.                 pioche[k].valeur = 13;
  164.                 pioche[k].couleur = 1;
  165.                 break;
  166.                 case 13:
  167.                 printf("As de Coeur\n");
  168.                 pioche[k].valeur = 1;
  169.                 pioche[k].couleur = 2;
  170.                 break;
  171.                 case 14:
  172.                 printf("2 de Coeur\n");
  173.                 pioche[k].valeur = 2;
  174.                 pioche[k].couleur = 2;
  175.                 break;
  176.                 case 15:
  177.                 printf("3 de Coeur\n");
  178.                 pioche[k].valeur = 3;
  179.                 pioche[k].couleur = 2;
  180.                 break;
  181.                 case 16:
  182.                 printf("4 de Coeur\n");
  183.                 pioche[k].valeur = 4;
  184.                 pioche[k].couleur = 2;
  185.                 break;
  186.                 case 17:
  187.                 printf("5 de Coeur\n");
  188.                 pioche[k].valeur = 5;
  189.                 pioche[k].couleur = 2;
  190.                 break;
  191.                 case 18:
  192.                 printf("6 de Coeur\n");
  193.                 pioche[k].valeur = 6;
  194.                 pioche[k].couleur = 2;
  195.                 break;
  196.                 case 19:
  197.                 printf("7 de Coeur\n");
  198.                 pioche[k].valeur = 7;
  199.                 pioche[k].couleur = 2;
  200.                 break;
  201.                 case 20:
  202.                 printf("8 de Coeur\n");
  203.                 pioche[k].valeur = 8;
  204.                 pioche[k].couleur = 2;
  205.                 break;
  206.                 case 21:
  207.                 printf("9 de Coeur\n");
  208.                 pioche[k].valeur = 9;
  209.                 pioche[k].couleur = 2;
  210.                 break;
  211.                 case 22:
  212.                 printf("10 de Coeur\n");
  213.                 pioche[k].valeur = 10;
  214.                 pioche[k].couleur = 2;
  215.                 break;
  216.                 case 23:
  217.                 printf("Valet de Coeur\n");
  218.                 pioche[k].valeur = 11;
  219.                 pioche[k].couleur = 2;
  220.                 break;
  221.                 case 24:
  222.                 printf("Dame de Coeur\n");
  223.                 pioche[k].valeur = 12;
  224.                 pioche[k].couleur = 2;
  225.                 break;
  226.                 case 25:
  227.                 printf("Roi de Coeur\n");
  228.                 pioche[k].valeur = 13;
  229.                 pioche[k].couleur = 2;
  230.                 break;
  231.                 case 26:
  232.                 printf("As de Carreau\n");
  233.                 pioche[k].valeur = 1;
  234.                 pioche[k].couleur = 3;
  235.                 break;
  236.                 case 27:
  237.                 printf("2 de Carreau\n");
  238.                 pioche[k].valeur = 2;
  239.                 pioche[k].couleur = 3;
  240.                 break;
  241.                 case 28:
  242.                 printf("3 de Carreau\n");
  243.                 pioche[k].valeur = 3;
  244.                 pioche[k].couleur = 3;
  245.                 break;
  246.                 case 29:
  247.                 printf("4 de Carreau\n");
  248.                 pioche[k].valeur = 4;
  249.                 pioche[k].couleur = 3;
  250.                 break;
  251.                 case 30:
  252.                 printf("5 de Carreau\n");
  253.                 pioche[k].valeur = 5;
  254.                 pioche[k].couleur = 3;
  255.                 break;
  256.                 case 31:
  257.                 printf("6 de Carreau\n");
  258.                 pioche[k].valeur = 6;
  259.                 pioche[k].couleur = 3;
  260.                 break;
  261.                 case 32:
  262.                 printf("7 de Carreau\n");
  263.                 pioche[k].valeur = 7;
  264.                 pioche[k].couleur = 3;
  265.                 break;
  266.                 case 33:
  267.                 printf("8 de Carreau\n");
  268.                 pioche[k].valeur = 8;
  269.                 pioche[k].couleur = 3;
  270.                 break;
  271.                 case 34:
  272.                 printf("9 de Carreau\n");
  273.                 pioche[k].valeur = 9;
  274.                 pioche[k].couleur = 3;
  275.                 break;
  276.                 case 35:
  277.                 printf("10 de Carreau\n");
  278.                 pioche[k].valeur = 10;
  279.                 pioche[k].couleur = 3;
  280.                 break;
  281.                 case 36:
  282.                 printf("Valet de Carreau\n");
  283.                 pioche[k].valeur = 11;
  284.                 pioche[k].couleur = 3;
  285.                 break;
  286.                 case 37:
  287.                 printf("Dame de Carreau\n");
  288.                 pioche[k].valeur = 12;
  289.                 pioche[k].couleur = 3;
  290.                 break;
  291.                 case 38:
  292.                 printf("Roi de Carreau\n");
  293.                 pioche[k].valeur = 13;
  294.                 pioche[k].couleur = 3;
  295.                 break;
  296.                 case 39:
  297.                 printf("As de Trefle\n");
  298.                 pioche[k].valeur = 1;
  299.                 pioche[k].couleur = 4;
  300.                 break;
  301.                 case 40:
  302.                 printf("2 de Trefle\n");
  303.                 pioche[k].valeur = 2;
  304.                 pioche[k].couleur = 4;
  305.                 break;
  306.                 case 41:
  307.                 printf("3 de Trefle\n");
  308.                 pioche[k].valeur = 3;
  309.                 pioche[k].couleur = 4;
  310.                 break;
  311.                 case 42:
  312.                 printf("4 de Trefle\n");
  313.                 pioche[k].valeur = 4;
  314.                 pioche[k].couleur = 4;
  315.                 break;
  316.                 case 43:
  317.                 printf("5 de Trefle\n");
  318.                 pioche[k].valeur = 5;
  319.                 pioche[k].couleur = 4;
  320.                 break;
  321.                 case 44:
  322.                 printf("6 de Trefle\n");
  323.                 pioche[k].valeur = 6;
  324.                 pioche[k].couleur = 4;
  325.                 break;
  326.                 case 45:
  327.                 printf("7 de Trefle\n");
  328.                 pioche[k].valeur = 7;
  329.                 pioche[k].couleur = 4;
  330.                 break;
  331.                 case 46:
  332.                 printf("8 de Trefle\n");
  333.                 pioche[k].valeur = 8;
  334.                 pioche[k].couleur = 4;
  335.                 break;
  336.                 case 47:
  337.                 printf("9 de Trefle\n");
  338.                 pioche[k].valeur = 9;
  339.                 pioche[k].couleur = 4;
  340.                 break;
  341.                 case 48:
  342.                 printf("10 de Trefle\n");
  343.                 pioche[k].valeur = 10;
  344.                 pioche[k].couleur = 4;
  345.                 break;
  346.                 case 49:
  347.                 printf("Valet de Trefle\n");
  348.                 pioche[k].valeur = 11;
  349.                 pioche[k].couleur = 4;
  350.                 break;
  351.                 case 50:
  352.                 printf("Dame de Trefle\n");
  353.                 pioche[k].valeur = 12;
  354.                 pioche[k].couleur = 4;
  355.                 break;
  356.                 case 51:
  357.                 printf("Roi de Trefle\n");
  358.                 pioche[k].valeur = 13;
  359.                 pioche[k].couleur = 4;
  360.                 break;
  361.             }
  362.         k++;
  363.         }
  364.     }
  365.    
  366. }
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