API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 25th, 2019
103
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 39.49 KB | None | 0 0
raw download clone embed print report
  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. }
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!