API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 19th, 2019
135
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.34 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <windows.h>
  4.  
  5. int xeque_torre(int i, int j, char king);
  6. int xeque_bispo(int i, int j, char king);
  7.  
  8. char tabuleiro[10][10] = {
  9. { 'T', 'C', 'B', 'Q', 'K', 'B', 'C', 'T' },
  10. { 'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P' },
  11. { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
  12. { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
  13. { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
  14. { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' },
  15. { 'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p' },
  16. { 't', 'c', 'b', 'k', 'q', 'b', 'c', 't' },
  17. };
  18.  
  19. char jogador1[6] = {'p', 't', 'c', 'b', 'k', 'q'};
  20. char jogador2[6] = {'P', 'T', 'C', 'B', 'Q', 'K'};
  21.  
  22. void pula_linha(int n){
  23. int i;
  24. for(i = 0; i < n; i++) putchar('\n');
  25. }
  26.  
  27. void visualizar_tabuleiro(void){
  28.  
  29. int i, j, cont = 0;
  30.  
  31. for(i = 0; i < 8; i++)
  32. {
  33. printf("\t\t\t\t\t %d ", cont); cont++;
  34. for(j = 0; j < 8; j++)
  35. {
  36. printf("%c ", tabuleiro[i][j]);
  37. }
  38. putchar('\n');
  39. }
  40. putchar('\n');
  41. printf("\t\t\t\t\t ");
  42. for(i = 0; i < 8; i++) printf("%d ", i);
  43. }
  44.  
  45. void movimento(int x1, int y1, int x2, int y2){
  46.  
  47. tabuleiro[x2][y2] = tabuleiro[x1][y1];
  48. tabuleiro[x1][y1] = ' ';
  49. }
  50.  
  51. int xeque_rainha(int i, int j, char king){
  52. /*A RAINHA FAZ O MOVIMENTO DO BISOO E O DA TORRE*/
  53. /*DIRECIONAMOS O ALGORITMO PARA AS RESPECTIVAS FUNCOES*/
  54. if(xeque_bispo(i, j, king)) return 1;
  55. else if(xeque_torre(i, j, king)) return 1;
  56.  
  57. return 0;
  58. }
  59.  
  60. int xeque_bispo(int i, int j, char king){
  61.  
  62. int x, y;
  63. /*NESSE FOR O BISPO CAMINHA PARA O SUDESTE DO TABULEIRO*/
  64. for(x = (i+1), y =(j+1); x < 8 && y < 8; x++, y++)
  65. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  66. if(tabuleiro[x][y] == king) return 1;
  67. else if(tabuleiro[x][y] != ' ') break;
  68. }
  69. /*NESSE FOR O BISPO CAMINHA PARA O SUDOESTE DO TABULEIRO*/
  70. for(x = (i+1), y = (j-1); x < 8 && y < 8; x++, y--)
  71. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  72. if(tabuleiro[x][y] == king) return 1;
  73. else if(tabuleiro[x][y] != ' ') break;
  74. }
  75. /*NESSE FOR O BISPO CAMINHA PARA O NOROESTE DO TABULEIRO*/
  76. for(x = (i-1), y = (j-1); x < 8 && y < 8; x--, y--)
  77. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  78. if(tabuleiro[x][y] == king) return 1;
  79. else if(tabuleiro[x][y] != ' ') break;
  80. }
  81. /*NESSE FOR O BISPO CAMINHA PARA O NORDESTE DO TABULEIRO*/
  82. for(x = (i-1), y = (j+1); x < 8 && y < 8; x--, y++)
  83. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  84. if(tabuleiro[x][y] == king) return 1;
  85. else if(tabuleiro[x][y] != ' ') break;
  86. }
  87.  
  88. return 0;
  89. }
  90.  
  91. int xeque_cavalo(int i, int j, char king){
  92. /*VERIFICA SE EM CADA POSICAO POSSIVEL DE JOGADA DO CAVALO, HA O REI*/
  93. if(tabuleiro[i+2][j+1] == king) return 1;
  94. else if(tabuleiro[i+2][j-1] == king) return 1;
  95. else if(tabuleiro[i+1][j+2] == king) return 1;
  96. else if(tabuleiro[i+1][j-2] == king) return 1;
  97. else if(tabuleiro[i-1][j-2] == king) return 1;
  98. else if(tabuleiro[i-1][j+2] == king) return 1;
  99. else if(tabuleiro[i-2][j-1] == king) return 1;
  100. else if(tabuleiro[i-2][j+1] == king) return 1;
  101.  
  102. return 0;
  103. }
  104.  
  105. int xeque_torre(int i, int j, char king){
  106.  
  107. int x, y;
  108. /*NESSE FOR, A TORRE NAO MUDA DE COLUNA, ELA VAI PRA BAIXO*/
  109. for(x = (i + 1); x < 8; x++)
  110. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  111. if(tabuleiro[x][j] == king) return 1;
  112. else if(tabuleiro[x][j] != ' ') break;
  113. }
  114. /*NESSE FOR, A TORRE NAO MUDA DE COLUNA, ELA VAI PRA CIMA*/
  115. for(x = (i - 1); x >= 0; x--)
  116. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  117. if(tabuleiro[x][j] == king) return 1;
  118. else if(tabuleiro[x][j] != ' ') break;
  119. }
  120. /*NESSE FOR, A TORRE NAO MUDA DE LINHA, ELA VAI PRA DIREITA*/
  121. for(y = (j + 1); y < 8; y++)
  122. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  123. if(tabuleiro[i][y] == king) return 1;
  124. else if(tabuleiro[i][y] != ' ') break;
  125. }
  126. /*NESSE FOR, A TORRE NAO MUDA DE LINHA, ELA VAI PRA ESQUERDA*/
  127. for(y = (j - 1); y >= 0; y--)
  128. { /*VERIFICA SE HA O REI EM SEU CAMINHO*/
  129. if(tabuleiro[i][y] == king) return 1;
  130. else if(tabuleiro[i][y] != ' ') break;
  131. }
  132.  
  133. return 0;
  134. }
  135.  
  136. int xeque_peao(int i, int j, char king, int atual){
  137. /*O PEAO ATACA APENAS PELAS SUAS DIAGONAIS*/
  138. if(atual == 1)
  139. { /*VERIFICA SE HA O REI NA SUA DIAGONAL DA ESQUERDA, DE CIMA PRA BAIXO*/
  140. if(tabuleiro[i+1][j-1] == king)
  141. return 1;
  142. /*VERIFICA SE HA O REI NA SUA DIAGONAL DA DIREITA, DE CIMA PRA BAIXO*/
  143. else if(tabuleiro[i+1][j+1] == king)
  144. return 1;
  145. }
  146. else if(atual == 2)
  147. { /*VERIFICA SE HA O REI NA SUA DIAGONAL DA ESQUERDA, DE BAIXO PRA CIMA*/
  148. if(tabuleiro[i-1][j-1] == king)
  149. return 1;
  150. /*VERIFICA SE HA O REI NA SUA DIAGONAL DA DIREITA, DE BAIXO PRA CIMA*/
  151. else if(tabuleiro[i-1][j+1] == king)
  152. return 1;
  153. }
  154.  
  155. return 0;
  156. }
  157.  
  158. int xeque(int i, int j, char king, int atual){
  159. /*LE TODA A MATRIZ*/
  160. for(i = 0; i < 8; i++)
  161. {
  162. for(j = 0; j < 8; j++)
  163. { /*SE FOR A VEZ DO JOGADOR 2, O ALGORITMO VAI VERIFICAR SE TEM ALGUMA PECA
  164. ADVERSARIA, ATACANDO O SEU REI*/
  165. if(atual == 2)
  166. { /*PROCURA AS PECAS DO OPONENTE*/
  167. if(tabuleiro[i][j] == 'p')
  168. { /*CHECA SE ALGUM DE TODOS OS PEOES INIMIGO AMEACA O SEU REI*/
  169. if(xeque_peao(i, j, king, atual)) return 1;
  170. }
  171. else if(tabuleiro[i][j] == 't')
  172. { /*CHECA SE ALGUMA DE TODAS AS TORRES INIMIGA AMEACA O SEU REI*/
  173. if(xeque_torre(i, j, king)) return 1;
  174. }
  175. else if(tabuleiro[i][j] == 'c')
  176. { /*CHECA SE ALGUMA DE TODOS OS CAVALOS INIMIGO AMEACA O SEU REI*/
  177. if(xeque_cavalo(i, j, king)) return 1;
  178. }
  179. else if(tabuleiro[i][j] == 'b')
  180. { /*CHECA SE ALGUM DE TODOS OS BISPOS INIMIGO AMEACA O SEU REI*/
  181. if(xeque_bispo(i, j, king)) return 1;
  182. }
  183. else if(tabuleiro[i][j] == 'q')
  184. {
  185. if(xeque_rainha(i, j, king)) return 1;
  186. }
  187. }
  188. if(atual == 1)
  189. { /*PROCURA AS PECAS DO OPONENTE*/
  190. if(tabuleiro[i][j] == 'P')
  191. { /*CHECA SE ALGUM DE TODOS OS PEOES INIMIGO AMEACA O SEU REI*/
  192. if(xeque_peao(i, j, king, atual)) return 1;
  193. }
  194. else if(tabuleiro[i][j] == 'T')
  195. { /*CHECA SE ALGUMA DE TODAS AS TORRES INIMIGA AMEACA O SEU REI*/
  196. if(xeque_torre(i, j, king)) return 1;
  197. }
  198. else if(tabuleiro[i][j] == 'C')
  199. { /*CHECA SE ALGUMA DE TODOS OS CAVALOS INIMIGO AMEACA O SEU REI*/
  200. if(xeque_cavalo(i, j, king)) return 1;
  201. }
  202. else if(tabuleiro[i][j] == 'B')
  203. { /*CHECA SE ALGUM DE TODOS OS BISPOS INIMIGO AMEACA O SEU REI*/
  204. if(xeque_bispo(i, j, king)) return 1;
  205. }
  206. else if(tabuleiro[i][j] == 'Q')
  207. {
  208. if(xeque_rainha(i, j, king)) return 1;
  209. }
  210. }
  211. }
  212. }
  213.  
  214. return 0;
  215. }
  216. /*MOVIMENTO DO REI*/
  217. int rei(int x1, int y1, int x2, int y2){
  218. /*O REI SO PODE SE MOVIMENTAR UMA CASA AO SEU REDOR*/
  219. /*LOGO, A DIFERENCA ENTRA AS CASAS NAO PODEM VARIAR MAIS QUE -1 E 1*/
  220. if(((x2 - x1) <= 1 && (x2 - x1) >= -1) && ((y2 - y1) <= 1 && (y2 - y1) >= -1))
  221. return 1;
  222.  
  223. return 0;
  224. }
  225. /*MOVIMENTO DA RAINHA*/
  226. int rainha(int x1, int y1, int x2, int y2){
  227. /*A RAINHA FAZ O MOVIMENTO DO BISPO + O DA TORRE*/
  228. int i, j;
  229. /*FAZ O MOVIMENTO DO BISPO*/
  230. if((x1 != x2) && (y1 != y2))
  231. {
  232. /*SE VERDADEIRO, SIGNIFICA QUE A RAINHA DESCEU (AUMENTOU LINHA)*/
  233. if(x1 < x2)
  234. { /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA DIREITA - SUDESTE*/
  235. if(y1 < y2)
  236. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  237. for(i = (x1 + 1), j = (y1 + 1); (i < x2) && (j < y2); i++, j++)
  238. { /*RAINHA NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  239. if(tabuleiro[i][j] != ' ')
  240. return 0;
  241. }
  242. return 1;
  243. }
  244. /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA ESQUEDA - SUDOESTE*/
  245. else if(y1 > y2)
  246. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  247. for(i = (x1 + 1), j = (y1 - 1); (i < x2) && (j > y2); i++, j--)
  248. { /*RAINHA NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  249. if(tabuleiro[i][j] != ' ')
  250. return 0;
  251. }
  252. return 1;
  253. }
  254. }
  255. /*SE VERDADEIRO, SIGNIFICA QUE A RAINHA SUBIU (DIMINUIU LINHA)*/
  256. else if(x1 > x2)
  257. { /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA DIREITA - NORDESTE*/
  258. if(y1 < y2)
  259. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  260. for(i = (x1 - 1), j = (y1 + 1); (i > x2) && (j < y2); i--, j++) // SOBE PARA DIREITA
  261. { /*RAINHA NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  262. if(tabuleiro[i][j] != ' ')
  263. return 0;
  264. }
  265. return 1;
  266. /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA ESQUERDA - NOROESTE*/
  267. }
  268. else if(y1 > y2)
  269. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  270. for(i = (x1 - 1), j = (y1 - 1); (i > x2) && (j > y2); i--, j--) // SOBE PARA ESQUERDA
  271. { /*RAINHA NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  272. if(tabuleiro[i][j] != ' ')
  273. return 0;
  274. }
  275. return 1;
  276. }
  277. }
  278. }
  279. /*SENAO FAZ O MOVIMENTO DA TORRE*/
  280. else
  281. { /*NESSA CONDICAO ELA SE MANTEM NA MESMA LINHA E MUDA DE COLUNA*/
  282. if(x1 == x2 && y1 != y2)
  283. { /*VERIFICA SE ELA FOI PRA DIREITA, SE SIM EXECUTA*/
  284. if(y2 > y1)
  285. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  286. for(i = (y1 + 1); i < y2; i++)
  287. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A RAINHA NAO PULA PECA*/
  288. if(tabuleiro[x1][i] != ' ')
  289. return 0;
  290. }
  291. return 1;
  292. }
  293. /*VERIFICA SE ELA FOI PRA ESQUERDA, SE SIM, EXECUTA*/
  294. else if(y2 < y1)
  295. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  296. for(i = (y1 - 1); i > y2; i--)
  297. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A RAINHA NAO PULA PECA*/
  298. if(tabuleiro[x1][i] != ' ')
  299. return 0;
  300. }
  301. return 1;
  302. }
  303. }
  304. /*NESSA CONDICAO ELA SE MANTEM NA MESMA COLUNA E MUDA DE LINHA*/
  305. else if(y1 == y2 && x1 != x2)
  306. { /*VERIFICA SE ELA FOI PRA BAIXO, SE SIM EXECUTA*/
  307. if(x2 > x1)
  308. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  309. for(i = (x1 + 1); i < x2; i++)
  310. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A RAINHA NAO PULA PECA*/
  311. if(tabuleiro[i][y1] != ' ')
  312. return 0;
  313. }
  314. return 1;
  315. }
  316. /*VERIFICA SE ELA FOI PRA CIMA, SE SIM, EXECUTA*/
  317. else if(x2 < x1)
  318. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  319. for(i = (x1 - 1); i > x2; i--)
  320. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A RAINHA NAO PULA PECA*/
  321. if(tabuleiro[i][y1] != ' ')
  322. return 0;
  323. }
  324. return 1;
  325. }
  326. }
  327. }
  328.  
  329. return 0;
  330. }
  331. /*MOVIMENTO DO BISPO*/
  332. int bispo(int x1, int y1, int x2, int y2){
  333.  
  334. int i, j;
  335. /*SE VERDADEIRO, SIGNIFICA QUE O BISPO DESCEU (AUMENTOU LINHA)*/
  336. if(x1 < x2)
  337. { /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA DIREITA - SUDESTE*/
  338. if(y1 < y2)
  339. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  340. for(i = (x1 + 1), j = (y1 + 1); (i < x2) && (j < y2); i++, j++)
  341. { /*BISPO NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  342. if(tabuleiro[i][j] != ' ')
  343. return 0;
  344. }
  345. return 1;
  346. }
  347. /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA ESQUEDA - SUDOESTE*/
  348. else if(y1 > y2)
  349. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  350. for(i = (x1 + 1), j = (y1 - 1); (i < x2) && (j > y2); i++, j--)
  351. { /*BISPO NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  352. if(tabuleiro[i][j] != ' ')
  353. return 0;
  354. }
  355. return 1;
  356. }
  357. }
  358. /*SE VERDADEIRO, SIGNIFICA QUE O BISPO SUBIU (DIMINUIU LINHA)*/
  359. else if(x1 > x2)
  360. { /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA DIREITA - NORDESTE*/
  361. if(y1 < y2)
  362. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  363. for(i = (x1 - 1), j = (y1 + 1); (i > x2) && (j < y2); i--, j++) // SOBE PARA DIREITA
  364. { /*BISPO NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  365. if(tabuleiro[i][j] != ' ')
  366. return 0;
  367. }
  368. return 1;
  369. /*SE VERDADEIRO, SIGNIFICA QUE ELE FOI PRA ESQUERDA - NOROESTE*/
  370. }
  371. else if(y1 > y2)
  372. { /*COMEÇA A VERIFICAR A PARTIR DA CASA SEGUINTE*/
  373. for(i = (x1 - 1), j = (y1 - 1); (i > x2) && (j > y2); i--, j--) // SOBE PARA ESQUERDA
  374. { /*BISPO NAO PULA PECA, E PRECISO VERIFICAR O CAMINHO*/
  375. if(tabuleiro[i][j] != ' ')
  376. return 0;
  377. }
  378. return 1;
  379. }
  380. }
  381.  
  382. return 0;
  383. }
  384. /*MOVIMENTO DO CAVALO*/
  385. int cavalo(int x1, int y1, int x2, int y2){
  386. /*NESSA CONDICAO ELA MUDA APENAS UMA COLUNA PARA DIREITA OU PARA ESQUERDA*/
  387. if((y1 + 1) == y2 || (y1 - 1) == y2)
  388. { /*NESSA CONDICAO ELA DESCE DUAS LINHAS*/
  389. if((x1 + 2) == x2)
  390. { /*MOVIMENTO VALIDO, RETORNA 1*/
  391. return 1;
  392. }
  393. /*NESSA CONDICAO ELA SOBE DUAS LINHAS*/
  394. else if((x1 - 2) == x2)
  395. { /*MOVIMENTO VALIDO, RETORNA 1*/
  396. return 1;
  397. }
  398. }
  399. /*NESSA CONDICAO ELA MUDA APENAS UMA LINHA PARA CIMA OU PARA BAIXO*/
  400. if((x1 + 1) == x2 || (x1 - 1) == x2)
  401. { /*NESSA CONDICAO ELA VAI DUAS COLUNAS PARA DIREITA*/
  402. if((y1 + 2) == y2)
  403. { /*MOVIMENTO VALIDO, RETORNA 1*/
  404. return 1;
  405. }
  406. /*NESSA CONDICAO ELA VAI DUAS COLUNAS PARA ESQUERDA*/
  407. else if((y1 - 2) == y2)
  408. { /*MOVIMENTO VALIDO, RETORNA 1*/
  409. return 1;
  410. }
  411. }
  412.  
  413. return 0;
  414. }
  415. /*MOVIMENTOS DA TORRE*/
  416. int torre(int x1, int y1, int x2, int y2){
  417. /*OBS: A TORRE, OU MUDA DE LINHA OU DE COLUNA*/
  418. int i;
  419. /*NESSA CONDICAO ELA SE MANTEM NA MESMA LINHA E MUDA DE COLUNA*/
  420. if(x1 == x2 && y1 != y2)
  421. { /*VERIFICA SE ELA FOI PRA DIREITA, SE SIM EXECUTA*/
  422. if(y2 > y1)
  423. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  424. for(i = (y1 + 1); i < y2; i++)
  425. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A TORRE NAO PULA PECA*/
  426. if(tabuleiro[x1][i] != ' ')
  427. return 0;
  428. }
  429. return 1;
  430. }
  431. /*VERIFICA SE ELA FOI PRA ESQUERDA, SE SIM, EXECUTA*/
  432. else if(y2 < y1)
  433. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  434. for(i = (y1 - 1); i > y2; i--)
  435. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A TORRE NAO PULA PECA*/
  436. if(tabuleiro[x1][i] != ' ')
  437. return 0;
  438. }
  439. return 1;
  440. }
  441. }
  442. /*NESSA CONDICAO ELA SE MANTEM NA MESMA COLUNA E MUDA DE LINHA*/
  443. else if(y1 == y2 && x1 != x2)
  444. { /*VERIFICA SE ELA FOI PRA BAIXO, SE SIM EXECUTA*/
  445. if(x2 > x1)
  446. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  447. for(i = (x1 + 1); i < x2; i++)
  448. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A TORRE NAO PULA PECA*/
  449. if(tabuleiro[i][y1] != ' ')
  450. return 0;
  451. }
  452. return 1;
  453. }
  454. /*VERIFICA SE ELA FOI PRA CIMA, SE SIM, EXECUTA*/
  455. else if(x2 < x1)
  456. { /*VERIFICA O CAMINHO ATE UMA CASA A MENOS DA DESEJADA*/
  457. for(i = (x1 - 1); i > x2; i--)
  458. { /*VENDO SE O CAMINHO ESTA LIVRE, JA QUE A TORRE NAO PULA PECA*/
  459. if(tabuleiro[i][y1] != ' ')
  460. return 0;
  461. }
  462. return 1;
  463. }
  464. }
  465.  
  466. return 0;
  467. }
  468. /*MOVIMENTOS DO PEAO*/
  469. int peao(int x1, int y1, int x2, int y2, int atual){
  470.  
  471. int i;
  472. /*IDENTIFICA SE O JOGADOR 1 E O DA VEZ*/
  473. if(atual == 1)
  474. { /*PEAO ANDA PARA FRENTE*/
  475. if(x2 == (x1 - 1) && y1 == y2)
  476. { /*VERIFICA SE NAO HA ALGUMA PECA ADVERSARIA NAQUELE LOCAL*/
  477. for(i = 0; i < 6; i++)
  478. { /*SE HOUVER, RETORNA 0 E A JOGADA E INVALIDA*/
  479. if(tabuleiro[x2][y2] == jogador2[i]) return 0;
  480. }
  481. return 1;
  482. }
  483. /*PEAO CAPTURA PECA ADVERSARIA NA DIAGONAL*/
  484. else if((y2 == (y1 + 1) || y2 == (y1 - 1)) && (x1 - 1))
  485. { /*VERIFICA SE HA PECA INIMIGO NAQUELA POSICAO*/
  486. for(i = 0; i < 6; i++)
  487. { /*SE SIM, A FUNCAO RETORNA 1 E A VERIFICACAO E VALIDA*/
  488. if(tabuleiro[x2][y2] == jogador2[i]) return 1;
  489. }
  490. }
  491. }
  492. /*IDENTIFICA SE O JOGADOR 2 E O DA VEZ*/
  493. else
  494. { /*PEAO ANDA PARA FRENTE*/
  495. if(x2 == (x1 + 1) && y1 == y2)
  496. { /*VERIFICA SE NAO HA ALGUMA PECA ADVERSARIA NAQUELE LOCAL*/
  497. for(i = 0; i < 6; i++)
  498. { /*SE HOUVER, RETORNA 0 E A JOGADA E INVALIDA*/
  499. if(tabuleiro[x2][y2] == jogador1[i]) return 0;
  500. }
  501. return 1;
  502. }
  503. /*PEAO CAPTURA PECA ADVERSARIA NA DIAGONAL*/
  504. else if((y2 == (y1 + 1) || y2 == (y1 - 1)) && (x1 + 1))
  505. { /*VERIFICA SE HA PECA INIMIGA NAQUELA POSICAO*/
  506. for(i = 0; i < 6; i++)
  507. { /*SE SIM, A FUNCAO RETORNA 1 E A VERIFICACAO E VALIDA*/
  508. if(tabuleiro[x2][y2] == jogador1[i]) return 1;
  509. }
  510. }
  511. }
  512. return 0;
  513. }
  514. /*FUNCAO QUE ENCAMINHA PARA O MOVIMENTO DE CADA PECA*/
  515. int possivel(int x1, int y1, int x2, int y2, int atual){
  516. /*SE A PECA FOR O PEAO, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DO PEAO*/
  517. if(tabuleiro[x1][y1] == 'p' || tabuleiro[x1][y1] == 'P') return peao(x1, y1, x2, y2, atual);
  518. /*SE A PECA FOR A TORRE, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DA TORRE*/
  519. else if(tabuleiro[x1][y1] == 't' || tabuleiro[x1][y1] == 'T') return torre(x1, y1, x2, y2);
  520. /*SE A PECA FOR O CAVALO, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DO CAVALO*/
  521. else if(tabuleiro[x1][y1] == 'c' || tabuleiro[x1][y1] == 'C') return cavalo(x1, y1, x2, y2);
  522. /*SE A PECA FOR O BISPO, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DO BISPO*/
  523. else if(tabuleiro[x1][y1] == 'b' || tabuleiro[x1][y1] == 'B') return bispo(x1, y1, x2, y2);
  524. /*SE A PECA FOR A RAINHA, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DA RAINHA*/
  525. else if(tabuleiro[x1][y1] == 'q' || tabuleiro[x1][y1] == 'Q') return rainha(x1, y1, x2, y2);
  526. /*SE A PECA FOR O REI, ELA DIRECIONA PARA OS MOVIMENTOS POSSIVEIS DO REI*/
  527. else if(tabuleiro[x1][y1] == 'k' || tabuleiro[x1][y1] == 'K') return rei(x1, y1, x2, y2);
  528.  
  529. return 0;
  530. }
  531. /*VERIFICA SE O JOGADOR PEGOU SUA PECA*/
  532. int peca_certa(int x1, int y1, int atual){
  533. int i;
  534. /*INDENTIFICA QUAL E O JOGADOR*/
  535. if(atual == 1)
  536. { /*VERIFICA SE A PECA E DELE*/
  537. for(i = 0; i < 6; i++)
  538. { /*SE VERDADEIRO, RETORNA 1 E SEQUENCIA CONTINUA*/
  539. if(tabuleiro[x1][y1] == jogador1[i])
  540. return 1;
  541. }
  542. }
  543. /*INDENTIFICA QUAL E O JOGADOR*/
  544. else if(atual == 2)
  545. { /*VERIFICA SE A PECA E DELE*/
  546. for(i = 0; i < 6; i++)
  547. { /*SE VERDADEIRO, RETORNA 1 E SEQUENCIA CONTINUA*/
  548. if(tabuleiro[x1][y1] == jogador2[i])
  549. return 1;
  550. }
  551. }
  552. /*CASO NAO, RETORNA 0 E VERIFICAO PARA*/
  553. return 0;
  554. }
  555. /*VERIFICA SE NO DESTINO EXISTE UMA PECA ALIADA*/
  556. int ocupado(int x2, int y2, int atual){
  557. int i;
  558. /*INDENTIFICA QUAL E O JOGADOR*/
  559. if(atual == 1)
  560. { /*VERIFICA E HA ALGUMA PECA ALIADA NO LOCAL DE JOGADA*/
  561. for(i = 0; i < 6; i++)
  562. { /*SE VERDADEIRO RETORNA 0 E A JOGADA E INVALIDA*/
  563. if(tabuleiro[x2][y2] == jogador1[i])
  564. return 0;
  565. }
  566. }
  567. /*INDENTIFICA QUAL E O JOGADOR*/
  568. else if(atual == 2)
  569. { /*VERIFICA E HA ALGUMA PECA ALIADA NO LOCAL DE JOGADA*/
  570. for(i = 0; i < 6; i++)
  571. { /*SE VERDADEIRO RETORNA 0 E A JOGADA E INVALIDA*/
  572. if(tabuleiro[x2][y2] == jogador2[i])
  573. return 0;
  574. }
  575. }
  576. /*CASO NAO, RETORNA 0 E VERIFICAO PARA*/
  577. return 1;
  578. }
  579. /*FUNCAO QUE VERIFICA SE A JOGADA E VALIDA*/
  580. int verifica(int x1, int y1, int x2, int y2, int atual){
  581. /*VERIFICA SE A POSICAO ATUAL EXISTE*/
  582. if((x1 < 8 && x1 >= 0) && (y1 < 8 && y1 >= 0))
  583. { /*VERIFICA SE A POSICAO DE JOGADA EXISTE*/
  584. if((x2 < 8 && x2 >= 0) && (y2 < 8 && y2 >= 0))
  585. { /*VERIFICA SE A POSICAO ATUAL NAO E VAZIA*/
  586. if(tabuleiro[x1][y1] != ' ')
  587. { /*VERIFICA SE NO DESTINO EXISTE UMA PECA ALIADA*/
  588. if(ocupado(x2, y2, atual))
  589. { /*VERIFICA SE O JOGADOR PEGOU SUA PECA*/
  590. if(peca_certa(x1, y1, atual))
  591. { /*VERIFICA SE O MOVIMENTO DA PECA E POSSIVEL*/
  592. if(possivel(x1, y1, x2, y2, atual))
  593. {
  594. return 1;
  595. }
  596. }
  597. }
  598. }
  599. }
  600. }
  601.  
  602. return 0;
  603. }
  604.  
  605. void cabecalho(){
  606.  
  607. puts("\t\t\t\t\t\t'C'HESS");
  608. puts("\t\t\tJOGO TOTALMENTE DESENVOLVIDO COM AS ESTRUTURAS BASICAS DE C");
  609. puts("\t\tDEV: Anderson da Costa Santos - SEGUNDO PERIODO DE CIENCIA DA COMPUTACAO");
  610. putchar('\n');
  611. }
  612.  
  613. int main(void){
  614.  
  615. int x1, y1, x2, y2;
  616. int atual = 1, XequeMate = 1, validez;
  617. char king;
  618. /*O JOGO SE MANTEM ATE QUE OCORRA O XEQUE MATE*/
  619. while(XequeMate)
  620. {
  621. /*MOSTRA O CABECALHO DO PROGRAMA*/
  622. cabecalho();
  623. validez = 1;
  624. do
  625. {
  626. printf("\t\t\t\t\t\tJOGADOR %d", atual);
  627. king = (atual == 1) ? 'k' : 'K';
  628. /*VERIFICA SE O JOGADOR ATUAL ESTÁ EM XEQUE*/
  629. if(xeque(x2, y2, king, atual))
  630. {
  631. pula_linha(1);
  632. puts("\t\t\t\t\t\tEM XEQUE!");
  633. }
  634.  
  635. pula_linha(2);
  636. visualizar_tabuleiro();
  637. pula_linha(2);
  638. /*INFORMA A COORDENADA DA PEÇA*/
  639. printf("COORDENADA DA PECA QUE DESEJA JOGAR[X / Y]: ");
  640. scanf("%d %d", &x1, &y1);
  641. pula_linha(1);
  642. printf("COORDENADA DA POSICAO QUE DESEJA INSERIR[X / Y]: ");
  643. scanf("%d %d", &x2, &y2);
  644. pula_linha(1);
  645. /*VERIFICA SE TAL JOGADA E VALIDA*/
  646. if(verifica(x1, y1, x2, y2, atual))
  647. {
  648. /*SE A VERIFICACAO FOR VALIDA, A PECA SE DESLOCA*/
  649. movimento(x1, y1, x2, y2);
  650. /*JOGADA SENDO VALIDA, A VARIAVEL RECEBE 0 E ENCERRA O LOOP*/
  651. validez = 0;
  652. }
  653. else
  654. puts("\t\t\t\t\t JOGADA INVALIDA!!!");
  655. pula_linha(2);
  656. }
  657. /*SE A JOGADA NAO FOR VALIDA, O LOOP SE REPETE*/
  658. while(validez);
  659. /*INFORMA QUEM VAI SER O PROXIMO A JOGAR*/
  660. atual == 1 ? atual++ : atual--;
  661. /*LIMPA TELA*/
  662. system("cls");
  663. }
  664.  
  665. return 0;
  666. }
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!