API tools faq
paste
Advertisement
Guest User

Untitled

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