SHARE
TWEET

Untitled

a guest May 25th, 2019 71 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <windows.h>
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <cstdlib>
  5. #include <string>
  6.  
  7. //esto es otra prueba
  8. using namespace std;
  9.  
  10. //Estructuras
  11. struct coordenadas{
  12.     int x;
  13.     int y;
  14. };
  15.  
  16. //Variables globales
  17. int arr[8][8] = {};
  18. bool jaqueMate=false;
  19. int teamCount = 1;
  20.  
  21. //Prototipos de las funciones
  22. bool isValidInt(string numeroEnCadena);
  23. void imprimirLetra(int cordLetra);
  24. int cinOpcionValida(int top);
  25. bool mismoEquipo(int piezaAMover, int piezaTope);
  26. void inicializarTablero();
  27. void board_set();
  28. void moverPieza(coordenadas *options);
  29. void moverPeon(int iCord , int jCord, coordenadas *options);
  30. void moverTorre(int iCord , int jCord, coordenadas *options);
  31. void moverCaballo(int iCord , int jCord, coordenadas *options);
  32. void moverAlfil(int iCord , int jCord, coordenadas *options);
  33. void moverReina(int iCord , int jCord, coordenadas *options);
  34. void moverRey(int iCord , int jCord, coordenadas *options);
  35.  
  36. int main()
  37. {
  38.     coordenadas *tempArr;
  39.     try{
  40.     tempArr = new coordenadas[64];
  41.     }catch(...){
  42.         cout << "Error fatal, el programa terminara";
  43.     }
  44.  
  45.     inicializarTablero();
  46.  
  47.  
  48.     do{
  49.     board_set();
  50.     moverPieza(tempArr);
  51.     board_set();
  52.     teamCount++;
  53.     }while(!jaqueMate);
  54.  
  55.     system("pause");
  56.  
  57.     delete [] tempArr;
  58.  
  59.     return 0;
  60. }
  61.  
  62. //FUNCIONES:
  63.  
  64. void moverPieza(coordenadas *options){
  65.     string tempX;
  66.     int coorX=0, coorY=0;
  67.     bool ban=false;
  68.     //Pide las coordenadas de la pieza a mover y verifica que sea coordenadas validas.
  69.     do{
  70.         try{
  71.             cout << "Ingresa la fila de la pieza a mover (a-h)" << endl;
  72.             cin>>tempX;
  73.  
  74.             if(tempX.size()>1) throw "NO EXISTE ESA COLUMNA (1-8)\n"; /** si introducen un string con longitud mayor a 1 se levanta una excepcion **/
  75.  
  76.             if(!(int(tempX[0])>= 97 && int(tempX[0])<=104)) throw "NO EXISTE ESA COLUMNA (1-8)\n"; /** si introducen un char que no este entre a y h levanta una excepcion**/
  77.  
  78.             cout << "Ingresa la columna de la pieza a mover (1-8)" << endl;
  79.  
  80.             coorY = cinOpcionValida(8); /** Nos aseguramos de que ingrese un entero valido, consultar la funcion para mayor detalle **/
  81.  
  82.             if(coorY == 0) throw "NO EXISTE ESA COLUMNA (1-8)\n"; /** Si nos ingresan 0 levantamos una excepcion (la funcion anterior solo se asegura de que no sean numeros enormes, negativos o cadenas )**/
  83.  
  84.             coorY--;
  85.  
  86.             ban=true; //La bandera se convierte en verdadera, esto significa que las coordenadas son validas y por ende sale del do while
  87.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  88.             system("cls");
  89.             cout << ex << endl << endl;
  90.             system("pause");
  91.             system("cls");
  92.             board_set();
  93.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  94.            system("cls");
  95.             cout << "NO EXISTE ESA COLUMNA (1-8)\n" << endl << endl;
  96.             system("pause");
  97.             system("cls");
  98.             board_set();
  99.         }
  100.  
  101.     }while(!ban);
  102.  
  103.     switch(tempX[0]){ //Convierte las filas (a-h) en numeros para manejarlo en el arreglo
  104.         case 'a':
  105.             coorX=0;
  106.         break;
  107.         case 'b':
  108.             coorX=1;
  109.         break;
  110.         case 'c':
  111.             coorX=2;
  112.         break;
  113.         case 'd':
  114.             coorX=3;
  115.         break;
  116.         case 'e':
  117.             coorX=4;
  118.         break;
  119.         case 'f':
  120.             coorX=5;
  121.         break;
  122.         case 'g':
  123.             coorX=6;
  124.         break;
  125.         case 'h':
  126.             coorX=7;
  127.         break;
  128.     }
  129.     if(teamCount % 2 != 0){
  130.         switch(arr[coorX][coorY]){ //Dependiendo de la pieza que desea mover llama la funcion correspondiente
  131.             case 1:
  132.                 system("cls");
  133.                 board_set();
  134.                 cout << "SELECCIONASTE EL PEON (" << tempX << "," << coorY+1 << ")" << endl << endl;
  135.                 moverPeon(coorX, coorY, options);
  136.             break;
  137.             case 2:
  138.                 system("cls");
  139.                 board_set();
  140.                 cout << "SELECCIONASTE LA TORRE (" << tempX << "," << coorY+1 << ")" << endl << endl;
  141.                 moverTorre(coorX, coorY,options);
  142.             break;
  143.             case 3:
  144.                 system("cls");
  145.                 board_set();
  146.                 cout << "SELECCIONASTE EL CABALLO (" << tempX << "," << coorY+1 << ")" << endl << endl;
  147.                 moverCaballo(coorX, coorY, options);
  148.             break;
  149.             case 4:
  150.                 system("cls");
  151.                 board_set();
  152.                 cout << "SELECCIONASTE EL ALFIL (" << tempX << "," << coorY+1 << ")" << endl << endl;
  153.                 moverAlfil(coorX, coorY, options);
  154.             break;
  155.             case 5:
  156.                 system("cls");
  157.                 board_set();
  158.                 cout << "SELECCIONASTE LA REINA (" << tempX << "," << coorY+1 << ")" << endl << endl;
  159.                 moverReina(coorX, coorY, options);
  160.             break;
  161.             case 6:
  162.                 system("cls");
  163.                 board_set();
  164.                 cout << "SELECCIONASTE EL REY (" << tempX << "," << coorY+1 << ")" << endl << endl;
  165.                 moverRey(coorX, coorY, options);
  166.             break;
  167.             default:
  168.                 cout << "No existe pieza en esa coordenada" << endl;
  169.                 teamCount--;
  170.                 system("pause");
  171.         }
  172.     }else{
  173.         switch(arr[coorX][coorY]){ //Dependiendo de la pieza que desea mover llama la funcion correspondiente
  174.             case -1:
  175.                 system("cls");
  176.                 board_set();
  177.                 cout << "SELECCIONASTE EL PEON (" << tempX << "," << coorY+1 << ")" << endl << endl;
  178.                 moverPeon(coorX, coorY, options);
  179.             break;
  180.             case -2:
  181.                 system("cls");
  182.                 board_set();
  183.                 cout << "SELECCIONASTE LA TORRE (" << tempX << "," << coorY+1 << ")" << endl << endl;
  184.                 moverTorre(coorX, coorY,options);
  185.             break;
  186.             case -3:
  187.                 system("cls");
  188.                 board_set();
  189.                 cout << "SELECCIONASTE EL CABALLO (" << tempX << "," << coorY+1 << ")" << endl << endl;
  190.                 moverCaballo(coorX, coorY, options);
  191.             break;
  192.             case -4:
  193.                 system("cls");
  194.                 board_set();
  195.                 cout << "SELECCIONASTE EL ALFIL (" << tempX << "," << coorY+1 << ")" << endl << endl;
  196.                 moverAlfil(coorX, coorY, options);
  197.             break;
  198.             case -5:
  199.                 system("cls");
  200.                 board_set();
  201.                 cout << "SELECCIONASTE LA REINA (" << tempX << "," << coorY+1 << ")" << endl << endl;
  202.                 moverReina(coorX, coorY, options);
  203.             break;
  204.             case -6:
  205.                 system("cls");
  206.                 board_set();
  207.                 cout << "SELECCIONASTE EL REY (" << tempX << "," << coorY+1 << ")" << endl << endl;
  208.                 moverRey(coorX, coorY, options);
  209.             break;
  210.             default:
  211.                 cout << "No existe pieza en esa coordenada" << endl;
  212.                 teamCount--;
  213.                 system("pause");
  214.         }
  215.     }
  216.  
  217. }
  218.  
  219. void imprimirLetra(int cordLetra){
  220.     switch(cordLetra){
  221.         case 0:
  222.         cout << "a,";
  223.         break;
  224.         case 1:
  225.         cout << "b,";
  226.         break;
  227.         case 2:
  228.         cout << "c,";
  229.         break;
  230.         case 3:
  231.         cout << "d,";
  232.         break;
  233.         case 4:
  234.         cout << "e,";
  235.         break;
  236.         case 5:
  237.         cout << "f,";
  238.         break;
  239.         case 6:
  240.         cout << "g,";
  241.         break;
  242.         case 7:
  243.         cout << "h,";
  244.         break;
  245.     }
  246. }
  247.  
  248. int cinOpcionValida(int top){
  249.     string dummy; /** string para poder recibir cualquier caracter **/
  250.     cin >> dummy;
  251.     if(!isValidInt(dummy)) /** funcion que se asegura que no sea una cadena, o un numero negativo, consultar la funcion para mayor detalle **/
  252.         throw "Favor de solo introducir numeros positivos ";
  253.  
  254.     int eleccion = stoi(dummy); /** convertimos nuestro string a un entero **/
  255.  
  256.     if(eleccion == 0) /** si la opcion es 0 la retornamos ya que 0 es la opcion de cancelar la jugada **/
  257.         return eleccion;
  258.  
  259.     if(eleccion > top) /** top corresponde al counter de la funcion que invoco esta funcion, counter es la cantidad de opciones que tiene el usuario,
  260.         si introducimos un valor mayor, arrojamos una excepcion**/
  261.         throw "Favor de introducir un numero menor o igual a las opciones disponibles ";
  262.  
  263.     return eleccion; /** si todo salio bien retornamos el valor ingresado **/
  264. }
  265.  
  266. bool mismoEquipo(int piezaAMover, int piezaTope){
  267.     if(piezaAMover < 0){ /** entra si la pieza a mover es negativa **/
  268.         return (piezaTope < 0); /** retorna verdadero si la pieza ocupando la posicion a la que nos queremos mover es negativa tambien **/
  269.     }else{ /** las siguientes lineas hacen lo mismo pero para cuando la pieza a mover sea positiva **/
  270.         return (piezaTope > 0);
  271.     }
  272. }
  273.  
  274. void moverTorre(int iCord , int jCord, coordenadas *options){
  275.     int iCordTemp = iCord;
  276.     int jCordTemp = jCord;
  277.     int counter = 0;
  278.     int eleccion;
  279.  
  280.     bool check = 1;
  281.     while(check){ /** Movimiento hacia arriba**/
  282.         iCordTemp--;
  283.         if(iCordTemp < 0){ /** Nos aseguramos que no se salga del los limites del tablero **/
  284.             check = 0;
  285.         }else if(arr[iCordTemp][jCord]==0){ /** checamos que sea una casilla vacia, si esta condicion no se cumple, llegamos a una pieza **/
  286.             options[counter].x = iCordTemp;
  287.             options[counter].y = jCordTemp;
  288.             counter++;
  289.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){ /** si es una pieza del mismo equipo de la que vamos a mover, se detiene**/
  290.             check = 0;
  291.         }else{  /** si es del equipo contrario, la podemos comer y se detiene **/
  292.             options[counter].x = iCordTemp;
  293.             options[counter].y = jCordTemp;
  294.             counter++;
  295.             check = 0;
  296.         }
  297.     }
  298.  
  299.     iCordTemp = iCord; /** Restauramos nuestra temporal despues de haberla modificado en el while anterior **/
  300.     check = 1;
  301.     while(check){ /** Movimiento hacia la derecha**/
  302.         jCordTemp++;
  303.         if(jCordTemp > 7){
  304.             check = 0;
  305.         }else if(arr[iCord][jCordTemp]==0){
  306.             options[counter].x = iCordTemp;
  307.             options[counter].y = jCordTemp;
  308.             counter++;
  309.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCord][jCordTemp])){
  310.             check = 0;
  311.         }else{
  312.             options[counter].x = iCordTemp;
  313.             options[counter].y = jCordTemp;
  314.             counter++;
  315.             check = 0;
  316.         }
  317.     }
  318.  
  319.     jCordTemp = jCord;
  320.     check = 1;
  321.     while(check){ /** Movimiento hacia abajo**/
  322.         iCordTemp++;
  323.         if(iCordTemp > 7){
  324.             check = 0;
  325.         }else if(arr[iCordTemp][jCord]==0){
  326.             options[counter].x = iCordTemp;
  327.             options[counter].y = jCordTemp;
  328.             counter++;
  329.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  330.             check = 0;
  331.         }else{
  332.             options[counter].x = iCordTemp;
  333.             options[counter].y = jCordTemp;
  334.             counter++;
  335.             check = 0;
  336.         }
  337.     }
  338.  
  339.     iCordTemp = iCord;
  340.     check = 1;
  341.     while(check){ /** Movimiento hacia la izquierda**/
  342.         jCordTemp--;
  343.         if(jCordTemp < 0){
  344.             check = 0;
  345.         }else if(arr[iCord][jCordTemp]==0){
  346.             options[counter].x = iCordTemp;
  347.             options[counter].y = jCordTemp;
  348.             counter++;
  349.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCord][jCordTemp])){
  350.             check = 0;
  351.         }else{
  352.             options[counter].x = iCordTemp;
  353.             options[counter].y = jCordTemp;
  354.             counter++;
  355.             check = 0;
  356.         }
  357.     }
  358.  
  359.     if(counter == 0){
  360.         cout << "Esta pieza no se puede mover hacia ninguna casilla" << endl; /** Si el counter no aumento, quiere decir que no hay movimientos posibles**/
  361.         system("pause");
  362.         teamCount--;
  363.         return;
  364.     }
  365.     cout << "Se puede mover a las siguientes opciones:" << endl;
  366.     cout << "Seleccione 0 para cambiar de jugada" << endl;
  367.     for(int i = 0 ; i < counter ; i++){ /** for para imprimir las opciones que tiene el usuario **/
  368.         cout << "#" << i+1 << ":";
  369.         imprimirLetra(options[i].x);
  370.         cout << (options[i].y)+1 << endl;
  371.     }
  372.  
  373.     cout << "Escoge tu opcion ";
  374.     check = 1; /** variable de control **/
  375.     while(check == 1){ /** ciclo para asegurarnos de recibir datos validos **/
  376.         try{
  377.             check = 0;
  378.             eleccion = cinOpcionValida(counter); /** nos aseguramos que el dato de entrada cumpla con varias caracterizticas, consultar la funcion para mayor detalle **/
  379.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  380.             cout << "Favor de introducir un numero menor o igual a las opciones disponibles \n";
  381.             check = 1;
  382.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  383.             cout << ex << endl;
  384.             check = 1;
  385.         }catch(...){
  386.             cout << "Error desconocido";
  387.             exit(1);
  388.         }
  389.     }
  390.     if(eleccion != 0){ /** si introducen 0 cancelan su jugada **/
  391.         arr[options[eleccion-1].x][options[eleccion-1].y] = arr[iCord][jCord];
  392.         arr[iCord][jCord] = 0;
  393.     }else{
  394.         cout << "Has cancelado la jugada" << endl;
  395.         system("pause");
  396.         system("cls");
  397.         board_set();
  398.         moverPieza(options);
  399.     }
  400. }
  401.  
  402. void moverCaballo(int iCord , int jCord, coordenadas *options){
  403.  
  404.     int iCordTemp = iCord;
  405.     int jCordTemp = jCord;
  406.     int counter = 0;
  407.     int eleccion;
  408.  
  409.     iCordTemp -= 2; /** El caballo se mueve 2 hacia arriba y 1 a la derecha **/
  410.     jCordTemp--;
  411.  
  412.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){ // checa que no se salga del tablero
  413.        if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  414.            options[counter].x = iCordTemp; // le da valor a la cordenada i de nuestra primer opcion
  415.            options[counter].y = jCordTemp; // le da valor a la cordenada j de nuestra primer opcion
  416.            counter++; // aumentamos el contador
  417.        }
  418.     }
  419.  
  420.     jCordTemp = jCord + 1; /** el caballo se mueve 2 hacia arriba y 1 a la derecha **/
  421.  
  422.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  423.       if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  424.            options[counter].x = iCordTemp;
  425.            options[counter].y = jCordTemp;
  426.            counter++;
  427.        }
  428.     }
  429.  
  430.     iCordTemp = iCord - 1; /** el caballo se mueve 2 hacia la derecha y 1 hacia arriba **/
  431.     jCordTemp = jCord + 2;
  432.  
  433.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  434.       if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  435.            options[counter].x = iCordTemp;
  436.            options[counter].y = jCordTemp;
  437.            counter++;
  438.        }
  439.     }
  440.  
  441.     iCordTemp = iCord + 1; /** el caballo se mueve 2 hacia la derecha y 1 hacia abajo **/
  442.     jCordTemp = jCord + 2;
  443.  
  444.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  445.        if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  446.            options[counter].x = iCordTemp;
  447.            options[counter].y = jCordTemp;
  448.            counter++;
  449.        }
  450.     }
  451.  
  452.     iCordTemp = iCord + 2; /** el caballo se mueve 2 hacia abajo y 1 a la derecha **/
  453.     jCordTemp = jCord + 1;
  454.  
  455.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  456.        if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  457.            options[counter].x = iCordTemp;
  458.            options[counter].y = jCordTemp;
  459.            counter++;
  460.        }
  461.     }
  462.  
  463.     iCordTemp = iCord + 2; /** el caballo se mueve 2 hacia abajo y 1 a la izquierda **/
  464.     jCordTemp = jCord - 1;
  465.  
  466.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  467.        if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  468.            options[counter].x = iCordTemp;
  469.            options[counter].y = jCordTemp;
  470.            counter++;
  471.        }
  472.     }
  473.  
  474.     iCordTemp = iCord + 1; /** el caballo se mueve 2 hacia la izquierda y 1 hacia abajo **/
  475.     jCordTemp = jCord - 2;
  476.  
  477.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){ // checa que no se salg
  478.         if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  479.            options[counter].x = iCordTemp;
  480.            options[counter].y = jCordTemp;
  481.            counter++;
  482.        }
  483.     }
  484.  
  485.     iCordTemp = iCord - 1; /** el caballo se mueve 2 hacia la izquierda y 1 hacia arriba **/
  486.     jCordTemp = jCord - 2;
  487.  
  488.     if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  489.        if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp])){ // checa si es el mismo equipo
  490.            options[counter].x = iCordTemp;
  491.            options[counter].y = jCordTemp;
  492.            counter++;
  493.        }
  494.     }
  495.  
  496.     if(counter == 0){
  497.         cout << "Esta pieza no se puede mover hacia ninguna casilla" << endl; /** Si el counter no aumento, quiere decir que no hay movimientos posibles**/
  498.         system("pause");
  499.         teamCount--;
  500.         return;
  501.     }
  502.     cout << "Se puede mover a las siguientes opciones:" << endl;
  503.     cout << "Seleccione 0 para cambiar de jugada" << endl;
  504.     for(int i = 0 ; i < counter ; i++){ /** for para imprimir las opciones que tiene el usuario **/
  505.         cout << "#" << i+1 << ":";
  506.         imprimirLetra(options[i].x);
  507.         cout << (options[i].y)+1 << endl;
  508.     }
  509.  
  510.     cout << "Escoge tu opcion ";
  511.     bool check = 1; /** variable de control **/
  512.     while(check == 1){ /** ciclo para asegurarnos de recibir datos validos **/
  513.         try{
  514.             check = 0;
  515.             eleccion = cinOpcionValida(counter); /** nos aseguramos que el dato de entrada cumpla con varias caracterizticas, consultar la funcion para mayor detalle **/
  516.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  517.             cout << "Favor de introducir un numero menor o igual a las opciones disponibles \n";
  518.             check = 1;
  519.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  520.             cout << ex << endl;
  521.             check = 1;
  522.         }catch(...){
  523.             cout << "Error desconocido";
  524.             exit(1);
  525.         }
  526.     }
  527.     if(eleccion != 0){ /** si introducen 0 cancelan su jugada **/
  528.         arr[options[eleccion-1].x][options[eleccion-1].y] = arr[iCord][jCord];
  529.         arr[iCord][jCord] = 0;
  530.     }else{
  531.         cout << "Has cancelado la jugada" << endl;
  532.         system("pause");
  533.         system("cls");
  534.         board_set();
  535.         moverPieza(options);
  536.     }
  537.  
  538. }
  539.  
  540. void inicializarTablero(){
  541.     arr[8][8] = {};
  542.     for(int i = 0 ; i < 8 ; i++){ /*Peones*/                   /**1 peon - 2 torre - 3 caballo**/
  543.        // arr[1][i] = -1;                                        /** 4 alfin - 5 reina -  6 rey **/
  544.         //arr[6][i] = 1;
  545.     }
  546.     arr[0][0] = arr[0][7] = -2;
  547.     arr[0][1] = arr[0][6] = -3;
  548.     arr[0][2] = arr[0][5] = -4;
  549.     arr[0][3] = -5;
  550.     arr[0][4] = -6;
  551.     arr[7][0] = arr[7][7] = 2;
  552.     arr[7][1] = arr[7][6] = 3;
  553.     arr[7][2] = arr[7][5] = 4;
  554.     arr[7][3] = 5;
  555.     arr[7][4] = 6;
  556.     arr[5][1] = -1;
  557.     arr[2][1] = 1;
  558.  
  559.  
  560. }
  561.  
  562. void board_set(){
  563.     system("CLS");
  564.     bool check = true;
  565.     std::cout << "   ";
  566.     std::cout << " 1  2  3  4  5  6  7  8\n";
  567.     for(int i=0; i<8; i++){
  568.         SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
  569.         switch(i){
  570.             default:
  571.                 break;
  572.             case 0:
  573.                 std::cout << " a ";
  574.                 break;
  575.             case 1:
  576.                 std::cout << " b ";
  577.                 break;
  578.             case 2:
  579.                 std::cout << " c ";
  580.                 break;
  581.             case 3:
  582.                 std::cout << " d ";
  583.                 break;
  584.             case 4:
  585.                 std::cout << " e ";
  586.                 break;
  587.             case 5:
  588.                 std::cout << " f ";
  589.                 break;
  590.             case 6:
  591.                 std::cout << " g ";
  592.                 break;
  593.             case 7:
  594.                 std::cout << " h ";
  595.                 break;
  596.         }
  597.         for(int j=0; j<8; j++){
  598.             if(check){
  599.                 if(arr[i][j] < 0)
  600.                     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 112);
  601.                 else
  602.                     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 127);
  603.             }
  604.             else{
  605.                 if(arr[i][j] < 0)
  606.                     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 128);
  607.                 else
  608.                     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 143);
  609.             }
  610.             check = !check;
  611.             std::cout << std::setw(2);
  612.             if(arr[i][j] == 0)
  613.                 std::cout << "   ";
  614.             else
  615.                 switch(abs(arr[i][j])){
  616.                     default:
  617.                         break;
  618.                     case 1:
  619.                         std::cout << " P ";
  620.                         break;
  621.                     case 2:
  622.                         std::cout << " R ";
  623.                         break;
  624.                     case 3:
  625.                         std::cout << " N ";
  626.                         break;
  627.                     case 4:
  628.                         std::cout << " B ";
  629.                         break;
  630.                     case 5:
  631.                         std::cout << " Q ";
  632.                         break;
  633.                     case 6:
  634.                         std::cout << " K ";
  635.                         break;
  636.                 }
  637.         }
  638.         check = !check;
  639.         std::cout << std::endl;
  640.     }
  641.     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
  642.     if(teamCount % 2 != 0){
  643.         cout << "Es turno de las piezas blancas" << endl;
  644.     }else{
  645.         cout << "Es turno de las piezas negras" << endl;
  646.     }
  647. }
  648.  
  649. bool isValidInt(string numeroEnCadena){
  650.     int inicio = 0;
  651.     int i=0;
  652.     bool valido = true;
  653.     bool signo = false;
  654.  
  655.     int tamanioDeCadena = numeroEnCadena.size();
  656.  
  657.     if(tamanioDeCadena == 0)
  658.         valido = 0;
  659.  
  660.     if(numeroEnCadena.at(0)=='+'){
  661.         inicio=1;
  662.         signo = true;
  663.     }
  664.  
  665.     if(signo && tamanioDeCadena ==1)
  666.         valido = false;
  667.  
  668.     for(i=inicio; valido && i<tamanioDeCadena; i++){
  669.         if(!isdigit(numeroEnCadena.at(i)))
  670.         valido = false;
  671.     }
  672.  
  673.     return valido;
  674. }
  675.  
  676. void moverPeon(int iCord , int jCord, coordenadas *options){
  677.  
  678.     int iCordTemp = iCord;
  679.     int jCordTemp = jCord;
  680.     int counter = 0;
  681.     int eleccion;
  682.  
  683.     if(arr[iCord][jCord]>0){
  684.         iCordTemp--;
  685.         jCordTemp--; /** checar arriba a la izquierda del peon**/
  686.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  687.             if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp]) && arr[iCordTemp][jCordTemp]!= 0 ){ // checa si es el mismo equipo
  688.                options[counter].x = iCordTemp;
  689.                options[counter].y = jCordTemp;
  690.                counter++;
  691.             }
  692.         }
  693.         iCordTemp = iCord - 1;
  694.         jCordTemp = jCord; /** checar justo arriba **/
  695.  
  696.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  697.             if(arr[iCordTemp][jCordTemp] == 0){ // checa si es el mismo equipo
  698.                options[counter].x = iCordTemp;
  699.                options[counter].y = jCordTemp;
  700.                counter++;
  701.             }
  702.         }
  703.  
  704.         if(iCord == 6){ /** solo entra si es la primera vez que el peon blanco se mueve **/
  705.  
  706.             iCordTemp = iCord - 2; /** checar 2 hacia arriba **/
  707.             jCordTemp = jCord;
  708.  
  709.             if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  710.                 if(arr[iCordTemp][jCordTemp] == 0){ // checa si es el mismo equipo
  711.                    options[counter].x = iCordTemp;
  712.                    options[counter].y = jCordTemp;
  713.                    counter++;
  714.                 }
  715.             }
  716.         }
  717.  
  718.         iCordTemp = iCord - 1;
  719.         jCordTemp = jCord + 1;
  720.  
  721.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  722.             if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp]) && arr[iCordTemp][jCordTemp]!= 0 ){ // checa si es el mismo equipo
  723.                options[counter].x = iCordTemp;
  724.                options[counter].y = jCordTemp;
  725.                counter++;
  726.             }
  727.         }
  728.     }else{
  729.  
  730.         iCordTemp++; /** checas abajo a la derecha **/
  731.         jCordTemp++;
  732.  
  733.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  734.             if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp]) && arr[iCordTemp][jCordTemp]!= 0 ){ // checa si es el mismo equipo
  735.                options[counter].x = iCordTemp;
  736.                options[counter].y = jCordTemp;
  737.                counter++;
  738.             }
  739.         }
  740.  
  741.         iCordTemp = iCord + 1; /** checas abajo **/
  742.         jCordTemp = jCord;
  743.  
  744.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  745.             if(arr[iCordTemp][jCordTemp] == 0){ // checa si es el mismo equipo
  746.                options[counter].x = iCordTemp;
  747.                options[counter].y = jCordTemp;
  748.                counter++;
  749.             }
  750.         }
  751.  
  752.         if(iCord == 1){ /** solo entra si es la primera vez que el peon blanco se mueve **/
  753.  
  754.             iCordTemp = iCord + 2; /** checar 2 hacia aabajo **/
  755.             jCordTemp = jCord;
  756.  
  757.             if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  758.                 if(arr[iCordTemp][jCordTemp] == 0){ // checa si es el mismo equipo
  759.                    options[counter].x = iCordTemp;
  760.                    options[counter].y = jCordTemp;
  761.                    counter++;
  762.                 }
  763.             }
  764.         }
  765.  
  766.         iCordTemp = iCord + 1; /** checas abajo y a la izquierda **/
  767.         jCordTemp = jCord - 1;
  768.  
  769.         if(iCordTemp >= 0 && iCordTemp < 8 && jCordTemp >= 0 && jCordTemp < 8){
  770.             if(!mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCordTemp]) && arr[iCordTemp][jCordTemp]!= 0 ){ // checa si es el mismo equipo
  771.                 options[counter].x = iCordTemp;
  772.                 options[counter].y = jCordTemp;
  773.                 counter++;
  774.             }
  775.         }
  776.     }
  777.  
  778.     if(counter == 0){
  779.         cout << "Esta pieza no se puede mover hacia ninguna casilla" << endl; /** Si el counter no aumento, quiere decir que no hay movimientos posibles**/
  780.         system("pause");
  781.         teamCount--;
  782.         return;
  783.     }
  784.     cout << "Se puede mover a las siguientes opciones:" << endl;
  785.     cout << "Seleccione 0 para cambiar de jugada" << endl;
  786.     for(int i = 0 ; i < counter ; i++){ /** for para imprimir las opciones que tiene el usuario **/
  787.         cout << "#" << i+1 << ":";
  788.         imprimirLetra(options[i].x);
  789.         cout << (options[i].y)+1 << endl;
  790.     }
  791.  
  792.     cout << "Escoge tu opcion ";
  793.     bool check = 1; /** variable de control **/
  794.     while(check == 1){ /** ciclo para asegurarnos de recibir datos validos **/
  795.         try{
  796.             check = 0;
  797.             eleccion = cinOpcionValida(counter); /** nos aseguramos que el dato de entrada cumpla con varias caracterizticas, consultar la funcion para mayor detalle **/
  798.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  799.             cout << "Favor de introducir un numero menor o igual a las opciones disponibles \n";
  800.             check = 1;
  801.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  802.             cout << ex << endl;
  803.             check = 1;
  804.         }catch(...){
  805.             cout << "Error desconocido";
  806.             exit(1);
  807.         }
  808.     }
  809.     if(eleccion != 0){ /** si introducen 0 cancelan su jugada **/
  810.         arr[options[eleccion-1].x][options[eleccion-1].y] = arr[iCord][jCord];
  811.         arr[iCord][jCord] = 0;
  812.  
  813.     }else{
  814.         cout << "Has cancelado la jugada" << endl;
  815.         system("pause");
  816.         system("cls");
  817.         board_set();
  818.         moverPieza(options);
  819.     }
  820.  
  821. }
  822.  
  823. void moverAlfil(int iCord , int jCord, coordenadas *options){
  824.  
  825.     int iCordTemp = iCord;
  826.     int jCordTemp = jCord;
  827.     int counter = 0;
  828.     int eleccion;
  829.  
  830.     bool check = 1;
  831.  
  832.     while(check){ /** Movimiento hacia arriba y la izquierda **/
  833.         iCordTemp--;
  834.         jCordTemp--;
  835.         if(iCordTemp < 0 || jCordTemp < 0){
  836.             check = 0;
  837.         }else if(arr[iCordTemp][jCord]==0){
  838.             options[counter].x = iCordTemp;
  839.             options[counter].y = jCordTemp;
  840.             counter++;
  841.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  842.         check = 0;
  843.         }else{
  844.             options[counter].x = iCordTemp;
  845.             options[counter].y = jCordTemp;
  846.             counter++;
  847.             check = 0;
  848.         }
  849.     }
  850.  
  851.     iCordTemp = iCord;
  852.     jCordTemp = jCord;
  853.     check = 1;
  854.  
  855.     while(check){ /** Movimiento hacia arriba y la derecha**/
  856.         iCordTemp--;
  857.         jCordTemp++;
  858.         if(iCordTemp < 0 || jCordTemp > 7){
  859.             check = 0;
  860.         }else if(arr[iCordTemp][jCord]==0){
  861.             options[counter].x = iCordTemp;
  862.             options[counter].y = jCordTemp;
  863.             counter++;
  864.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  865.             check = 0;
  866.         }else{
  867.             options[counter].x = iCordTemp;
  868.             options[counter].y = jCordTemp;
  869.             counter++;
  870.             check = 0;
  871.         }
  872.     }
  873.  
  874.     iCordTemp = iCord;
  875.     jCordTemp = jCord;
  876.     check = 1;
  877.  
  878.     while(check){ /** Movimiento hacia abajo y derecha **/
  879.         iCordTemp++;
  880.         jCordTemp++;
  881.         if(iCordTemp > 7 || jCordTemp > 7){
  882.             check = 0;
  883.         }else if(arr[iCordTemp][jCord]==0){
  884.             options[counter].x = iCordTemp;
  885.             options[counter].y = jCordTemp;
  886.             counter++;
  887.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  888.         }else{
  889.             options[counter].x = iCordTemp;
  890.             options[counter].y = jCordTemp;
  891.             counter++;
  892.             check = 0;
  893.         }
  894.     }
  895.  
  896.     iCordTemp = iCord;
  897.     jCordTemp = jCord;
  898.     check = 1;
  899.  
  900.     while(check){ /** Movimiento hacia abajo e izquierda **/
  901.         iCordTemp++;
  902.         jCordTemp--;
  903.         if(iCordTemp > 7 || jCordTemp < 0){
  904.             check = 0;
  905.         }else if(arr[iCordTemp][jCord]==0){
  906.             options[counter].x = iCordTemp;
  907.             options[counter].y = jCordTemp;
  908.             counter++;
  909.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  910.         }else{
  911.             options[counter].x = iCordTemp;
  912.             options[counter].y = jCordTemp;
  913.             counter++;
  914.             check = 0;
  915.         }
  916.     }
  917.  
  918.     if(counter == 0){
  919.         cout << "Esta pieza no se puede mover hacia ninguna casilla" << endl; /** Si el counter no aumento, quiere decir que no hay movimientos posibles**/
  920.         system("pause");
  921.         teamCount--;
  922.         return;
  923.     }
  924.     cout << "Se puede mover a las siguientes opciones:" << endl;
  925.     cout << "Seleccione 0 para cambiar de jugada" << endl;
  926.     for(int i = 0 ; i < counter ; i++){ /** for para imprimir las opciones que tiene el usuario **/
  927.         cout << "#" << i+1 << ":";
  928.         imprimirLetra(options[i].x);
  929.         cout << (options[i].y)+1 << endl;
  930.     }
  931.  
  932.     cout << "Escoge tu opcion ";
  933.     check = 1; /** variable de control **/
  934.     while(check == 1){ /** ciclo para asegurarnos de recibir datos validos **/
  935.         try{
  936.             check = 0;
  937.             eleccion = cinOpcionValida(counter); /** nos aseguramos que el dato de entrada cumpla con varias caracterizticas, consultar la funcion para mayor detalle **/
  938.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  939.             cout << "Favor de introducir un numero menor o igual a las opciones disponibles \n";
  940.             check = 1;
  941.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  942.             cout << ex << endl;
  943.             check = 1;
  944.         }catch(...){
  945.             cout << "Error desconocido";
  946.             exit(1);
  947.         }
  948.     }
  949.     if(eleccion != 0){ /** si introducen 0 cancelan su jugada **/
  950.         arr[options[eleccion-1].x][options[eleccion-1].y] = arr[iCord][jCord];
  951.         arr[iCord][jCord] = 0;
  952.  
  953.     }else{
  954.         cout << "Has cancelado la jugada" << endl;
  955.         system("pause");
  956.         system("cls");
  957.         board_set();
  958.         moverPieza(options);
  959.     }
  960.  
  961. }
  962.  
  963. void moverReina(int iCord , int jCord, coordenadas *options){
  964.  
  965.     int iCordTemp = iCord;
  966.     int jCordTemp = jCord;
  967.     int counter = 0;
  968.     int eleccion;
  969.  
  970.     bool check = 1;
  971.  
  972.     while(check){ /** Movimiento hacia arriba**/
  973.         iCordTemp--;
  974.         if(iCordTemp < 0){ /** Nos aseguramos que no se salga del los limites del tablero **/
  975.             check = 0;
  976.         }else if(arr[iCordTemp][jCord]==0){ /** checamos que sea una casilla vacia, si esta condicion no se cumple, llegamos a una pieza **/
  977.             options[counter].x = iCordTemp;
  978.             options[counter].y = jCordTemp;
  979.             counter++;
  980.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){ /** si es una pieza del mismo equipo de la que vamos a mover, se detiene**/
  981.             check = 0;
  982.         }else{  /** si es del equipo contrario, la podemos comer y se detiene **/
  983.             options[counter].x = iCordTemp;
  984.             options[counter].y = jCordTemp;
  985.             counter++;
  986.             check = 0;
  987.         }
  988.     }
  989.  
  990.     iCordTemp = iCord;
  991.     jCordTemp = jCord;
  992.     check = 1;
  993.  
  994.     while(check){ /** Movimiento hacia arriba y la derecha**/
  995.         iCordTemp--;
  996.         jCordTemp++;
  997.         if(iCordTemp < 0 || jCordTemp > 7){
  998.             check = 0;
  999.         }else if(arr[iCordTemp][jCord]==0){
  1000.             options[counter].x = iCordTemp;
  1001.             options[counter].y = jCordTemp;
  1002.             counter++;
  1003.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  1004.             check = 0;
  1005.         }else{
  1006.             options[counter].x = iCordTemp;
  1007.             options[counter].y = jCordTemp;
  1008.             counter++;
  1009.             check = 0;
  1010.         }
  1011.     }
  1012.  
  1013.     iCordTemp = iCord;
  1014.     jCordTemp = jCord;
  1015.     check = 1;
  1016.  
  1017.     while(check){ /** Movimiento hacia la derecha**/
  1018.         jCordTemp++;
  1019.         if(jCordTemp > 7){
  1020.             check = 0;
  1021.         }else if(arr[iCord][jCordTemp]==0){
  1022.             options[counter].x = iCordTemp;
  1023.             options[counter].y = jCordTemp;
  1024.             counter++;
  1025.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCord][jCordTemp])){
  1026.             check = 0;
  1027.         }else{
  1028.             options[counter].x = iCordTemp;
  1029.             options[counter].y = jCordTemp;
  1030.             counter++;
  1031.             check = 0;
  1032.         }
  1033.     }
  1034.  
  1035.     iCordTemp = iCord;
  1036.     jCordTemp = jCord;
  1037.     check = 1;
  1038.  
  1039.     while(check){ /** Movimiento hacia abajo y derecha **/
  1040.         iCordTemp++;
  1041.         jCordTemp++;
  1042.         if(iCordTemp > 7 || jCordTemp > 7){
  1043.             check = 0;
  1044.         }else if(arr[iCordTemp][jCord]==0){
  1045.             options[counter].x = iCordTemp;
  1046.             options[counter].y = jCordTemp;
  1047.             counter++;
  1048.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  1049.         }else{
  1050.             options[counter].x = iCordTemp;
  1051.             options[counter].y = jCordTemp;
  1052.             counter++;
  1053.             check = 0;
  1054.         }
  1055.     }
  1056.  
  1057.     iCordTemp = iCord;
  1058.     jCordTemp = jCord;
  1059.     check = 1;
  1060.     while(check){ /** Movimiento hacia abajo**/
  1061.         iCordTemp++;
  1062.         if(iCordTemp > 7){
  1063.             check = 0;
  1064.         }else if(arr[iCordTemp][jCord]==0){
  1065.             options[counter].x = iCordTemp;
  1066.             options[counter].y = jCordTemp;
  1067.             counter++;
  1068.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  1069.             check = 0;
  1070.         }else{
  1071.             options[counter].x = iCordTemp;
  1072.             options[counter].y = jCordTemp;
  1073.             counter++;
  1074.             check = 0;
  1075.         }
  1076.     }
  1077.  
  1078.     iCordTemp = iCord;
  1079.     jCordTemp = jCord;
  1080.     check = 1;
  1081.  
  1082.     while(check){ /** Movimiento hacia abajo e izquierda **/
  1083.         iCordTemp++;
  1084.         jCordTemp--;
  1085.         if(iCordTemp > 7 || jCordTemp < 0){
  1086.             check = 0;
  1087.         }else if(arr[iCordTemp][jCord]==0){
  1088.             options[counter].x = iCordTemp;
  1089.             options[counter].y = jCordTemp;
  1090.             counter++;
  1091.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  1092.         }else{
  1093.             options[counter].x = iCordTemp;
  1094.             options[counter].y = jCordTemp;
  1095.             counter++;
  1096.             check = 0;
  1097.         }
  1098.     }
  1099.  
  1100.     iCordTemp = iCord;
  1101.     jCordTemp = jCord;
  1102.     check = 1;
  1103.  
  1104.     while(check){ /** Movimiento hacia la izquierda**/
  1105.         jCordTemp--;
  1106.         if(jCordTemp < 0){
  1107.             check = 0;
  1108.         }else if(arr[iCord][jCordTemp]==0){
  1109.             options[counter].x = iCordTemp;
  1110.             options[counter].y = jCordTemp;
  1111.             counter++;
  1112.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCord][jCordTemp])){
  1113.             check = 0;
  1114.         }else{
  1115.             options[counter].x = iCordTemp;
  1116.             options[counter].y = jCordTemp;
  1117.             counter++;
  1118.             check = 0;
  1119.         }
  1120.     }
  1121.  
  1122.     iCordTemp = iCord;
  1123.     jCordTemp = jCord;
  1124.     check = 1;
  1125.  
  1126.     while(check){ /** Movimiento hacia arriba y la izquierda **/
  1127.         iCordTemp--;
  1128.         jCordTemp--;
  1129.         if(iCordTemp < 0 || jCordTemp < 0){
  1130.             check = 0;
  1131.         }else if(arr[iCordTemp][jCord]==0){
  1132.             options[counter].x = iCordTemp;
  1133.             options[counter].y = jCordTemp;
  1134.             counter++;
  1135.         }else if(mismoEquipo(arr[iCord][jCord],arr[iCordTemp][jCord])){
  1136.         check = 0;
  1137.         }else{
  1138.             options[counter].x = iCordTemp;
  1139.             options[counter].y = jCordTemp;
  1140.             counter++;
  1141.             check = 0;
  1142.         }
  1143.     }
  1144.  
  1145.     if(counter == 0){
  1146.         cout << "Esta pieza no se puede mover hacia ninguna casilla" << endl; /** Si el counter no aumento, quiere decir que no hay movimientos posibles**/
  1147.         system("pause");
  1148.         teamCount--;
  1149.         return;
  1150.     }
  1151.     cout << "Se puede mover a las siguientes opciones:" << endl;
  1152.     cout << "Seleccione 0 para cambiar de jugada" << endl;
  1153.     for(int i = 0 ; i < counter ; i++){ /** for para imprimir las opciones que tiene el usuario **/
  1154.         cout << "#" << i+1 << ":";
  1155.         imprimirLetra(options[i].x);
  1156.         cout << (options[i].y)+1 << endl;
  1157.     }
  1158.  
  1159.     cout << "Escoge tu opcion ";
  1160.     check = 1; /** variable de control **/
  1161.     while(check == 1){ /** ciclo para asegurarnos de recibir datos validos **/
  1162.         try{
  1163.             check = 0;
  1164.             eleccion = cinOpcionValida(counter); /** nos aseguramos que el dato de entrada cumpla con varias caracterizticas, consultar la funcion para mayor detalle **/
  1165.         }catch(out_of_range){  /** si nos introducen un valor que no cabe en un int, out_of_range se arroja de manera implicita **/
  1166.             cout << "Favor de introducir un numero menor o igual a las opciones disponibles \n";
  1167.             check = 1;
  1168.         }catch(const char* ex){ /** Si sucede alguna excepcion la imprimimos **/
  1169.             cout << ex << endl;
  1170.             check = 1;
  1171.         }catch(...){
  1172.             cout << "Error desconocido";
  1173.             exit(1);
  1174.         }
  1175.     }
  1176.     if(eleccion != 0){ /** si introducen 0 cancelan su jugada **/
  1177.         arr[options[eleccion-1].x][options[eleccion-1].y] = arr[iCord][jCord];
  1178.         arr[iCord][jCord] = 0;
  1179.  
  1180.     }else{
  1181.         cout << "Has cancelado la jugada" << endl;
  1182.         system("pause");
  1183.         system("cls");
  1184.         board_set();
  1185.         moverPieza(options);
  1186.     }
  1187. }
  1188.  
  1189. void moverRey(int iCord , int jCord, coordenadas *options){
  1190. }
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top