API tools faq
paste
Advertisement
Guest User

Worst C ever

a guest
Jul 4th, 2015
254
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 34.92 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <memory.h>
  4. #include <unistd.h>
  5. #include <string.h>
  6. #define BUFSIZE 256
  7.  
  8.  //Check player0 startup position
  9.  //return 1 si OK / 0 if KO
  10.  int verifconfigj0(char plateau)
  11.  {
  12.     int marechal = 0;
  13.     int general= 0;
  14.     int colonel=0;
  15.     int commandant=0;
  16.     int capitaine=0;
  17.     int lieutenant=0;
  18.     int sergent =0;
  19.     int demineur =0;
  20.     int eclaireur=0;
  21.     int espion=0;
  22.     int drapeau=0;
  23.     int bombe=0;
  24.     int other=0;
  25.  
  26.     int i;
  27.     int j;
  28.  
  29.     for(i=0; i<4; i++)
  30.     {
  31.         for(j=0; j<10; j++)
  32.         {
  33.             switch (plateau[i][j])
  34.             {
  35.                 case 1:
  36.                     marechal= marechal+1;
  37.                     break;
  38.                 case 2:
  39.                     general= general+1;
  40.                     break;
  41.                 case 3:
  42.                     colonel=colonel+1;
  43.                     break;
  44.                 case 4:
  45.                     commandant=commandant+1;
  46.                     break;
  47.                 case 5:
  48.                     capitaine=capitaine+1;
  49.                     break;
  50.                 case 6:
  51.                     lieutenant=lieutenant+1;
  52.                     break;
  53.                 case 7:
  54.                     sergent=sergent+1;
  55.                     break;
  56.                 case 8:
  57.                     demineur=demineur+1;
  58.                     break;
  59.                 case 9:
  60.                     eclaireur=eclaireur+1;
  61.                     break;
  62.                 case 10:
  63.                     espion=espion+1
  64.                     break;
  65.                 case 11:
  66.                     drapeau=drapeau+1;
  67.                     break;
  68.                 case 12:
  69.                     bombe=bombe+1;
  70.                 default:
  71.                     other=other+1;
  72.                     break
  73.             }
  74.         }
  75.     }
  76.  
  77.     if((marechal==1)&&(bombe==6)&&(drapeau==1)&&(general==1)&&(colonel==2)&&(capitaine==4)&&(lieutenant==4)&&(sergent==4)&&(demineur==5)&&(eclaireur==8)&&(espion==1)&&(other==0))
  78.     {
  79.         return 1;
  80.     }
  81.     else
  82.     {
  83.         return 0;
  84.     }
  85.  
  86.  }
  87.  
  88.  //Check player1 startup position
  89.  //return 1 si OK / 0 if KO
  90.  int verifconfigj1(char plateau)
  91.  {
  92.     int marechal = 0;
  93.     int general= 0;
  94.     int colonel=0;
  95.     int commandant=0;
  96.     int capitaine=0;
  97.     int lieutenant=0;
  98.     int sergent =0;
  99.     int demineur =0;
  100.     int eclaireur=0;
  101.     int espion=0;
  102.     int drapeau =0;
  103.     int bombe=0;
  104.     int other=0;
  105.  
  106.     int i;
  107.     int j;
  108.  
  109.     for(i=6; i<10; i++)
  110.     {
  111.         for(j=0; j<10; j++)
  112.         {
  113.             switch (plateau[i][j])
  114.             {
  115.                 case 1:
  116.                     marechal= marechal+1;
  117.                     break;
  118.                 case 2:
  119.                     general= general+1;
  120.                     break;
  121.                 case 3:
  122.                     colonel=colonel+1;
  123.                     break;
  124.                 case 4:
  125.                     commandant=commandant+1;
  126.                     break;
  127.                 case 5:
  128.                     capitaine=capitaine+1;
  129.                     break;
  130.                 case 6:
  131.                     lieutenant=lieutenant+1;
  132.                     break;
  133.                 case 7:
  134.                     sergent=sergent+1;
  135.                     break;
  136.                 case 8:
  137.                     demineur=demineur+1;
  138.                     break;
  139.                 case 9:
  140.                     eclaireur=eclaireur+1;
  141.                     break;
  142.                 case 10:
  143.                     espion=espion+1
  144.                     break;
  145.                 case 11:
  146.                     drapeau=drapeau+1;
  147.                     break;
  148.                 case 12:
  149.                     bombe=bombe+1;
  150.                 default:
  151.                     other=other+1;
  152.                     break
  153.             }
  154.         }
  155.     }
  156.  
  157.     if((marechal==1)&&(bombe==6)&&(drapeau==1)&&(general==1)&&(colonel==2)&&(capitaine==4)&&(lieutenant==4)&&(sergent==4)&&(demineur==5)&&(eclaireur==8)&&(espion==1)&&(other==0))
  158.     {
  159.         return 1;
  160.     }
  161.     else
  162.     {
  163.         return 0;
  164.     }
  165.  
  166.  }
  167.  
  168.  //function who return a deplacement result in the board from the player input
  169.  //return N / B / E / F
  170.  // return Z if flag found
  171.  char result(char plateau, char deplacement)
  172.  {
  173.  
  174.     char *piece = strtok(deplacement, " ");
  175.     char *dir = strtok(NULL, " ");
  176.     char *nbdeplacement = strtok(NULL, " ");
  177.  
  178.     //get column
  179.     char pieceLettre[1];
  180.     strncpy(pieceLettre,piece,1);
  181.     pieceLettre[1] = '\0';
  182.  
  183.     switch (pieceLettre[0])
  184.     {
  185.         case 'A':
  186.              //get row
  187.             char *pieceChiffre = strtok(piece,"A");
  188.             int nbChiffre = atoi(pieceChiffre);
  189.             if(plateau[0][nbChiffre] == NULL)
  190.             {
  191.                 return 'E';
  192.             }
  193.             else
  194.             {
  195.  
  196.                 //get the number of movements
  197.                 int nbdep = atoi(nbdeplacement);
  198.  
  199.                 //get the deplacement direction
  200.                 switch (dir[0])
  201.                 {
  202.                     case 'N':
  203.                         deplacementpiece
  204.                         int x = 0;
  205.                         int y = nbdep;
  206.                         break;
  207.                     case 'S':
  208.                         int x = 0;
  209.                         int y= -nbdep;
  210.                         break;
  211.                     case 'E':
  212.                         int x = nbdep;
  213.                         int y = 0;
  214.                         break;
  215.                     case 'W':
  216.                         int x = -nbdep;
  217.                         int y = 0;
  218.                         break;
  219.                     default:
  220.                         return 'E';
  221.                         break;
  222.                 }
  223.  
  224.  
  225.                 //new piece location
  226.  
  227.                 //Code N
  228.                 if(plateau[0+(y)][nbChiffre+(x)] == NULL){
  229.                     plateau[0+(y)][nbChiffre+(x) == plateau[0][nbChiffre];
  230.                     plateau[0][nbChiffre] == NULL;
  231.                     return 'N';
  232.                 }
  233.  
  234.                 //Code B
  235.                 if(plateau[0+(y)][nbChiffre+(x)] != NULL){
  236.                    plateau[0+(y)][nbChiffre+(x)] = battle(plateau[0][nbChiffre],plateau[0+(y)][nbChiffre+(x)]);
  237.                    if(plateau[0+(y)][nbChiffre+(x)]== 'E')
  238.                    {
  239.                     return 'E'
  240.                    }
  241.                    if(plateau[0+(y)][nbChiffre+(x)]== 'Z')
  242.                    {
  243.                     return 'Z'
  244.                    }
  245.                     plateau[0][nbChiffre] == NULL;
  246.                     return 'B';
  247.                 }
  248.  
  249.             }
  250.             break;
  251.  
  252.         case 'B':
  253.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  254.             char *pieceChiffre = strtok(piece,"B");
  255.             int nbChiffre = atoi(pieceChiffre);
  256.             if(plateau[1][nbChiffre] == NULL)
  257.             {
  258.                 return 'E';
  259.             }
  260.             else
  261.             {
  262.  
  263.                 //determine nombre de deplacement
  264.                 int nbdep = atoi(nbdeplacement);
  265.  
  266.                 // détermine la direction du déplacement
  267.                 switch (dir[0])
  268.                 {
  269.                     case 'N':
  270.                         deplacementpiece
  271.                         int x = 0;
  272.                         int y = nbdep;
  273.                         break;
  274.                     case 'S':
  275.                         int x = 0;
  276.                         int y= -nbdep;
  277.                         break;
  278.                     case 'E':
  279.                         int x = nbdep;
  280.                         int y = 0;
  281.                         break;
  282.                     case 'W':
  283.                         int x = -nbdep;
  284.                         int y = 0;
  285.                         break;
  286.                     default:
  287.                         return 'E';
  288.                         break;
  289.                 }
  290.  
  291.  
  292.                 //resultat de la position future du pion
  293.  
  294.                 //Code N
  295.                 if(plateau[1+(y)][nbChiffre+(x)] == NULL){
  296.                     plateau[1+(y)][nbChiffre+(x) == plateau[1][nbChiffre];
  297.                     plateau[1][nbChiffre] == NULL;
  298.                     return 'N';
  299.                 }
  300.  
  301.                 //Code B
  302.                 if(plateau[1+(y)][nbChiffre+(x)] != NULL){
  303.                    plateau[1+(y)][nbChiffre+(x)] = battle(plateau[1][nbChiffre],plateau[1+(y)][nbChiffre+(x)]);
  304.                    if(plateau[1+(y)][nbChiffre+(x)]== 'E')
  305.                    {
  306.                     return 'E'
  307.                    }
  308.                    if(plateau[1+(y)][nbChiffre+(x)]== 'Z')
  309.                    {
  310.                     return 'Z'
  311.                    }
  312.                     plateau[1][nbChiffre] == NULL;
  313.                     return 'B';
  314.                 }
  315.  
  316.             }
  317.             break;
  318.  
  319.         case 'C':
  320.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  321.             char *pieceChiffre = strtok(piece,"C");
  322.             int nbChiffre = atoi(pieceChiffre);
  323.             if(plateau[2][nbChiffre] == NULL)
  324.             {
  325.                 return 'E';
  326.             }
  327.             else
  328.             {
  329.  
  330.                 //determine nombre de deplacement
  331.                 int nbdep = atoi(nbdeplacement);
  332.  
  333.                 // détermine la direction du déplacement
  334.                 switch (dir[0])
  335.                 {
  336.                     case 'N':
  337.                         deplacementpiece
  338.                         int x = 0;
  339.                         int y = nbdep;
  340.                         break;
  341.                     case 'S':
  342.                         int x = 0;
  343.                         int y= -nbdep;
  344.                         break;
  345.                     case 'E':
  346.                         int x = nbdep;
  347.                         int y = 0;
  348.                         break;
  349.                     case 'W':
  350.                         int x = -nbdep;
  351.                         int y = 0;
  352.                         break;
  353.                     default:
  354.                         return 'E';
  355.                         break;
  356.                 }
  357.  
  358.  
  359.                 //resultat de la position future du pion
  360.  
  361.                 //Code N
  362.                 if(plateau[2+(y)][nbChiffre+(x)] == NULL){
  363.                     plateau[2+(y)][nbChiffre+(x) == plateau[2][nbChiffre];
  364.                     plateau[2][nbChiffre] == NULL;
  365.                     return 'N';
  366.                 }
  367.  
  368.                 //Code B
  369.                 if(plateau[2+(y)][nbChiffre+(x)] != NULL){
  370.                    plateau[2+(y)][nbChiffre+(x)] = battle(plateau[2][nbChiffre],plateau[2+(y)][nbChiffre+(x)]);
  371.                    if(plateau[2+(y)][nbChiffre+(x)]== 'E')
  372.                    {
  373.                     return 'E'
  374.                    }
  375.                    if(plateau[2+(y)][nbChiffre+(x)]== 'Z')
  376.                    {
  377.                     return 'Z'
  378.                    }
  379.                     plateau[2][nbChiffre] == NULL;
  380.                     return 'B';
  381.                 }
  382.  
  383.             }
  384.             break;
  385.  
  386.         case 'D':
  387.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  388.             char *pieceChiffre = strtok(piece,"D");
  389.             int nbChiffre = atoi(pieceChiffre);
  390.             if(plateau[3][nbChiffre] == NULL)
  391.             {
  392.                 return 'E';
  393.             }
  394.             else
  395.             {
  396.  
  397.                 //determine nombre de deplacement
  398.                 int nbdep = atoi(nbdeplacement);
  399.  
  400.                 // détermine la direction du déplacement
  401.                 switch (dir[0])
  402.                 {
  403.                     case 'N':
  404.                         deplacementpiece
  405.                         int x = 0;
  406.                         int y = nbdep;
  407.                         break;
  408.                     case 'S':
  409.                         int x = 0;
  410.                         int y= -nbdep;
  411.                         break;
  412.                     case 'E':
  413.                         int x = nbdep;
  414.                         int y = 0;
  415.                         break;
  416.                     case 'W':
  417.                         int x = -nbdep;
  418.                         int y = 0;
  419.                         break;
  420.                     default:
  421.                         return 'E';
  422.                         break;
  423.                 }
  424.  
  425.  
  426.                 //resultat de la position future du pion
  427.  
  428.                 //Code N
  429.                 if(plateau[3+(y)][nbChiffre+(x)] == NULL){
  430.                     plateau[3+(y)][nbChiffre+(x) == plateau[3][nbChiffre];
  431.                     plateau[3][nbChiffre] == NULL;
  432.                     return 'N';
  433.                 }
  434.  
  435.                 //Code B
  436.                 if(plateau[3+(y)][nbChiffre+(x)] != NULL){
  437.                    plateau[3+(y)][nbChiffre+(x)] = battle(plateau[3][nbChiffre],plateau[3+(y)][nbChiffre+(x)]);
  438.                    if(plateau[3+(y)][nbChiffre+(x)]== 'E')
  439.                    {
  440.                     return 'E'
  441.                    }
  442.                    if(plateau[3+(y)][nbChiffre+(x)]== 'Z')
  443.                    {
  444.                     return 'Z'
  445.                    }
  446.                     plateau[3][nbChiffre] == NULL;
  447.                     return 'B';
  448.                 }
  449.  
  450.             }
  451.             break;
  452.  
  453.  
  454.         case 'E':
  455.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  456.             char *pieceChiffre = strtok(piece,"E");
  457.             int nbChiffre = atoi(pieceChiffre);
  458.             if(plateau[4][nbChiffre] == NULL)
  459.             {
  460.                 return 'E';
  461.             }
  462.             else
  463.             {
  464.  
  465.                 //determine nombre de deplacement
  466.                 int nbdep = atoi(nbdeplacement);
  467.  
  468.                 // détermine la direction du déplacement
  469.                 switch (dir[0])
  470.                 {
  471.                     case 'N':
  472.                         deplacementpiece
  473.                         int x = 0;
  474.                         int y = nbdep;
  475.                         break;
  476.                     case 'S':
  477.                         int x = 0;
  478.                         int y= -nbdep;
  479.                         break;
  480.                     case 'E':
  481.                         int x = nbdep;
  482.                         int y = 0;
  483.                         break;
  484.                     case 'W':
  485.                         int x = -nbdep;
  486.                         int y = 0;
  487.                         break;
  488.                     default:
  489.                         return 'E';
  490.                         break;
  491.                 }
  492.  
  493.  
  494.                 //resultat de la position future du pion
  495.  
  496.                 //Code N
  497.                 if(plateau[4+(y)][nbChiffre+(x)] == NULL){
  498.                     plateau[4+(y)][nbChiffre+(x) == plateau[4][nbChiffre];
  499.                     plateau[4][nbChiffre] == NULL;
  500.                     return 'N';
  501.                 }
  502.  
  503.                 //Code B
  504.                 if(plateau[4+(y)][nbChiffre+(x)] != NULL){
  505.                    plateau[4+(y)][nbChiffre+(x)] = battle(plateau[4][nbChiffre],plateau[4+(y)][nbChiffre+(x)]);
  506.                    if(plateau[4+(y)][nbChiffre+(x)]== 'E')
  507.                    {
  508.                     return 'E'
  509.                    }
  510.                    if(plateau[4+(y)][nbChiffre+(x)]== 'Z')
  511.                    {
  512.                     return 'Z'
  513.                    }
  514.                     plateau[4][nbChiffre] == NULL;
  515.                     return 'B';
  516.                 }
  517.  
  518.             }
  519.             break;
  520.  
  521.         case 'F':
  522.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  523.             char *pieceChiffre = strtok(piece,"F");
  524.             int nbChiffre = atoi(pieceChiffre);
  525.             if(plateau[5][nbChiffre] == NULL)
  526.             {
  527.                 return 'E';
  528.             }
  529.             else
  530.             {
  531.  
  532.                 //determine nombre de deplacement
  533.                 int nbdep = atoi(nbdeplacement);
  534.  
  535.                 // détermine la direction du déplacement
  536.                 switch (dir[0])
  537.                 {
  538.                     case 'N':
  539.                         deplacementpiece
  540.                         int x = 0;
  541.                         int y = nbdep;
  542.                         break;
  543.                     case 'S':
  544.                         int x = 0;
  545.                         int y= -nbdep;
  546.                         break;
  547.                     case 'E':
  548.                         int x = nbdep;
  549.                         int y = 0;
  550.                         break;
  551.                     case 'W':
  552.                         int x = -nbdep;
  553.                         int y = 0;
  554.                         break;
  555.                     default:
  556.                         return 'E';
  557.                         break;
  558.                 }
  559.  
  560.  
  561.                 //resultat de la position future du pion
  562.  
  563.                 //Code N
  564.                 if(plateau[5+(y)][nbChiffre+(x)] == NULL){
  565.                     plateau[5+(y)][nbChiffre+(x) == plateau[5][nbChiffre];
  566.                     plateau[5][nbChiffre] == NULL;
  567.                     return 'N';
  568.                 }
  569.  
  570.                 //Code B
  571.                 if(plateau[5+(y)][nbChiffre+(x)] != NULL){
  572.                    plateau[5+(y)][nbChiffre+(x)] = battle(plateau[5][nbChiffre],plateau[5+(y)][nbChiffre+(x)]);
  573.                    if(plateau[5+(y)][nbChiffre+(x)]== 'E')
  574.                    {
  575.                     return 'E'
  576.                    }
  577.                    if(plateau[5+(y)][nbChiffre+(x)]== 'Z')
  578.                    {
  579.                     return 'Z'
  580.                    }
  581.                     plateau[5][nbChiffre] == NULL;
  582.                     return 'B';
  583.                 }
  584.  
  585.             }
  586.             break;
  587.  
  588.         case 'G':
  589.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  590.             char *pieceChiffre = strtok(piece,"G");
  591.             int nbChiffre = atoi(pieceChiffre);
  592.             if(plateau[6][nbChiffre] == NULL)
  593.             {
  594.                 return 'E';
  595.             }
  596.             else
  597.             {
  598.  
  599.                 //determine nombre de deplacement
  600.                 int nbdep = atoi(nbdeplacement);
  601.  
  602.                 // détermine la direction du déplacement
  603.                 switch (dir[0])
  604.                 {
  605.                     case 'N':
  606.                         deplacementpiece
  607.                         int x = 0;
  608.                         int y = nbdep;
  609.                         break;
  610.                     case 'S':
  611.                         int x = 0;
  612.                         int y= -nbdep;
  613.                         break;
  614.                     case 'E':
  615.                         int x = nbdep;
  616.                         int y = 0;
  617.                         break;
  618.                     case 'W':
  619.                         int x = -nbdep;
  620.                         int y = 0;
  621.                         break;
  622.                     default:
  623.                         return 'E';
  624.                         break;
  625.                 }
  626.  
  627.  
  628.                 //resultat de la position future du pion
  629.  
  630.                 //Code N
  631.                 if(plateau[6+(y)][nbChiffre+(x)] == NULL){
  632.                     plateau[6+(y)][nbChiffre+(x) == plateau[6][nbChiffre];
  633.                     plateau[6][nbChiffre] == NULL;
  634.                     return 'N';
  635.                 }
  636.  
  637.                 //Code B
  638.                 if(plateau[6+(y)][nbChiffre+(x)] != NULL){
  639.                    plateau[6+(y)][nbChiffre+(x)] = battle(plateau[6][nbChiffre],plateau[6+(y)][nbChiffre+(x)]);
  640.                    if(plateau[6+(y)][nbChiffre+(x)]== 'E')
  641.                    {
  642.                     return 'E'
  643.                    }
  644.                    if(plateau[6+(y)][nbChiffre+(x)]== 'Z')
  645.                    {
  646.                     return 'Z'
  647.                    }
  648.                     plateau[6][nbChiffre] == NULL;
  649.                     return 'B';
  650.                 }
  651.  
  652.             }
  653.             break;
  654.  
  655.         case 'H':
  656.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  657.             char *pieceChiffre = strtok(piece,"H");
  658.             int nbChiffre = atoi(pieceChiffre);
  659.             if(plateau[7][nbChiffre] == NULL)
  660.             {
  661.                 return 'E';
  662.             }
  663.             else
  664.             {
  665.  
  666.                 //determine nombre de deplacement
  667.                 int nbdep = atoi(nbdeplacement);
  668.  
  669.                 // détermine la direction du déplacement
  670.                 switch (dir[0])
  671.                 {
  672.                     case 'N':
  673.                         deplacementpiece
  674.                         int x = 0;
  675.                         int y = nbdep;
  676.                         break;
  677.                     case 'S':
  678.                         int x = 0;
  679.                         int y= -nbdep;
  680.                         break;
  681.                     case 'E':
  682.                         int x = nbdep;
  683.                         int y = 0;
  684.                         break;
  685.                     case 'W':
  686.                         int x = -nbdep;
  687.                         int y = 0;
  688.                         break;
  689.                     default:
  690.                         return 'E';
  691.                         break;
  692.                 }
  693.  
  694.  
  695.                 //resultat de la position future du pion
  696.  
  697.                 //Code N
  698.                 if(plateau[7+(y)][nbChiffre+(x)] == NULL){
  699.                     plateau[7+(y)][nbChiffre+(x) == plateau[7][nbChiffre];
  700.                     plateau[7][nbChiffre] == NULL;
  701.                     return 'N';
  702.                 }
  703.  
  704.                 //Code B
  705.                 if(plateau[7+(y)][nbChiffre+(x)] != NULL){
  706.                    plateau[7+(y)][nbChiffre+(x)] = battle(plateau[7][nbChiffre],plateau[7+(y)][nbChiffre+(x)]);
  707.                    if(plateau[7+(y)][nbChiffre+(x)]== 'E')
  708.                    {
  709.                     return 'E'
  710.                    }
  711.                    if(plateau[7+(y)][nbChiffre+(x)]== 'Z')
  712.                    {
  713.                     return 'Z'
  714.                    }
  715.                     plateau[7][nbChiffre] == NULL;
  716.                     return 'B';
  717.                 }
  718.  
  719.             }
  720.             break;
  721.  
  722.  
  723.         case 'I':
  724.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  725.             char *pieceChiffre = strtok(piece,"I");
  726.             int nbChiffre = atoi(pieceChiffre);
  727.             if(plateau[8][nbChiffre] == NULL)
  728.             {
  729.                 return 'E';
  730.             }
  731.             else
  732.             {
  733.  
  734.                 //determine nombre de deplacement
  735.                 int nbdep = atoi(nbdeplacement);
  736.  
  737.                 // détermine la direction du déplacement
  738.                 switch (dir[0])
  739.                 {
  740.                     case 'N':
  741.                         deplacementpiece
  742.                         int x = 0;
  743.                         int y = nbdep;
  744.                         break;
  745.                     case 'S':
  746.                         int x = 0;
  747.                         int y= -nbdep;
  748.                         break;
  749.                     case 'E':
  750.                         int x = nbdep;
  751.                         int y = 0;
  752.                         break;
  753.                     case 'W':
  754.                         int x = -nbdep;
  755.                         int y = 0;
  756.                         break;
  757.                     default:
  758.                         return 'E';
  759.                         break;
  760.                 }
  761.  
  762.  
  763.                 //resultat de la position future du pion
  764.  
  765.                 //Code N
  766.                 if(plateau[8+(y)][nbChiffre+(x)] == NULL){
  767.                     plateau[8+(y)][nbChiffre+(x) == plateau[8][nbChiffre];
  768.                     plateau[8][nbChiffre] == NULL;
  769.                     return 'N';
  770.                 }
  771.  
  772.                 //Code B
  773.                 if(plateau[8+(y)][nbChiffre+(x)] != NULL){
  774.                    plateau[8+(y)][nbChiffre+(x)] = battle(plateau[8][nbChiffre],plateau[8+(y)][nbChiffre+(x)]);
  775.                    if(plateau[8+(y)][nbChiffre+(x)]== 'E')
  776.                    {
  777.                     return 'E'
  778.                    }
  779.                    if(plateau[8+(y)][nbChiffre+(x)]== 'Z')
  780.                    {
  781.                     return 'Z'
  782.                    }
  783.                     plateau[8][nbChiffre] == NULL;
  784.                     return 'B';
  785.                 }
  786.  
  787.             }
  788.             break;
  789.  
  790.         case 'J':
  791.              //determiner quelle chiffre a été envoyé afin de trouver la piece
  792.             char *pieceChiffre = strtok(piece,"J");
  793.             int nbChiffre = atoi(pieceChiffre);
  794.             if(plateau[9][nbChiffre] == NULL)
  795.             {
  796.                 return 'E';
  797.             }
  798.             else
  799.             {
  800.  
  801.                 //determine nombre de deplacement
  802.                 int nbdep = atoi(nbdeplacement);
  803.  
  804.                 // détermine la direction du déplacement
  805.                 switch (dir[0])
  806.                 {
  807.                     case 'N':
  808.                         deplacementpiece
  809.                         int x = 0;
  810.                         int y = nbdep;
  811.                         break;
  812.                     case 'S':
  813.                         int x = 0;
  814.                         int y= -nbdep;
  815.                         break;
  816.                     case 'E':
  817.                         int x = nbdep;
  818.                         int y = 0;
  819.                         break;
  820.                     case 'W':
  821.                         int x = -nbdep;
  822.                         int y = 0;
  823.                         break;
  824.                     default:
  825.                         return 'E';
  826.                         break;
  827.                 }
  828.  
  829.  
  830.                 //resultat de la position future du pion
  831.  
  832.                 //Code N
  833.                 if(plateau[9+(y)][nbChiffre+(x)] == NULL){
  834.                     plateau[9+(y)][nbChiffre+(x) == plateau[9][nbChiffre];
  835.                     plateau[9][nbChiffre] == NULL;
  836.                     return 'N';
  837.                 }
  838.  
  839.                 //Code B
  840.                 if(plateau[9+(y)][nbChiffre+(x)] != NULL){
  841.                    plateau[9+(y)][nbChiffre+(x)] = battle(plateau[9][nbChiffre],plateau[9+(y)][nbChiffre+(x)]);
  842.                    if(plateau[9+(y)][nbChiffre+(x)]== 'E')
  843.                    {
  844.                     return 'E'
  845.                    }
  846.                    if(plateau[9+(y)][nbChiffre+(x)]== 'Z')
  847.                    {
  848.                     return 'Z'
  849.                    }
  850.                     plateau[9][nbChiffre] == NULL;
  851.                     return 'B';
  852.                 }
  853.  
  854.             }
  855.             break;
  856.  
  857.         default:
  858.             return 'E';
  859.             break;
  860.     }
  861.  
  862. }
  863.  
  864. //function to handle battle between players
  865. char battle(char plateaujAttaquant, char plateaujAttaque)
  866. {
  867.     char message[BUFSIZE];
  868.     char message1[BUFSIZE];
  869.  
  870.     //saisi des valeurs
  871.     sprintf(message, "%s\n",plateaujAttaquant);
  872.     sprintf(message1, "%s\n", plateaujAttaque);
  873.  
  874.     // ouverture du tube pour joueur 0 en écriture
  875.     int fd = open ("p0write", O_WRONLY);
  876.     if(fd!=-1)
  877.     {
  878.         //ecrite le texte dans le tube
  879.         write(fd,message,strlen(message));
  880.         write(fd,message1,strlen(message1));
  881.     }
  882.     else
  883.     {
  884.         printf("Pipe no possible");
  885.     }
  886.     close(fd);
  887.  
  888.     // ouverture du tube pour joueur 1 en écriture
  889.     int fd = open ("p1write", O_WRONLY);
  890.     if(fd!=-1)
  891.     {
  892.         //Write to pipe
  893.        //Write to pipe
  894.         write(fd,message,strlen(message));
  895.         write(fd,message1,strlen(message1));
  896.     }
  897.     else
  898.     {
  899.         printf("Pipe no possible");
  900.     }
  901.     close(fd);
  902.  
  903.     //cas où le drapeau est trouvé
  904.     if(plateaujAttaque=='11')
  905.     {
  906.         return 'Z';
  907.  
  908.     }
  909.  
  910.     //Handle who get the location
  911.     switch (plateaujAttaquant[0])
  912.     {
  913.         case '1':
  914.                 if(plateaujAttaque=='12')
  915.                 {
  916.                     return plateaujAttaque;
  917.                 }
  918.                 return plateaujAttaquant;
  919.             break;
  920.         case '2':
  921.                 if(plateaujAttaque!='1')
  922.                 {
  923.                     return plateaujAttaquant;
  924.                 }
  925.                 return plateaujAttaque;
  926.             break;
  927.         case '3':
  928.                 if((plateaujAttaque!='1') || (plateaujAttaque!='2'))
  929.                 {
  930.                     return plateaujAttaquant;
  931.                 }
  932.                 return plateaujAttaque;
  933.             break;
  934.         case '4':
  935.                  if((plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3'))
  936.                 {
  937.                     return plateaujAttaquant;
  938.                 }
  939.                 return plateaujAttaque;
  940.             break;
  941.         case '5':
  942.                  if((plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3')|| (plateaujAttaque!='4'))
  943.                 {
  944.                     return plateaujAttaquant;
  945.                 }
  946.                 return plateaujAttaque;
  947.             break;
  948.         case '6':
  949.                 if((plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3')|| (plateaujAttaque!='4')|| (plateaujAttaque!='5'))
  950.                 {
  951.                     return plateaujAttaquant;
  952.                 }
  953.                 return plateaujAttaque;
  954.             break;
  955.         case '7':
  956.                 if((plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3')|| (plateaujAttaque!='4')|| (plateaujAttaque!='5')|| (plateaujAttaque!='6'))
  957.                 {
  958.                     return plateaujAttaquant;
  959.                 }
  960.                 return plateaujAttaque;
  961.             break;
  962.         case '8':
  963.                  if(plateaujAttaque!='12') ||(plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3')|| (plateaujAttaque!='4')|| (plateaujAttaque!='5')|| (plateaujAttaque!='6')|| (plateaujAttaque!='7'))
  964.                 {
  965.                     return plateaujAttaquant;
  966.                 }
  967.                 return plateaujAttaque;
  968.             break;
  969.         case '9':
  970.                 if((plateaujAttaque!='1') || (plateaujAttaque!='2')|| (plateaujAttaque!='3')|| (plateaujAttaque!='4')|| (plateaujAttaque!='5')|| (plateaujAttaque!='6')|| (plateaujAttaque!='7')|| (plateaujAttaque!='8'))
  971.                 {
  972.                     return plateaujAttaquant;
  973.                 }
  974.                 return plateaujAttaque;
  975.             break;
  976.         case '10':
  977.                 if(plateaujAttaque==1)
  978.                 {
  979.                     return plateaujAttaquant;
  980.                 }
  981.                 return plateaujAttaque;
  982.             break;
  983.         default:
  984.             printf("Impossible move !");
  985.             return 'E';
  986.             break;
  987.     }
  988.  
  989.  
  990. }
  991.  
  992.  
  993. int main (int argc, char * argv[])
  994. {
  995.     char message[BUFSIZE];
  996.     char plateau[10][10];
  997.     char *deplacement;
  998.     char resultatDeplacement;
  999.     int i;
  1000.     int j;
  1001.     int n;
  1002.  
  1003.     //get player0 input
  1004.     sprintf(message, "%d\n",0);
  1005.  
  1006.     //send value to p0
  1007.     //Opening pipe for p0 with write right
  1008.     int fd = open ("p0write", O_WRONLY);
  1009.     if(fd!=-1)
  1010.     {
  1011.         //Write text to pipe
  1012.         write(fd,message,strlen(message));
  1013.     }
  1014.     else
  1015.     {
  1016.         printf("Pipe no possible");
  1017.     }
  1018.     close(fd);
  1019.  
  1020.     //get p0 conf
  1021.     //opening read only pipe
  1022.     fd = open ("p0read", O_RDONLY);
  1023.     if(fd!=-1)
  1024.     {
  1025.         //read loop
  1026.         while(n = read(fd,&message,1)>0)
  1027.         {
  1028.             for(i=0;i<4;i++)
  1029.             {
  1030.                 for(j=0;j<10;j++)
  1031.                 {
  1032.                     plateau[i][j]= &message;
  1033.                 }
  1034.             }
  1035.         }
  1036.  
  1037.     }
  1038.     else
  1039.     {
  1040.         printf("Pipe no possible");
  1041.     }
  1042.     close(fd);
  1043.  
  1044.     //Check conf
  1045.     int config = verifconfigj0(plateau);
  1046.     if (config == 0)
  1047.     {
  1048.         printf("KO");
  1049.         exit(1);
  1050.     }
  1051.     printf("OK");
  1052.  
  1053.      //Enter player value
  1054.     sprintf(message, "%d\n",1);
  1055.  
  1056.     //Send player value to p1
  1057.     //Opening pipe for p1 with write access
  1058.     int fd = open ("p1write", O_WRONLY);
  1059.     if(fd!=-1)
  1060.     {
  1061.         //Write to pipe
  1062.         write(fd,message,strlen(message));
  1063.     }
  1064.     else
  1065.     {
  1066.         printf("Pipe no possible");
  1067.     }
  1068.     close(fd);
  1069.  
  1070.  
  1071.     //Open pipe for p1 in read only
  1072.     fd = open ("p1read", O_RDONLY);
  1073.         //read loop
  1074.         while(n = read(fd,&message,1)>0)
  1075.         {
  1076.             for(i=6;i<10;i++)
  1077.             {
  1078.                 for(j=0;j<10;j++)
  1079.                 {
  1080.                     plateau[i][j]= &message;
  1081.                 }
  1082.             }
  1083.         }
  1084.     close(fd);
  1085.  
  1086.      //Check conf
  1087.     config = verifconfigj1(plateau)
  1088.     if(config ==0)
  1089.     {
  1090.         printf("KO");
  1091.         exit(1);
  1092.     }
  1093.  
  1094.     //infinite loop
  1095.     //move j0 piece and show the result
  1096.     //move j1 piece and show the result
  1097.  
  1098.     while(1)
  1099.     {
  1100.         //player0
  1101.  
  1102.         printf("Player 0\n");
  1103.         fd = open ("p0read", O_RDONLY);
  1104.         if(fd!=-1)
  1105.         {
  1106.             //read loop
  1107.             while(n = read(fd,&message,1)>0)
  1108.             {
  1109.                 deplacement=&message;
  1110.             }
  1111.  
  1112.         }
  1113.         else
  1114.         {
  1115.             printf("Pipe no possible");
  1116.         }
  1117.         close(fd);
  1118.  
  1119.         resultatDeplacement = result(plateau,deplacement);
  1120.  
  1121.         if(resultatDeplacement=='Z')
  1122.         {
  1123.             printf("Flag !! Player 0 win !");
  1124.             exit(0);
  1125.         }
  1126.  
  1127.         sprintf(message, "%s\n",resultatDeplacement);
  1128.  
  1129.         if(resultatDeplacement=='E')
  1130.         {
  1131.             fd = open ("p0write", O_WRONLY);
  1132.             if(fd!=-1)
  1133.             {
  1134.                 //Write text to pipe
  1135.                 write(fd,message,strlen(message));
  1136.             }
  1137.             else
  1138.             {
  1139.                 printf("Pipe no possible");
  1140.             }
  1141.             close(fd);
  1142.             exit(1);
  1143.         }
  1144.  
  1145.         fd = open ("p0write", O_WRONLY);
  1146.             if(fd!=-1)
  1147.             {
  1148.                 //Write text to pipe
  1149.                 write(fd,message,strlen(message));
  1150.             }
  1151.             else
  1152.             {
  1153.                 printf("Pipe no possible");
  1154.             }
  1155.             close(fd);
  1156.  
  1157.             //player1
  1158.  
  1159.         printf("Player 1\n");
  1160.         fd = open ("p1read", O_RDONLY);
  1161.         if(fd!=-1)
  1162.         {
  1163.             //read loop
  1164.             while(n = read(fd,&message,1)>0)
  1165.             {
  1166.                 deplacement=&message;
  1167.             }
  1168.  
  1169.         }
  1170.         else
  1171.         {
  1172.             printf("Pipe no possible");
  1173.         }
  1174.         close(fd);
  1175.  
  1176.         resultatDeplacement = result(plateau,deplacement);
  1177.  
  1178.         if(resultatDeplacement=='Z')
  1179.         {
  1180.             printf("Flag !! Player 1 win !");
  1181.             exit(0);
  1182.         }
  1183.  
  1184.         sprintf(message, "%s\n",resultatDeplacement);
  1185.  
  1186.         if(resultatDeplacement=='E')
  1187.         {
  1188.             fd = open ("j1write", O_WRONLY);
  1189.             if(fd!=-1)
  1190.             {
  1191.                 //Write text to pipe
  1192.                 write(fd,message,strlen(message));
  1193.             }
  1194.             else
  1195.             {
  1196.                 printf("Pipe no possible");
  1197.             }
  1198.             close(fd);
  1199.             exit(1);
  1200.         }
  1201.  
  1202.         fd = open ("j1write", O_WRONLY);
  1203.             if(fd!=-1)
  1204.             {
  1205.                 //Write text to pipe
  1206.                 write(fd,message,strlen(message));
  1207.             }
  1208.             else
  1209.             {
  1210.                 printf("Pipe no possible");
  1211.             }
  1212.             close(fd);
  1213.  
  1214.     }
  1215.  
  1216.  
  1217.     return 0;
  1218. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!