API tools faq
paste
Advertisement
Essam_khames

Untitled

Essam_khames
Dec 22nd, 2018
112
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 103.88 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define ROWS 8
  5. #define COLUMNS 8
  6. #define PIECES 16
  7. #define MAX_DIFFERENCE 7
  8. #define MAX_PLAYS 1000000
  9. char domain[ROWS][COLUMNS];
  10. int occupied[ROWS][COLUMNS];
  11. char killed1[PIECES];
  12. char killed2[PIECES];
  13. int checkedby1[ROWS+2][COLUMNS+2];
  14. int checkedby2[ROWS+2][COLUMNS+2];
  15. int zone1[ROWS][COLUMNS];
  16. int zone2[ROWS][COLUMNS];
  17. int kp1i=0,kp1j=4;
  18. int kp2i=7,kp2j=4;
  19. int number_killed1=0;
  20. int number_killed2=0;
  21. int flaz=0;
  22. int turn=1;
  23. int winner=0,draw=0;
  24. int counter_steps1=0,counter_steps2=0;
  25. int pointer1=0,pointer2=0;
  26. char letter[8]={'A','B','C','D','E','F','G','H'};
  27. int number[8]={1,2,3,4,5,6,7,8};
  28. int i1,j1,i2,j2;
  29. char promotion = 'o';
  30. void save (void);
  31. void load (void);
  32. void set_game(void);
  33. void print_board(void);
  34. void blackandwhite(int i,int j);
  35. void movement(void);
  36. void save_step(int i1,int j1,int i2,int j2,char eaten,char piece);
  37. void move_piece (int i1, int j1,int i2,int j2,int turn);
  38. void premote(char *a);
  39. void move_king(int i1,int j1,int i2, int j2);
  40. void set_checks1(void);
  41. void set_checks2(void);
  42. void read(char *i1,char *j1,char *i2,char *j2,char *promotion);
  43. void check_mate(void);
  44. void end_game(void);
  45. void set1(void);
  46. void set2(void);
  47. void switch_turns(void);
  48. int movability1[ROWS][COLUMNS];
  49. int movability2[ROWS][COLUMNS];
  50. void checking_move(void);
  51.  
  52.  
  53. typedef struct {
  54. char piece;
  55. int domain1i;
  56. int domain1j;
  57. int domain2i;
  58. int domain2j;
  59. char eaten;}steps;
  60. steps steps1[MAX_PLAYS];
  61. steps steps2[MAX_PLAYS];
  62.  
  63.  
  64. int main()
  65. {
  66. set_game();
  67. set1();
  68. set2();
  69. do
  70. {
  71. system("CLS");
  72. print_board();
  73. if(checkedby2[kp1i+1][kp1j+1]||checkedby1[kp2i+1][kp2j+1])
  74. {
  75. check_mate();
  76. }
  77. else
  78. {
  79. movement();
  80. set1();
  81. set2();
  82. set_checks1();
  83. set_checks2();
  84.  
  85. checking_move();
  86. switch_turns();}
  87.  
  88. }while(winner==0 && draw==0);
  89.  
  90. return 0;
  91. }
  92. void movement(void)
  93. {
  94.  
  95. char i1c,j1c,i2c,j2c,promotion='o';
  96.  
  97. AGAIN :
  98. printf("\n\n");
  99. printf("\v Enter 'S' if you want to save this game or Enter 'L' if you want to load your game \n ");
  100. printf("Enter player %d move : ",turn);
  101.  
  102. read(&j1c,&i1c,&j2c,&i2c,&promotion);
  103.  
  104.  
  105.  
  106. if(j1c=='u' || j1c=='U')
  107. {
  108. undo();
  109. return;
  110. }
  111. if(j1c=='r' || j1c=='R')
  112. {
  113. redo();
  114. return;
  115. }
  116. if(j1c=='s' || j1c=='S'){
  117. save();
  118. return movement();
  119. }
  120. if(j1c=='l' || j1c=='L'){
  121. load();
  122. switch_turns();
  123. return;
  124. }
  125. promotion=tolower(promotion);
  126.  
  127.  
  128. if(islower(j1c))
  129. j1c=toupper(j1c);
  130. if(islower(j2c))
  131. j2c= toupper(j2c);
  132. if(turn==1&&isupper(promotion))
  133. promotion=tolower(promotion);
  134. if(turn==2&&islower(promotion))
  135. promotion=toupper(promotion);
  136.  
  137. switch(j1c)
  138. {
  139. case 'A' : j1=0; break;
  140. case 'B' : j1=1; break;
  141. case 'C' : j1=2; break;
  142. case 'D' : j1=3; break;
  143. case 'E' : j1=4; break;
  144. case 'F' : j1=5; break;
  145. case 'G' : j1=6; break;
  146. case 'H' : j1=7; break;
  147. default : printf("Column intial is wrong! \nplease re-enter your move");
  148. goto AGAIN; break;
  149. }
  150. switch(j2c)
  151. {
  152. case 'A' : j2=0; break;
  153. case 'B' : j2=1; break;
  154. case 'C' : j2=2; break;
  155. case 'D' : j2=3; break;
  156. case 'E' : j2=4; break;
  157. case 'F' : j2=5; break;
  158. case 'G' : j2=6; break;
  159. case 'H' : j2=7; break;
  160. default : printf("Column final is wrong! \nplease re-enter your move");
  161. goto AGAIN; break;
  162. }
  163. switch(i1c)
  164. {
  165. case '8' : i1=0; break;
  166. case '7' : i1=1; break;
  167. case '6' : i1=2; break;
  168. case '5' : i1=3; break;
  169. case '4' : i1=4; break;
  170. case '3' : i1=5; break;
  171. case '2' : i1=6; break;
  172. case '1' : i1=7; break;
  173. default : printf("row initial is wrong! \nplease re-enter your move");
  174. goto AGAIN; break;
  175. }
  176. switch(i2c)
  177. {
  178. case '8' : i2=0; break;
  179. case '7' : i2=1; break;
  180. case '6' : i2=2; break;
  181. case '5' : i2=3; break;
  182. case '4' : i2=4; break;
  183. case '3' : i2=5; break;
  184. case '2' : i2=6; break;
  185. case '1' : i2=7; break;
  186. default : printf("row final is wrong! \nplease re-enter your move");
  187. goto AGAIN; break;
  188. }
  189.  
  190. if(occupied[i1][j1]==0)
  191. {
  192. printf("nothing to move from the initial position.\nplease re-enter your move.");
  193. goto AGAIN;
  194. }
  195. else
  196. {
  197. if (turn==1)
  198. {
  199. if(islower(domain[i1][j1]))
  200. goto CONT;
  201. else
  202. {
  203. printf("You can't move the other player's piece.\nplease re-enter your move");
  204. goto AGAIN;
  205. }
  206. }
  207. if (turn==2)
  208. {
  209. if(isupper(domain[i1][j1]))
  210. goto CONT;
  211. else
  212. {
  213. printf("You can't move the other player's piece.\n please re-enter your move");
  214. goto AGAIN;
  215. }
  216. }
  217. }
  218. CONT :
  219. move_piece(i1,j1,i2,j2,turn);
  220. blackandwhite(i1,j1);
  221.  
  222.  
  223. }
  224. void set_game(void)
  225. {
  226. /*filling the 1st , 2nd , 7th and 8th rows*/
  227. int i,j;
  228. for(i=0; i<2; i++)
  229. {
  230. for(j=0;j<COLUMNS;j++)
  231. {
  232. occupied[i][j]=1;
  233. }
  234. }
  235. for(i=6; i<8; i++)
  236. {
  237. for(j=0;j<COLUMNS;j++)
  238. {
  239. occupied[i][j]=2;
  240. }
  241. }
  242.  
  243. /* setting pawns on board*/
  244.  
  245. for(j=0; j<COLUMNS; j++)
  246. {
  247. domain[1][j]='p';
  248. domain[6][j]='P';
  249. }
  250. /*eltabya*/
  251. domain[0][0]=domain[0][7]='r';
  252. domain[7][0]=domain[7][7]='R';
  253. /*el7osan*/
  254. domain[0][1]=domain[0][6]='n';
  255. domain[7][1]=domain[7][6]='N';
  256. /*elephant*/
  257. domain[0][2]=domain[0][5]='b';
  258. domain[7][2]=domain[7][5]='B';
  259. /*Queen*/
  260. domain[0][3]='q';
  261. domain[7][3]='Q';
  262. /*king*/
  263. domain[0][4]='k';
  264. domain[7][4]='K';
  265. for(i=2; i<6;i++)
  266. {
  267. for(j=0;j<COLUMNS;j++)
  268. {
  269. occupied[i][j]=0;
  270. if((i+j)%2==0)
  271. {
  272. domain[i][j]='.';
  273. }else{
  274. domain[i][j]='-';
  275. }
  276. }
  277. }
  278.  
  279. for(i=0; i<ROWS+2;i++)
  280. {
  281. checkedby1[i][0]=1;
  282. checkedby1[i][9]=1;
  283. checkedby2[i][0]=1;
  284. checkedby2[i][9]=1;
  285. checkedby1[0][i]=1;
  286. checkedby1[9][i]=1;
  287. checkedby2[0][i]=1;
  288. checkedby2[9][i]=1;
  289. }
  290. for(j=1;j<COLUMNS+1;j++){
  291. checkedby1[3][j]=1;
  292. checkedby2[6][j]=1;
  293. }
  294.  
  295.  
  296.  
  297.  
  298.  
  299. }
  300. void print_board(void)
  301. {
  302. int i,j,k,c;
  303. c=0;
  304. int n=49;
  305. printf(" ");
  306. for(k=0; k<8;k++)
  307. printf(" %c",letter[k]);
  308. printf("\n");
  309. printf(" ");
  310. for(k=0; k<n;k++){
  311. printf("-");
  312. if(k==n-1)
  313. printf("\n");
  314. }
  315. for(i=0;i<ROWS;i++)
  316. {
  317. for(j=0; j<COLUMNS;j++)
  318. {
  319. if(j==0)
  320. {
  321. printf(" %d | %c |",number[7-i],domain[i][j]);
  322.  
  323. }
  324. else if (j==7)
  325. {
  326. printf(" %c | %d",domain[i][j],number[7-i]);
  327. }
  328. else
  329. {
  330. printf(" %c |",domain[i][j]);
  331. }
  332. if(j==7 && i==4){
  333. printf(" Killed Player 1 : ");
  334. while(c<number_killed1)
  335. {
  336. printf(" %c,",killed1[c]);
  337. c++;
  338. if(c==8)
  339. printf("\n");
  340. }}
  341. c=0;
  342. if(j==7 && i==5){
  343. printf(" Killed Player 2 :");
  344. while(c<number_killed2)
  345. {
  346. printf(" %c,",killed2[c]);
  347. c++;
  348. if(c==8)
  349. printf("\n");
  350. }}
  351. if(j==COLUMNS-1)
  352. {
  353.  
  354.  
  355. printf("\n");
  356. printf(" ");
  357. for(k=0; k<n;k++){
  358. printf("-");
  359. if(k==n-1)
  360. printf("\n");
  361. }
  362.  
  363. }
  364.  
  365.  
  366.  
  367. }
  368. }
  369. printf(" ");
  370.  
  371. for(k=0; k<8;k++)
  372. printf(" %c",letter[k]);
  373.  
  374.  
  375.  
  376. }
  377. void blackandwhite(int i,int j)
  378.  
  379. {
  380.  
  381. if(occupied[i][j]==0)
  382. {
  383. if((i+j)%2==0)
  384. domain[i][j]='.';
  385. else
  386. domain[i][j]='-';
  387. }
  388.  
  389.  
  390. }
  391. void move_piece(int i1, int j1,int i2, int j2,int turn){
  392.  
  393.  
  394. /* for player 1*/
  395. if(turn==1){
  396. /*moving pawn*/
  397. if(domain[i1][j1]=='p')
  398. {
  399. if(i1==1){
  400. /*if next square is correct and empty*/
  401. if((i2-i1==1||i2-i1==2)&&j1==j2&& occupied[i2][j2]==0&&occupied[i1+1][j2]==0){
  402. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  403. domain[i2][j2]=domain[i1][j1];
  404. occupied[i1][j1]=0;
  405. occupied[i2][j2]=1;
  406.  
  407. } else if(i2==i1+1&&(j2==j1-1||j2==j1+1)&&occupied[i2][j2]==2)
  408. {
  409. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  410. killed2[number_killed2]=domain[i2][j2];
  411. domain[i2][j2]=domain[i1][j1];
  412. number_killed2++;
  413. occupied[i1][j1]=0;
  414. occupied[i2][j2]=1;
  415.  
  416.  
  417.  
  418. }
  419. else
  420. {
  421. printf("Incorrect move.\nPlease re-enter your move.");
  422. movement();
  423. }
  424. }
  425. else if((i2-i1==1)&&j1==j2&& occupied[i2][j2]==0){
  426. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  427. if(i2==7)
  428. {
  429. premote(&domain[i1][j1]);
  430. }
  431.  
  432. domain[i2][j2]=domain[i1][j1];
  433. occupied[i1][j1]=0;
  434. occupied[i2][j2]=1;
  435. return;
  436.  
  437.  
  438.  
  439. }
  440.  
  441. /*eaten player 2 piece*/
  442. else if(i2==i1+1&&(j2==j1-1||j2==j1+1)&&occupied[i2][j2]==2)
  443. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  444.  
  445. if(i2==7)
  446. {
  447. premote(&domain[i1][j1]);
  448.  
  449. }
  450.  
  451. killed2[number_killed2]=domain[i2][j2];
  452. domain[i2][j2]=domain[i1][j1];
  453. number_killed2++;
  454. occupied[i1][j1]=0;
  455. occupied[i2][j2]=1;
  456.  
  457.  
  458.  
  459. }
  460.  
  461. else
  462. {
  463. printf("Incorrect move.\nPlease re-enter your move.");
  464. movement();
  465. }
  466. return;
  467.  
  468. }
  469. /*moving tabya*/
  470. if(domain[i1][j1]=='r')
  471. {
  472. /*moving through the row*/
  473. if(i2==i1)
  474. {
  475. int n;
  476. if(j2>j1){
  477. for(n=j1+1;n<j2;n++)
  478. {
  479. if(occupied[i1][n])
  480. {
  481. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  482. movement();
  483. goto OUT;
  484. }}}
  485. if(j1>j2)
  486. {
  487. for(n=j1-1;n>j2;n--)
  488. {
  489. if(occupied[i1][n])
  490. {
  491. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  492. movement();
  493. goto OUT;
  494. }}
  495. }
  496. if(occupied[i1][j2]==1)
  497. {
  498. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  499. movement();
  500. return;
  501. }save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  502. if(occupied[i2][j2]==2)
  503. {
  504. occupied[i2][j2]=1;
  505. occupied[i1][j1]=0;
  506. killed2[number_killed2]=domain[i2][j2];
  507. domain[i2][j2]=domain[i1][j1];
  508. number_killed2++;
  509. }
  510. if(occupied[i2][j2]==0)
  511. {
  512. domain[i2][j2]=domain[i1][j1];
  513. occupied[i1][j1]=0;
  514. occupied[i2][j2]=1;
  515.  
  516. }
  517. }
  518. else if(j2==j1)
  519. {
  520. int n;
  521. if(i2>i1)
  522. {
  523. for(n=i1+1;n<i2;n++)
  524. {
  525. if(occupied[n][j1])
  526. {
  527. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  528. movement();
  529. return;
  530.  
  531. }}}
  532. if(i1>i2)
  533. {
  534. for(n=i1-1;n>i2;n--)
  535. {
  536. if(occupied[n][j1])
  537. {
  538. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  539. movement();
  540. return;
  541.  
  542. }}
  543. }
  544. if(occupied[i2][j2]==1)
  545. {
  546. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  547. movement();
  548. return;
  549. }save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  550. if(occupied[i2][j2]==2)
  551. {
  552. occupied[i1][j1]=0;
  553. occupied[i2][j2]=1;
  554. killed2[number_killed2]=domain[i2][j2];
  555. domain[i2][j2]=domain[i1][j1];
  556. number_killed2++;
  557. }
  558. if(occupied[i2][j2]==0)
  559. {
  560. occupied[i1][j1]=0;
  561. occupied[i2][j2]=1;
  562. domain[i2][j2]=domain[i1][j1];
  563. }
  564.  
  565. }else
  566. {
  567. printf("Incorrect move.\nPlease re-enter your move.");
  568. movement();
  569. }
  570.  
  571. }
  572. /*moving the knight*/
  573. if(domain[i1][j1]=='n')
  574. {
  575. if((i2==i1+2&&(j2==j1-1||j2==j1+1))||(i2==i1-2&&(j2==j1-1||j2==j1+1))||(j2==j1+2&&(i2==i1-1||i2==i1+1))||(j2==j1-2&&(i2==i1-1||i2==i1+1)))
  576. {
  577. if(occupied[i2][j2]==1)
  578. {
  579. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  580. movement();
  581. return;
  582. }save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  583. if(occupied[i2][j2]==2)
  584. {
  585. occupied[i1][j1]=0;
  586. occupied[i2][j2]=1;
  587. killed2[number_killed2]=domain[i2][j2];
  588. domain[i2][j2]=domain[i1][j1];
  589. number_killed2++;
  590. }
  591. if(occupied[i2][j2]==0)
  592. {
  593. domain[i2][j2]=domain[i1][j1];
  594. occupied[i1][j1]=0;
  595. occupied[i2][j2]=1;
  596. }
  597. }else
  598. {
  599. printf("Incorrect move.\nPlease re-enter your move.");
  600. movement();
  601. }
  602. }
  603. if(domain[i1][j1]=='b')
  604. {
  605. int n,m;
  606. if(j2-j1==i2-i1 || j2-j1==i1-i2)
  607. {
  608. if(j2>j1&&i2>i1)
  609. {
  610. m=j1+1;
  611. for(n=i1+1;n<i2;n++)
  612. {
  613. if(occupied[n][m++])
  614. {
  615. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  616. movement();
  617. return;
  618. }
  619.  
  620. }
  621. }
  622.  
  623.  
  624.  
  625.  
  626. else if(j1>j2 && i2>i1)
  627. {
  628. m=j1-1;
  629. for(n=i1+1;n<i2;n++)
  630. {
  631. if(occupied[n][m--])
  632. {
  633. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  634. movement();
  635. return;
  636. }
  637.  
  638. }
  639. }
  640. else if (i1>i2 && j2>j1)
  641. {
  642. m=j1+1;
  643. for(n=i1-1;n>i2;n--)
  644. {
  645. if(occupied[n][m++])
  646. {
  647. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  648. movement();
  649. return;
  650. }
  651.  
  652. }
  653.  
  654. }
  655. else if(i2<i1 && j2<j1)
  656. {
  657. m=j1-1;
  658. for(n=i1-1;n>i2;n--)
  659. {
  660. if(occupied[n][m--])
  661. {
  662. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  663. movement();
  664. return;
  665. }
  666.  
  667. }
  668. }}
  669. else{
  670. printf("Incorrect move.\nPlease re-enter your move.");
  671. movement();
  672. return;
  673. }
  674. if(occupied[i2][j2]==1)
  675. {
  676. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  677. movement();
  678. return;
  679. }
  680. if(occupied[i2][j2]==2)
  681. {
  682. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  683. occupied[i1][j1]=0;
  684. occupied[i2][j2]=1;
  685. killed2[number_killed2]=domain[i2][j2];
  686. domain[i2][j2]=domain[i1][j1];
  687. number_killed2++;
  688. }
  689. if(occupied[i2][j2]==0)
  690. {
  691. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  692. domain[i2][j2]=domain[i1][j1];
  693. occupied[i1][j1]=0;
  694. occupied[i2][j2]=1;
  695. }
  696.  
  697. }
  698.  
  699.  
  700.  
  701. }
  702. if(domain[i1][j1]=='q')
  703. {
  704. int n,m;
  705. if(j2-j1==i2-i1 || j2-j1==i1-i2)
  706. {
  707. if(j2>j1&&i2>i1)
  708. {
  709. m=j1+1;
  710. for(n=i1+1;n<i2;n++)
  711. {
  712. if(occupied[n][m++])
  713. {
  714. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  715. movement();
  716. goto OUT;
  717. }
  718.  
  719. }
  720. }
  721.  
  722.  
  723.  
  724.  
  725. else if(j1>j2 && i2>i1)
  726. {
  727. m=j1-1;
  728. for(n=i1+1;n<i2;n++)
  729. {
  730. if(occupied[n][m--])
  731. {
  732. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  733. movement();
  734. return;
  735. }
  736.  
  737. }
  738. }
  739. else if (i1>i2 && j2>j1)
  740. {
  741. m=j1+1;
  742. for(n=i1-1;n>i2;n--)
  743. {
  744. if(occupied[n][m++])
  745. {
  746. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  747. movement();
  748. return;
  749. }
  750.  
  751. }
  752.  
  753. }
  754. else if(i2<i1 && j2<j1)
  755. {
  756. for(n=i1-1;n>i2;n--)
  757. {
  758. m=j1-1;
  759.  
  760. if(occupied[n][m--])
  761. {
  762. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  763. movement();
  764. return;
  765. }
  766.  
  767. }
  768. }
  769. if(occupied[i2][j2]==1)
  770. {
  771. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  772. movement();
  773. return;
  774. }
  775. if(occupied[i2][j2]==2)
  776. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  777. occupied[i1][j1]=0;
  778. occupied[i2][j2]=1;
  779. killed2[number_killed2]=domain[i2][j2];
  780. domain[i2][j2]=domain[i1][j1];
  781. number_killed2++;
  782. }
  783. if(occupied[i2][j2]==0)
  784. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  785. domain[i2][j2]=domain[i1][j1];
  786. occupied[i1][j1]=0;
  787. occupied[i2][j2]=1;
  788. }
  789. }
  790. else if(i2==i1)
  791. {
  792. int n;
  793. if(j2>j1){
  794. for(n=j1+1;n<j2;n++)
  795. {
  796. if(occupied[i1][n])
  797. {
  798. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  799. movement();
  800. return;
  801. }}}
  802. if(j1>j2)
  803. {
  804. for(n=j1-1;n>j2;n--)
  805. {
  806. if(occupied[i1][n])
  807. {
  808. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  809. movement();
  810. return;
  811. }}
  812. }
  813. if(occupied[i1][j2]==1)
  814. {
  815. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  816. movement();
  817. return;
  818. }
  819. if(occupied[i2][j2]==2)
  820. {save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  821. occupied[i2][j2]=1;
  822. occupied[i1][j1]=0;
  823. killed2[number_killed2]=domain[i2][j2];
  824. domain[i2][j2]=domain[i1][j1];
  825. number_killed2++;
  826. }
  827. if(occupied[i2][j2]==0)
  828. {save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  829. domain[i2][j2]=domain[i1][j1];
  830. occupied[i1][j1]=0;
  831. occupied[i2][j2]=1;
  832.  
  833. }
  834. }
  835. else if(j2==j1)
  836. {
  837. int n;
  838. if(i2>i1)
  839. {
  840. for(n=i1+1;n<i2;n++)
  841. {
  842. if(occupied[n][j1])
  843. {
  844. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  845. movement();
  846. return;
  847.  
  848. }}}
  849. if(i1>i2)
  850. {
  851. for(n=i1-1;n>i2;n--)
  852. {
  853. if(occupied[n][j1])
  854. {
  855. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  856. movement();
  857. return;
  858.  
  859. }}
  860. }
  861. if(occupied[i2][j2]==1)
  862. {
  863. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  864. movement();
  865. }
  866. if(occupied[i2][j2]==2)
  867. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  868. occupied[i1][j1]=0;
  869. occupied[i2][j2]=1;
  870. killed2[number_killed2]=domain[i2][j2];
  871. domain[i2][j2]=domain[i1][j1];
  872. number_killed2++;
  873. }
  874. if(occupied[i2][j2]==0)
  875. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  876. occupied[i1][j1]=0;
  877. occupied[i2][j2]=1;
  878. domain[i2][j2]=domain[i1][j1];
  879. }
  880.  
  881. }
  882. else
  883. {
  884. printf("Incorrect move.\nPlease re-enter your move.");
  885. movement();
  886. }
  887.  
  888. }
  889.  
  890. if(domain[i1][j1]=='k')
  891. {
  892. move_king(i1,j1,i2,j2);
  893. }
  894.  
  895. /******* PLAYER 2**********/
  896. if(turn==2)
  897. {
  898. if(domain[i1][j1]=='P')
  899. {
  900.  
  901.  
  902. if(i1==6){
  903. /*if next square is correct and empty*/
  904. if((i1-i2==1||i1-i2==2)&&j1==j2&& occupied[i2][j2]==0&&occupied[i1-1][j2]==0){
  905. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  906. domain[i2][j2]=domain[i1][j1];
  907. occupied[i1][j1]=0;
  908. occupied[i2][j2]=2;
  909.  
  910. }else if((i1-i2==1)&&j1==j2&& occupied[i2][j2]==0){
  911. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  912. domain[i2][j2]=domain[i1][j1];
  913. occupied[i1][j1]=0;
  914. occupied[i2][j2]=2;
  915.  
  916.  
  917.  
  918.  
  919. }
  920. else
  921. {
  922. printf("Incorrect move.\nPlease re-enter your move.");
  923. movement();
  924. }
  925. }
  926. else if((i1-i2==1)&&j1==j2&& occupied[i2][j2]==0){
  927. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  928. if(i2==0)
  929. {
  930. premote(&domain[i1][j1]);
  931. }
  932.  
  933. domain[i2][j2]=domain[i1][j1];
  934. occupied[i1][j1]=0;
  935. occupied[i2][j2]=2;
  936.  
  937.  
  938.  
  939.  
  940. }
  941.  
  942. /*eaten player 1 piece*/
  943. else if(i2==i1-1&&(j2==j1-1||j2==j1+1)&&occupied[i2][j2]==1)
  944. {
  945. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  946. if(i2==0)
  947. {
  948. premote(&domain[i1][j1]);
  949.  
  950. }
  951.  
  952. killed1[number_killed1]=domain[i2][j2];
  953. domain[i2][j2]=domain[i1][j1];
  954. number_killed1++;
  955. occupied[i1][j1]=0;
  956. occupied[i2][j2]=2;
  957.  
  958.  
  959.  
  960. }
  961.  
  962. else
  963. {
  964. printf("Incorrect move.\nPlease re-enter your move.");
  965. movement();
  966. return;
  967. }
  968. return;
  969.  
  970. }
  971. if(domain[i1][j1]=='R')
  972. {
  973. if(i2==i1)
  974. {
  975. int n;
  976. if(j2>j1){
  977. for(n=j1+1;n<j2;n++)
  978. {
  979. if(occupied[i1][n])
  980. {
  981. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  982. movement();
  983. return;
  984. }}}
  985. if(j1>j2)
  986. {
  987. for(n=j1-1;n>j2;n--)
  988. {
  989. if(occupied[i1][n])
  990. {
  991. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  992. movement();
  993. return;
  994. }}
  995. }
  996. if(occupied[i1][j2]==2)
  997. {
  998. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  999. movement();
  1000. return;
  1001. }
  1002. if(occupied[i2][j2]==1)
  1003. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1004. occupied[i2][j2]=2;
  1005. occupied[i1][j1]=0;
  1006. killed1[number_killed1]=domain[i2][j2];
  1007. domain[i2][j2]=domain[i1][j1];
  1008. number_killed1++;
  1009. }
  1010. if(occupied[i2][j2]==0)
  1011. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1012. domain[i2][j2]=domain[i1][j1];
  1013. occupied[i1][j1]=0;
  1014. occupied[i2][j2]=2;
  1015.  
  1016. }
  1017. }
  1018. else if(j2==j1)
  1019. {
  1020. int n;
  1021. if(i2>i1)
  1022. {
  1023. for(n=i1+1;n<i2;n++)
  1024. {
  1025. if(occupied[n][j1])
  1026. {
  1027. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1028. movement();
  1029. return;
  1030.  
  1031. }}}
  1032. if(i1>i2)
  1033. {
  1034. for(n=i1-1;n>i2;n--)
  1035. {
  1036. if(occupied[n][j1])
  1037. {
  1038. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1039. movement();
  1040. return;
  1041.  
  1042. }}
  1043. }
  1044. if(occupied[i2][j2]==2)
  1045. {
  1046. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1047. movement();
  1048. return;
  1049. }
  1050. if(occupied[i2][j2]==1)
  1051. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1052. occupied[i1][j1]=0;
  1053. occupied[i2][j2]=2;
  1054. killed1[number_killed1]=domain[i2][j2];
  1055. domain[i2][j2]=domain[i1][j1];
  1056. number_killed1++;
  1057. }
  1058. if(occupied[i2][j2]==0)
  1059. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1060. occupied[i1][j1]=0;
  1061. occupied[i2][j2]=2;
  1062. domain[i2][j2]=domain[i1][j1];
  1063. }
  1064.  
  1065. }else
  1066. {
  1067. printf("Incorrect move.\nPlease re-enter your move.");
  1068. movement();
  1069. return;
  1070. }
  1071.  
  1072. }
  1073. if(domain[i1][j1]=='N')
  1074. {
  1075. if((i2==i1+2&&(j2==j1-1||j2==j1+1))||(i2==i1-2&&(j2==j1-1||j2==j1+1))||(j2==j1+2&&(i2==i1-1||i2==i1+1))||(j2==j1-2&&(i2==i1-1||i2==i1+1)))
  1076. {
  1077. if(occupied[i2][j2]==2)
  1078. {
  1079. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1080. movement();
  1081. return;
  1082. }
  1083. if(occupied[i2][j2]==1)
  1084. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1085. occupied[i1][j1]=0;
  1086. occupied[i2][j2]=2;
  1087. killed1[number_killed1]=domain[i2][j2];
  1088. domain[i2][j2]=domain[i1][j1];
  1089. number_killed1++;
  1090. }
  1091. if(occupied[i2][j2]==0)
  1092. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1093. domain[i2][j2]=domain[i1][j1];
  1094. occupied[i1][j1]=0;
  1095. occupied[i2][j2]=2;
  1096. }
  1097. }else
  1098. {
  1099. printf("Incorrect move.\nPlease re-enter your move.");
  1100. movement();
  1101. }
  1102. }
  1103. if(domain[i1][j1]=='B')
  1104. {
  1105.  
  1106. int n,m;
  1107. if(j2-j1==i2-i1 || j2-j1==i1-i2)
  1108. {
  1109. m=j1+1;
  1110. if(j2>j1&&i2>i1)
  1111. {
  1112. for(n=i1+1;n<i2;n++)
  1113. {
  1114. if(occupied[n][m++])
  1115. {
  1116. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1117. movement();
  1118. goto OUT;
  1119. }
  1120.  
  1121. }
  1122. }
  1123.  
  1124.  
  1125.  
  1126.  
  1127. else if(j1>j2 && i2>i1)
  1128. {
  1129. m=j1-1;
  1130. for(n=i1+1;n<i2;n++)
  1131. {
  1132. if(occupied[n][m--])
  1133. {
  1134. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1135. movement();
  1136. goto OUT;
  1137. }
  1138.  
  1139. }
  1140. }
  1141. else if (i1>i2 && j2>j1)
  1142. {
  1143. m=j1+1;
  1144. for(n=i1-1;n>i2;n--)
  1145. {
  1146. if(occupied[n][m++])
  1147. {
  1148. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1149. movement();
  1150. return;
  1151. }
  1152.  
  1153. }
  1154.  
  1155. }
  1156. else if(i2<i1 && j2<j1)
  1157. {
  1158. m=j1-1;
  1159. for(n=i1-1;n>i2;n--)
  1160. {
  1161. if(occupied[n][m--])
  1162. {
  1163. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1164. movement();
  1165. return;
  1166. }
  1167.  
  1168. }
  1169. }}
  1170. else{
  1171. printf("Incorrect move.\nPlease re-enter your move.");
  1172. movement();
  1173. return;
  1174. }
  1175. if(occupied[i2][j2]==2)
  1176. {
  1177. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1178. movement();
  1179. return;
  1180. }
  1181. if(occupied[i2][j2]==1)
  1182. {save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1183. occupied[i1][j1]=0;
  1184. occupied[i2][j2]=2;
  1185. killed1[number_killed1]=domain[i2][j2];
  1186. domain[i2][j2]=domain[i1][j1];
  1187. number_killed1++;
  1188. }
  1189. if(occupied[i2][j2]==0)
  1190. {save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1191. domain[i2][j2]=domain[i1][j1];
  1192. occupied[i1][j1]=0;
  1193. occupied[i2][j2]=2;
  1194. }
  1195.  
  1196.  
  1197.  
  1198.  
  1199. }
  1200. if(domain[i1][j1]=='Q')
  1201. {
  1202. int n,m;
  1203. if(j2-j1==i2-i1 || j2-j1==i1-i2)
  1204. {
  1205. m=j1+1;
  1206. if(j2>j1&&i2>i1)
  1207. {
  1208. for(n=i1+1;n<i2;n++)
  1209. {
  1210. if(occupied[n][m++])
  1211. {
  1212. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1213. movement();
  1214. return;
  1215. }
  1216.  
  1217. }
  1218. }
  1219.  
  1220. else if(j1>j2 && i2>i1)
  1221. {
  1222. m=j1-1;
  1223. for(n=i1+1;n<i2;n++)
  1224. {
  1225. if(occupied[n][m--])
  1226. {
  1227. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1228. movement();
  1229. return;
  1230. }
  1231.  
  1232. }
  1233. }
  1234. else if (i1>i2 && j2>j1)
  1235. {
  1236. m=j1+1;
  1237. for(n=i1-1;n>i2;n--)
  1238. {
  1239. if(occupied[n][m++])
  1240. {
  1241. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1242. movement();
  1243. return;
  1244. }
  1245.  
  1246. }
  1247.  
  1248. }
  1249. else if(i2<i1 && j2<j1)
  1250. {
  1251. m=j1-1;
  1252.  
  1253. for(n=i1-1;n>i2;n--)
  1254. {
  1255. if(occupied[n][m--])
  1256. {
  1257. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1258. movement();
  1259. return;
  1260. }
  1261.  
  1262. }
  1263. }
  1264. if(occupied[i2][j2]==2)
  1265. {
  1266. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1267. movement();
  1268. }
  1269. if(occupied[i2][j2]==1)
  1270. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1271. occupied[i1][j1]=0;
  1272. occupied[i2][j2]=2;
  1273. killed1[number_killed1]=domain[i2][j2];
  1274. domain[i2][j2]=domain[i1][j1];
  1275. number_killed1++;
  1276. }
  1277. if(occupied[i2][j2]==0)
  1278. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1279. domain[i2][j2]=domain[i1][j1];
  1280. occupied[i1][j1]=0;
  1281. occupied[i2][j2]=2;
  1282. }
  1283. }
  1284. else if(i2==i1)
  1285. {
  1286. int n;
  1287. if(j2>j1){
  1288. for(n=j1+1;n<j2;n++)
  1289. {
  1290. if(occupied[i1][n])
  1291. {
  1292. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1293. movement();
  1294. return;
  1295. }}}
  1296. if(j1>j2)
  1297. {
  1298. for(n=j1-1;n>j2;n--)
  1299. {
  1300. if(occupied[i1][n])
  1301. {
  1302. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1303. movement();
  1304. return;
  1305. }}
  1306. }
  1307. if(occupied[i1][j2]==2)
  1308. {
  1309. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1310. movement();
  1311. return;
  1312. }
  1313. if(occupied[i2][j2]==1)
  1314. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1315. occupied[i2][j2]=2;
  1316. occupied[i1][j1]=0;
  1317. killed1[number_killed1]=domain[i2][j2];
  1318. domain[i2][j2]=domain[i1][j1];
  1319. number_killed1++;
  1320. }
  1321. if(occupied[i2][j2]==0)
  1322. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1323. domain[i2][j2]=domain[i1][j1];
  1324. occupied[i1][j1]=0;
  1325. occupied[i2][j2]=2;
  1326.  
  1327. }
  1328. }
  1329. else if(j2==j1)
  1330. {
  1331. int n;
  1332. if(i2>i1)
  1333. {
  1334. for(n=i1+1;n<i2;n++)
  1335. {
  1336. if(occupied[n][j1])
  1337. {
  1338. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1339. movement();
  1340. return;
  1341.  
  1342. }}}
  1343. if(i1>i2)
  1344. {
  1345. for(n=i1-1;n>i2;n--)
  1346. {
  1347. if(occupied[n][j1])
  1348. {
  1349. printf("Incorrect move(a piece inside the path).\nPlease re-enter your move.");
  1350. movement();
  1351. return;
  1352.  
  1353. }}
  1354. }
  1355. if(occupied[i2][j2]==2)
  1356. {
  1357. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1358. movement();
  1359. return;
  1360. }
  1361. if(occupied[i2][j2]==1)
  1362. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1363. occupied[i1][j1]=0;
  1364. occupied[i2][j2]=2;
  1365. killed1[number_killed1]=domain[i2][j2];
  1366. domain[i2][j2]=domain[i1][j1];
  1367. number_killed1++;
  1368. }
  1369. if(occupied[i2][j2]==0)
  1370. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1371. occupied[i1][j1]=0;
  1372. occupied[i2][j2]=2;
  1373. domain[i2][j2]=domain[i1][j1];
  1374. }
  1375.  
  1376. }
  1377. else
  1378. {
  1379. printf("Incorrect move.\nPlease re-enter your move.");
  1380. movement();
  1381. return;
  1382. }
  1383.  
  1384. }
  1385. if(domain[i1][j1]=='K')
  1386. {
  1387. move_king(i1,j1,i2,j2);
  1388. }
  1389. }
  1390.  
  1391.  
  1392. OUT : return;
  1393. }
  1394.  
  1395.  
  1396. void premote(char *a)
  1397. {
  1398. if(promotion=='o')
  1399. {
  1400. printf("please enter a promotion for your pawn :");
  1401. scanf(" %c",a);
  1402. if(isupper(*a))
  1403. *a=tolower(*a);
  1404.  
  1405. }
  1406. if(*a!= 'o' && *a!='r' && *a!='n' && *a!='b' && *a != 'q')
  1407. {
  1408. do
  1409. {
  1410.  
  1411.  
  1412. printf("Incorrect promotion\nPlease enter a correct promotion : ");
  1413. scanf(" %c",a);
  1414. if(isupper(*a))
  1415. *a=tolower(*a);
  1416. }
  1417.  
  1418. while(*a!='r' && *a!='n' && *a!='b' && *a != 'q');
  1419. }
  1420. if(turn==1&&isupper(*a))
  1421. *a=tolower(*a);
  1422. if(turn==2&&islower(*a))
  1423. *a=toupper(*a);
  1424. }
  1425. void move_king(int i1,int j1,int i2,int j2)
  1426. {
  1427. if((j2-j1==-1 || j2-j1==0 || j2-j1==1) && (i2-i1==-1 || i2-i1==0 || i2-i1==1)){
  1428. int k,q;
  1429. if(domain[i1][j1]=='k')
  1430. {
  1431. for(k=i1-1; k<=i1+1; k++)
  1432. {
  1433. for(q=j1-1; q<=j1+1; q++)
  1434. {
  1435. if((k==i1 && q==j1) || (k<0 || k>7 || q<0 || q>7) )
  1436. continue;
  1437.  
  1438. if(!checkedby2[k+1][q+1] && occupied[k][q] != 1)
  1439. {
  1440. goto CONT2;
  1441. }
  1442. }
  1443. }
  1444. printf("You can't move the king\nPlease enter an-other move.");
  1445. movement();
  1446. return;
  1447. CONT2 :
  1448.  
  1449. if(checkedby2[i2+1][j2+1])
  1450. {
  1451. printf("You can't move the king to this position or you will lose.");
  1452. movement();
  1453. return;
  1454. }else
  1455. {
  1456. if(occupied[i2][j2]==1)
  1457. {
  1458. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1459. movement();
  1460. return;
  1461. }
  1462. if(occupied[i2][j2]==2)
  1463. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1464. kp1i=i2;
  1465. kp1j=j2;
  1466. occupied[i1][j1]=0;
  1467. occupied[i2][j2]=1;
  1468. killed2[number_killed2]=domain[i2][j2];
  1469. domain[i2][j2]=domain[i1][j1];
  1470. number_killed2++;
  1471. }
  1472. if(occupied[i2][j2]==0)
  1473. {
  1474.  
  1475. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1476. kp1i=i2;
  1477. kp1j=j2;
  1478. domain[i2][j2]=domain[i1][j1];
  1479. occupied[i1][j1]=0;
  1480. occupied[i2][j2]=1;
  1481. }
  1482.  
  1483. }
  1484. }else if(domain[i1][j1]=='K')
  1485. {
  1486.  
  1487. for(k=i1-1; k<=i1+1; k++)
  1488. {
  1489. for(q=j1-1; q<=j1+1; q++)
  1490. {
  1491. if((k==i1 && q==j1) || (k<0 || k>7 || q<0 || q>7) )
  1492. continue;
  1493.  
  1494. if(!checkedby1[k+1][q+1] && occupied[k][q] != 2)
  1495. {
  1496. goto CONT3;
  1497. }
  1498. }
  1499. }
  1500. printf("You can't move the king\nPlease enter an-other move.");
  1501. movement();
  1502. return;
  1503. CONT3 :
  1504.  
  1505. if(checkedby1[i2+1][j2+1])
  1506. {
  1507. printf("You can't move the king to this position or you will lose.");
  1508. movement();
  1509. return;
  1510. }else
  1511. {
  1512. if(occupied[i2][j2]==2)
  1513. {
  1514. printf("Incorrect move(moving over your own piece).\nPlease re-enter your move.");
  1515. movement();
  1516. return;
  1517. }
  1518. if(occupied[i2][j2]==1)
  1519. {
  1520. save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1521. kp2i=i2;
  1522. kp2j=j2;
  1523. occupied[i1][j1]=0;
  1524. occupied[i2][j2]=2;
  1525. killed1[number_killed1]=domain[i2][j2];
  1526. domain[i2][j2]=domain[i1][j1];
  1527. number_killed1++;
  1528. }
  1529. if(occupied[i2][j2]==0)
  1530. { save_step(i1,j1,i2,j2,domain[i2][j2],domain[i1][j1]);
  1531. kp2i=i2;
  1532. kp2j=j2;
  1533. domain[i2][j2]=domain[i1][j1];
  1534. occupied[i1][j1]=0;
  1535. occupied[i2][j2]=2;
  1536. }
  1537.  
  1538. }
  1539. }}
  1540. else
  1541. {
  1542. printf("Incorrect move for the king.\nPlease re-enter your move");
  1543. movement();
  1544. }
  1545. }
  1546. void set_checks1(void)
  1547. {
  1548.  
  1549. int i,j,k,q;
  1550.  
  1551. for(i=0; i<ROWS;i++)
  1552. {
  1553. for(j=0; j<COLUMNS; j++)
  1554. {
  1555. if(occupied[i][j]==1){
  1556.  
  1557. if(domain[i][j]=='r')
  1558. {
  1559. k=i+1;
  1560. while(!occupied[k][j]&&k<ROWS)
  1561. {
  1562. checkedby1[k+1][j+1]=1;
  1563. movability1[k++][j]=1;
  1564.  
  1565. }
  1566. if(k<8&&k>=0){
  1567. if(occupied[k][j]==2 ||occupied[k][j]==0)
  1568. {
  1569. checkedby1[k+1][j+1]=1;
  1570. movability1[k][j]=1;
  1571. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][j]=='K'){
  1572. k--;
  1573. zone2[k][j]=1;
  1574. while(!occupied[k][j]&&k>=0)
  1575. zone2[--k][j]=1;
  1576. }
  1577. }
  1578. else
  1579. {
  1580. checkedby1[k+1][j+1]=1;
  1581. }}
  1582. k=i-1;
  1583. while(!occupied[k][j]&&k>0)
  1584. {
  1585. checkedby1[k+1][j+1]=1;
  1586. movability1[k--][j]=1;
  1587. }
  1588.  
  1589. if(k<8&&k>=0){
  1590. if(occupied[k][j]==2 ||occupied[k][j]==0)
  1591. {
  1592. checkedby1[k+1][j+1]=1;
  1593. movability1[k][j]=1;
  1594. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][j]=='K'){
  1595. k++;
  1596. zone2[k][j]=1;
  1597. while(!occupied[k][j]&&k<8)
  1598. zone2[++k][j]=1;
  1599. }
  1600. }
  1601. else
  1602. {
  1603. checkedby1[k+1][j+1]=1;
  1604. }}
  1605. k=j+1;
  1606. while(!occupied[i][k]&&k<COLUMNS)
  1607. {
  1608. checkedby1[i+1][k+1]=1;
  1609. movability1[i][k++]=1;
  1610.  
  1611. }if(k<8&&k>=0){
  1612. if(occupied[i][k]==2 || occupied[i][k]==0 )
  1613. {
  1614. checkedby1[i+1][k+1]=1;
  1615. movability1[i][k]=1;
  1616. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[i][k]=='K'){
  1617. k--;
  1618. zone2[i][k]=1;
  1619. while(!occupied[i][k]&&k>=0)
  1620. zone2[i][--k]=1;
  1621. }
  1622.  
  1623. }
  1624. else
  1625. {
  1626. checkedby1[i+1][k+1]=1;
  1627. }}
  1628. k=j-1;
  1629. while(!occupied[i][k]&&k>0)
  1630. {
  1631. checkedby1[i+1][k+1]=1;
  1632. movability1[i][k--]=1;
  1633.  
  1634. }if(k<8&&k>=0){
  1635. if(occupied[i][k]==2 || occupied[i][k]==0)
  1636. {
  1637. checkedby1[i+1][k+1]=1;
  1638. movability1[i][k]=1;
  1639. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[i][k]=='K'){
  1640. k++;
  1641. zone2[i][k]=1;
  1642. while(!occupied[i][k]&&k<8)
  1643. zone2[i][++k]=1;
  1644. }
  1645. }
  1646. else
  1647. {
  1648. checkedby1[i+1][k+1]=1;
  1649. }}
  1650. }
  1651. if(domain[i][j]=='b')
  1652. {
  1653. k=i+1;
  1654. q=j+1;
  1655. while(!occupied[k][q]&&k<ROWS&&q<COLUMNS)
  1656. {
  1657. checkedby1[k+1][q+1]=1;
  1658. movability1[k++][q++]=1;
  1659. }
  1660. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1661. if(occupied[k][q]==2 || occupied[k][q]==0 )
  1662. {
  1663. checkedby1[k+1][q+1]=1;
  1664. movability1[k][q]=1;
  1665. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1666. k--;q--;
  1667. zone2[k][q]=1;
  1668. while(!occupied[k][q]&&k>=0&&q>=0)
  1669. zone2[--k][--q]=1;
  1670. }
  1671. }else
  1672. {
  1673. checkedby1[k+1][q+1]=1;
  1674. }}
  1675. k=i-1;
  1676. q=j-1;
  1677. while(!occupied[k][q]&&k>0&&q>0)
  1678. {
  1679. checkedby1[k+1][q+1]=1;
  1680. movability1[k--][q--]=1;
  1681. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1682. if(occupied[k][q]==2 || occupied[k][q]==0)
  1683. {
  1684. checkedby1[k+1][q+1]=1;
  1685. movability1[k][q]=1;
  1686. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1687. k++;q++;
  1688. zone2[k][q]=1;
  1689. while(!occupied[k][q]&&k<8&&q<8)
  1690. zone2[++k][++q]=1;
  1691. }
  1692. }else
  1693. {
  1694. checkedby1[k+1][q+1]=1;
  1695. }}
  1696. k=i-1;
  1697. q=j+1;
  1698. while(!occupied[k][q]&&k>0&&q<COLUMNS)
  1699. {
  1700. checkedby1[k+1][q+1]=1;
  1701. movability1[k--][q++]=1;
  1702. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1703. if(occupied[k][q]==2 || occupied[k][q]==0)
  1704. {
  1705. checkedby1[k+1][q+1]=1;
  1706. movability1[k][q]=1;
  1707. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1708. k++;q--;
  1709. zone2[k][q]=1;
  1710. while(!occupied[k][q]&&k<8&&q>=0)
  1711. zone2[++k][--q]=1;
  1712. }
  1713. }else
  1714. {
  1715. checkedby1[k+1][q+1]=1;
  1716. }}
  1717. k=i+1;
  1718. q=j-1;
  1719. while(!occupied[k][q]&&k<ROWS&&q>0)
  1720. {
  1721. checkedby1[k+1][q+1]=1;
  1722. movability1[k++][q--]=1;
  1723. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1724. if(occupied[k][q]==2 || occupied[k][q]==0)
  1725. {
  1726. checkedby1[k+1][q+1]=1;
  1727. movability1[k][q]=1;
  1728. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1729. k--;q++;
  1730. zone2[k][q]=1;
  1731. while(!occupied[k][q]&&k>=0&&q<8)
  1732. zone2[--k][++q]=1;
  1733. }
  1734. }else
  1735. {
  1736. checkedby1[k+1][q+1]=1;
  1737. }}
  1738. }
  1739. if(domain[i][j]=='n')
  1740. {
  1741. q=j+2;
  1742. k=i-1;
  1743. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1744. checkedby1[k+1][q+1]=1;
  1745. if(occupied[k][q]!=1)
  1746. movability1[k][q]=1;
  1747. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1748. zone2[i][j]=1;
  1749. }}
  1750. q=j+2;
  1751. k=i+1;
  1752. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1753. checkedby1[k+1][q+1]=1;
  1754. if(occupied[k][q]!=1)
  1755. movability1[k][q]=1;
  1756. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1757. zone2[i][j]=1;
  1758. }
  1759. }
  1760. q=j-2;
  1761. k=i-1;
  1762. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1763.  
  1764. checkedby1[k+1][q+1]=1;
  1765. if(occupied[k][q]!=1)
  1766. movability1[k][q]=1;
  1767. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1768. zone2[i][j]=1;
  1769. }
  1770. }
  1771. q=j-2;
  1772. k=i+1;
  1773. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1774. checkedby1[k+1][q+1]=1;
  1775. if(occupied[k][q]!=1)
  1776. movability1[k][q]=1;
  1777. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1778. zone2[i][j]=1;
  1779. }
  1780. }
  1781. q=j-1;
  1782. k=i-2;
  1783. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1784. checkedby1[k+1][q+1]=1;
  1785. if(occupied[k][q]!=1)
  1786. movability1[k][q]=1;
  1787. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1788. zone2[i][j]=1;
  1789. }
  1790. }
  1791. q=j+1;
  1792. k=i-2;
  1793. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1794. checkedby1[k+1][q+1]=1;
  1795. if(occupied[k][q]!=1)
  1796. movability1[k][q]=1;
  1797. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1798. zone2[i][j]=1;
  1799. }
  1800. }
  1801. q=j+1;
  1802. k=i+2;
  1803. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1804. checkedby1[k+1][q+1]=1;
  1805. if(occupied[k][q]!=1)
  1806. movability1[k][q]=1;
  1807. }
  1808. q=j-1;
  1809. k=i+2;
  1810. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1811. checkedby1[k+1][q+1]=1;
  1812. if(occupied[k][q]!=1)
  1813. movability1[k][q]=1;
  1814. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1815. zone2[i][j]=1;
  1816. }
  1817. }
  1818.  
  1819. }
  1820. if(domain[i][j]=='q')
  1821. {
  1822.  
  1823. k=i+1;
  1824. q=j+1;
  1825. while(!occupied[k][q]&&k<ROWS&&q<COLUMNS)
  1826. {
  1827. checkedby1[k+1][q+1]=1;
  1828. movability1[k++][q++]=1;
  1829. }
  1830. if((k<8 && q<8)&&(k>=0 && q>=0)){
  1831. if(occupied[k][q]==2 || occupied[k][q]==0 )
  1832. {
  1833. checkedby1[k+1][q+1]=1;
  1834. movability1[k][q]=1;
  1835. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1836. k--;q--;
  1837. zone2[k][q]=1;
  1838. while(!occupied[k][q]&&k>=0&&q>=0)
  1839. zone2[--k][--q]=1;
  1840. }
  1841. }else
  1842. {
  1843. checkedby1[k+1][q+1]=1;
  1844. }}
  1845. k=i-1;
  1846. q=j-1;
  1847. while(!occupied[k][q]&&k>0&&q>0)
  1848. {
  1849. checkedby1[k+1][q+1]=1;
  1850. movability1[k--][q--]=1;
  1851. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1852. if(occupied[k][q]==2 || occupied[k][q]==0)
  1853. {
  1854. checkedby1[k+1][q+1]=1;
  1855. movability1[k][q]=1;
  1856. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1857. k++;q++;
  1858. zone2[k][q]=1;
  1859. while(!occupied[k][q]&&k<8&&q<8)
  1860. zone2[++k][++q]=1;
  1861. }
  1862. }else
  1863. {
  1864. checkedby1[k+1][q+1]=1;
  1865. }}
  1866. k=i-1;
  1867. q=j+1;
  1868. while(!occupied[k][q]&&k>0&&q<COLUMNS)
  1869. {
  1870. checkedby1[k+1][q+1]=1;
  1871. movability1[k--][q++]=1;
  1872. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1873. if(occupied[k][q]==2 || occupied[k][q]==0)
  1874. {
  1875. checkedby1[k+1][q+1]=1;
  1876. movability1[k][q]=1;
  1877. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1878. k++;q--;
  1879. zone2[k][q]=1;
  1880. while(!occupied[k][q]&&k<8&&q>=0)
  1881. zone2[++k][--q]=1;
  1882. }
  1883. }else
  1884. {
  1885. checkedby1[k+1][q+1]=1;
  1886. }}
  1887. k=i+1;
  1888. q=j-1;
  1889. while(!occupied[k][q]&&k<ROWS&&q>0)
  1890. {
  1891. checkedby1[k+1][q+1]=1;
  1892. movability1[k++][q--]=1;
  1893. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  1894. if(occupied[k][q]==2 || occupied[k][q]==0)
  1895. {
  1896. checkedby1[k+1][q+1]=1;
  1897. movability1[k][q]=1;
  1898. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  1899. k--;q++;
  1900. zone2[k][q]=1;
  1901. while(!occupied[k][q]&&k>=0&&q<8)
  1902. zone2[--k][++q]=1;
  1903. }
  1904. }else
  1905. {
  1906. checkedby1[k+1][q+1]=1;
  1907. }}
  1908.  
  1909. k=i+1;
  1910. while(!occupied[k][j]&&k<ROWS)
  1911. {
  1912. checkedby1[k+1][j+1]=1;
  1913. movability1[k++][j]=1;
  1914.  
  1915. }
  1916. if(k<8&&k>=0){
  1917. if(occupied[k][j]==2 ||occupied[k][j]==0)
  1918. {
  1919. checkedby1[k+1][j+1]=1;
  1920. movability1[k][j]=1;
  1921. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][j]=='K'){
  1922. k--;
  1923. zone2[k][j]=1;
  1924. while(!occupied[k][j]&&k>=0)
  1925. zone2[--k][j]=1;
  1926. }
  1927. }
  1928. else
  1929. {
  1930. checkedby1[k+1][j+1]=1;
  1931. }}
  1932. k=i-1;
  1933. while(!occupied[k][j]&&k>0)
  1934. {
  1935. checkedby1[k+1][j+1]=1;
  1936. movability1[k--][j]=1;
  1937. }
  1938.  
  1939. if(k<8&&k>=0){
  1940. if(occupied[k][j]==2 ||occupied[k][j]==0)
  1941. {
  1942. checkedby1[k+1][j+1]=1;
  1943. movability1[k][j]=1;
  1944. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][j]=='K'){
  1945. k++;
  1946. zone2[k][j]=1;
  1947. while(!occupied[k][j]&&k<8)
  1948. zone2[++k][j]=1;
  1949. }
  1950. }
  1951. else
  1952. {
  1953. checkedby1[k+1][j+1]=1;
  1954. }}
  1955. k=j+1;
  1956. while(!occupied[i][k]&&k<COLUMNS)
  1957. {
  1958. checkedby1[i+1][k+1]=1;
  1959. movability1[i][k++]=1;
  1960.  
  1961. }if(k<8&&k>=0){
  1962. if(occupied[i][k]==2 || occupied[i][k]==0 )
  1963. {
  1964. checkedby1[i+1][k+1]=1;
  1965. movability1[i][k]=1;
  1966. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[i][k]=='K'){
  1967. k--;
  1968. zone2[i][k]=1;
  1969. while(!occupied[i][k]&&k>=0)
  1970. zone2[i][--k]=1;
  1971. }
  1972.  
  1973. }
  1974. else
  1975. {
  1976. checkedby1[i+1][k+1]=1;
  1977. }}
  1978. k=j-1;
  1979. while(!occupied[i][k]&&k>0)
  1980. {
  1981. checkedby1[i+1][k+1]=1;
  1982. movability1[i][k--]=1;
  1983.  
  1984. }if(k<8&&k>=0){
  1985. if(occupied[i][k]==2 || occupied[i][k]==0)
  1986. {
  1987. checkedby1[i+1][k+1]=1;
  1988. movability1[i][k]=1;
  1989. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[i][k]=='K'){
  1990. k++;
  1991. zone2[i][k]=1;
  1992. while(!occupied[i][k]&&k<8)
  1993. zone2[i][++k]=1;
  1994. }
  1995. }
  1996. else
  1997. {
  1998. checkedby1[i+1][k+1]=1;
  1999. }}
  2000. }
  2001. if(domain[i][j]=='p')
  2002. {
  2003. k=i+1;
  2004. q=j+1;
  2005. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2006. checkedby1[k+1][q+1]=1;
  2007. if(occupied[k][q]==2){
  2008. movability1[k][q]=1;
  2009. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  2010. zone2[i][j]=1;
  2011. }}
  2012. q=j-1;
  2013. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2014.  
  2015. checkedby1[k+1][q+1]=1;
  2016. if(occupied[k][q]==2){
  2017. movability1[k][q]=1;
  2018. if(checkedby1[kp2i+1][kp2j+1]==1&&domain[k][q]=='K'){
  2019. zone2[i][j]=1;
  2020. }
  2021. }
  2022. }
  2023. if(i==1)
  2024. {
  2025. k=i+1;
  2026. if(!occupied[k][j]){
  2027. movability1[k][j]=1;
  2028. k++;
  2029. if(!occupied[k][j])
  2030. movability1[k][j]=1;}
  2031. }else{
  2032. if(k<8&&k>=0){
  2033. k=i+1;
  2034. if(!occupied[k][j])
  2035. movability1[k][j]=1;}
  2036. }
  2037.  
  2038.  
  2039. }
  2040.  
  2041. }
  2042. }
  2043. }
  2044. }}
  2045. void set_checks2(void)
  2046. {
  2047.  
  2048. int i,j,k,q;
  2049. for(i=0; i<ROWS;i++)
  2050. {
  2051. for(j=0; j<COLUMNS; j++)
  2052. {
  2053. if(occupied[i][j]==2)
  2054. {
  2055. if(domain[i][j]=='R')
  2056. {
  2057. k=i+1;
  2058. while(!occupied[k][j]&&k<ROWS)
  2059. {
  2060. checkedby2[k+1][j+1]=1;
  2061. movability2[k++][j]=1;
  2062.  
  2063. }if(k<8 &&k>=0){
  2064. if(occupied[k][j]==1 ||occupied[k][j]==0)
  2065. {
  2066. checkedby2[k+1][j+1]=1;
  2067. movability2[k][j]=1;
  2068. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][j]=='k'){
  2069. k--;
  2070. zone1[k][j]=1;
  2071. while(!occupied[k][j]&&k>=0)
  2072. zone1[--k][j]=1;
  2073. }
  2074. }
  2075. else
  2076. {
  2077. checkedby2[k+1][j+1]=1;
  2078. }}
  2079. k=i-1;
  2080. while(!occupied[k][j]&&k>0)
  2081. {
  2082. checkedby2[k+1][j+1]=1;
  2083. movability2[k--][j]=1;
  2084.  
  2085. }if(k<8 &&k>=0){
  2086. if(occupied[k][j]==1 ||occupied[k][j]==0)
  2087. {
  2088. checkedby2[k+1][j+1]=1;
  2089. movability2[k][j]=1;
  2090. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][j]=='k'){
  2091. k++;
  2092. zone1[k][j]=1;
  2093. while(!occupied[k][j]&&k>=0)
  2094. zone1[++k][j]=1;
  2095. }
  2096. }
  2097. else
  2098. {
  2099. checkedby2[k+1][j+1]=1;
  2100. }}
  2101. k=j+1;
  2102. while(!occupied[i][k]&&k<COLUMNS)
  2103. {
  2104. checkedby2[i+1][k+1]=1;
  2105. movability2[i][k++]=1;
  2106.  
  2107. }if(k<8 &&k>=0){
  2108. if(occupied[i][k]==1 || occupied[i][k]==0 )
  2109. {
  2110. checkedby2[i+1][k+1]=1;
  2111. movability2[i][k]=1;
  2112. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[i][k]=='k'){
  2113. k--;
  2114. zone1[i][k]=1;
  2115. while(!occupied[i][k]&&k>=0)
  2116. zone1[i][--k]=1;
  2117. }
  2118.  
  2119. }
  2120. else
  2121. {
  2122. checkedby2[i+1][k+1]=1;
  2123. }}
  2124. k=j-1;
  2125. while(!occupied[i][k]&&k>0)
  2126. {
  2127. checkedby2[i+1][k+1]=1;
  2128. movability2[i][k--]=1;
  2129.  
  2130. }if(k<8 &&k>=0){
  2131. if(occupied[i][k]==1 || occupied[i][k]==0)
  2132. {
  2133. checkedby2[i+1][k+1]=1;
  2134. movability2[i][k]=1;
  2135. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[i][k]=='k'){
  2136. k++;
  2137. zone1[i][k]=1;
  2138. while(!occupied[i][k]&&k>=0)
  2139. zone1[i][++k]=1;
  2140. }
  2141. }
  2142. else
  2143. {
  2144. checkedby2[i+1][k+1]=1;
  2145. }}
  2146. }
  2147. if(domain[i][j]=='B')
  2148. {
  2149. k=i+1;
  2150. q=j+1;
  2151. while(!occupied[k][q]&&k<ROWS&&q<COLUMNS)
  2152. {
  2153. checkedby2[k+1][q+1]=1;
  2154. movability2[k++][q++]=1;
  2155. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2156. if(occupied[k][q]==1 || occupied[k][q]==0)
  2157. {
  2158. checkedby2[k+1][q+1]=1;
  2159. movability2[k][q]=1;
  2160. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2161. k--;
  2162. q--;
  2163. zone1[k][q]=1;
  2164. while(!occupied[k][q]&&k>=0)
  2165. zone1[--k][--q]=1;
  2166. }
  2167. }else
  2168. {
  2169. checkedby2[k+1][q+1]=1;
  2170. }}
  2171. k=i-1;
  2172. q=j-1;
  2173. while(!occupied[k][q]&&k>0&&q>0)
  2174. {
  2175. checkedby2[k+1][q+1]=1;
  2176. movability2[k--][q--]=1;
  2177. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2178. if(occupied[k][q]==1 || occupied[k][q]==0)
  2179. {
  2180. checkedby2[k+1][q+1]=1;
  2181. movability2[k][q]=1;
  2182. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2183. k++;
  2184. q++;
  2185. zone1[k][q]=1;
  2186. while(!occupied[k][q]&&k>=0)
  2187. zone1[++k][++q]=1;
  2188. }
  2189. }else
  2190. {
  2191. checkedby2[k+1][q+1]=1;
  2192. }}
  2193. k=i-1;
  2194. q=j+1;
  2195. while(!occupied[k][q]&&k>0&&q<COLUMNS)
  2196. {
  2197. checkedby2[k+1][q+1]=1;
  2198. movability2[k--][q++]=1;
  2199. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2200. if(occupied[k][q]==1 || occupied[k][q]==0)
  2201. {
  2202. checkedby2[k+1][q+1]=1;
  2203. movability2[k][q]=1;
  2204. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2205. k++;
  2206. q--;
  2207. zone1[k][q]=1;
  2208. while(!occupied[k][q]&&k>=0)
  2209. zone1[++k][--q]=1;
  2210. }
  2211. }else
  2212. {
  2213. checkedby2[k+1][q+1]=1;
  2214. }}
  2215. k=i+1;
  2216. q=j-1;
  2217. while(!occupied[k][q]&&k<ROWS&&q>0)
  2218. {
  2219. checkedby2[k+1][q+1]=1;
  2220. movability2[k++][q--]=1;
  2221. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2222. if(occupied[k][q]==1 || occupied[k][q]==0)
  2223. {
  2224. checkedby2[k+1][q+1]=1;
  2225. movability2[k][q]=1;
  2226. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2227. k--;
  2228. q++;
  2229. zone1[k][q]=1;
  2230. while(!occupied[k][q]&&k>=0)
  2231. zone1[--k][++q]=1;
  2232. }
  2233. }else
  2234. {
  2235. checkedby2[k+1][q+1]=1;
  2236. }}
  2237. }
  2238. if(domain[i][j]=='N')
  2239. {
  2240. q=j+2;
  2241. k=i-1;
  2242. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2243. checkedby2[k+1][q+1]=1;
  2244. if(occupied[k][q]!=2)
  2245. movability2[k][q]=1;
  2246. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2247. zone1[i][j]=1;
  2248. }}
  2249. q=j+2;
  2250. k=i+1;
  2251. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2252. checkedby2[k+1][q+1]=1;
  2253. if(occupied[k][q]!=2)
  2254. movability2[k][q]=1;
  2255. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2256. zone1[i][j]=1;
  2257. }
  2258. }
  2259. q=j-2;
  2260. k=i-1;
  2261. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2262. checkedby2[k+1][q+1]=1;
  2263. if(occupied[k][q]!=2)
  2264. movability2[k][q]=1;
  2265. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2266. zone1[i][j]=1;
  2267. }
  2268. }
  2269. q=j+2;
  2270. k=i+1;
  2271. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2272. checkedby2[k+1][q+1]=1;
  2273. if(occupied[k][q]!=2)
  2274. movability2[k][q]=1;
  2275. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2276. zone1[i][j]=1;
  2277. }
  2278. }
  2279. q=j-1;
  2280. k=i-2;
  2281. if(k>-2&&q>-2){
  2282. checkedby2[k+1][q+1]=1;
  2283. if(occupied[k][q]!=2)
  2284. movability2[k][q]=1;
  2285. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2286. zone1[i][j]=1;
  2287. }
  2288. }
  2289. q=j+1;
  2290. k=i-2;
  2291. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2292. checkedby2[k+1][q+1]=1;
  2293. if(occupied[k][q]!=2)
  2294. movability2[k][q]=1;
  2295. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2296. zone1[i][j]=1;
  2297. }
  2298. }
  2299. q=j+1;
  2300. k=i+2;
  2301. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2302. checkedby2[k+1][q+1]=1;
  2303. if(occupied[k][q]!=2)
  2304. movability2[k][q]=1;
  2305. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2306. zone1[i][j]=1;
  2307. }
  2308. }
  2309. q=j-1;
  2310. k=i+2;
  2311. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2312. checkedby2[k+1][q+1]=1;
  2313. if(occupied[k][q]!=2)
  2314. movability2[k][q]=1;
  2315. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2316. zone1[i][j]=1;
  2317. }
  2318. }
  2319.  
  2320. }
  2321. if(domain[i][j]=='Q')
  2322. {
  2323.  
  2324. k=i+1;
  2325. q=j+1;
  2326. while(!occupied[k][q]&&k<ROWS&&q<COLUMNS)
  2327. {
  2328. checkedby2[k+1][q+1]=1;
  2329. movability2[k++][q++]=1;
  2330. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2331. if(occupied[k][q]==1 || occupied[k][q]==0)
  2332. {
  2333. checkedby2[k+1][q+1]=1;
  2334. movability2[k][q]=1;
  2335. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2336. k--;
  2337. q--;
  2338. zone1[k][q]=1;
  2339. while(!occupied[k][q]&&k>=0)
  2340. zone1[--k][--q]=1;
  2341. }
  2342. }else
  2343. {
  2344. checkedby2[k+1][q+1]=1;
  2345. }}
  2346. k=i-1;
  2347. q=j-1;
  2348. while(!occupied[k][q]&&k>0&&q>0)
  2349. {
  2350. checkedby2[k+1][q+1]=1;
  2351. movability2[k--][q--]=1;
  2352. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2353. if(occupied[k][q]==1 || occupied[k][q]==0)
  2354. {
  2355. checkedby2[k+1][q+1]=1;
  2356. movability2[k][q]=1;
  2357. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2358. k++;
  2359. q++;
  2360. zone1[k][q]=1;
  2361. while(!occupied[k][q]&&k>=0)
  2362. zone1[++k][++q]=1;
  2363. }
  2364. }else
  2365. {
  2366. checkedby2[k+1][q+1]=1;
  2367. }}
  2368. k=i-1;
  2369. q=j+1;
  2370. while(!occupied[k][q]&&k>0&&q<COLUMNS)
  2371. {
  2372. checkedby2[k+1][q+1]=1;
  2373. movability2[k--][q++]=1;
  2374. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2375. if(occupied[k][q]==1 || occupied[k][q]==0)
  2376. {
  2377. checkedby2[k+1][q+1]=1;
  2378. movability2[k][q]=1;
  2379. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2380. k++;
  2381. q--;
  2382. zone1[k][q]=1;
  2383. while(!occupied[k][q]&&k>=0)
  2384. zone1[++k][--q]=1;
  2385. }
  2386. }else
  2387. {
  2388. checkedby2[k+1][q+1]=1;
  2389. }}
  2390. k=i+1;
  2391. q=j-1;
  2392. while(!occupied[k][q]&&k<ROWS&&q>0)
  2393. {
  2394. checkedby2[k+1][q+1]=1;
  2395. movability2[k++][q--]=1;
  2396. }if((k<8 && q<8)&&(k>=0 && q>=0)){
  2397. if(occupied[k][q]==1 || occupied[k][q]==0)
  2398. {
  2399. checkedby2[k+1][q+1]=1;
  2400. movability2[k][q]=1;
  2401. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][j]=='k'){
  2402. k--;
  2403. q++;
  2404. zone1[k][q]=1;
  2405. while(!occupied[k][q]&&k>=0)
  2406. zone1[--k][++q]=1;
  2407. }
  2408. }else
  2409. {
  2410. checkedby2[k+1][q+1]=1;
  2411. }}
  2412.  
  2413. k=i+1;
  2414. while(!occupied[k][j]&&k<ROWS)
  2415. {
  2416. checkedby2[k+1][j+1]=1;
  2417. movability2[k++][j]=1;
  2418.  
  2419. }if(k<8 &&k>=0){
  2420. if(occupied[k][j]==1 ||occupied[k][j]==0)
  2421. {
  2422. checkedby2[k+1][j+1]=1;
  2423. movability2[k][j]=1;
  2424. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][j]=='k'){
  2425. k--;
  2426. zone1[k][j]=1;
  2427. while(!occupied[k][j]&&k>=0)
  2428. zone1[--k][j]=1;
  2429. }
  2430. }
  2431. else
  2432. {
  2433. checkedby2[k+1][j+1]=1;
  2434. }}
  2435. k=i-1;
  2436. while(!occupied[k][j]&&k>0)
  2437. {
  2438. checkedby2[k+1][j+1]=1;
  2439. movability2[k--][j]=1;
  2440.  
  2441. }if(k<8 &&k>=0){
  2442. if(occupied[k][j]==1 ||occupied[k][j]==0)
  2443. {
  2444. checkedby2[k+1][j+1]=1;
  2445. movability2[k][j]=1;
  2446. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][j]=='k'){
  2447. k++;
  2448. zone1[k][j]=1;
  2449. while(!occupied[k][j]&&k>=0)
  2450. zone1[++k][j]=1;
  2451. }
  2452. }
  2453. else
  2454. {
  2455. checkedby2[k+1][j+1]=1;
  2456. }}
  2457. k=j+1;
  2458. while(!occupied[i][k]&&k<COLUMNS)
  2459. {
  2460. checkedby2[i+1][k+1]=1;
  2461. movability2[i][k++]=1;
  2462.  
  2463. }if(k<8 &&k>=0){
  2464. if(occupied[i][k]==1 || occupied[i][k]==0 )
  2465. {
  2466. checkedby2[i+1][k+1]=1;
  2467. movability2[i][k]=1;
  2468. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[i][k]=='k'){
  2469. k--;
  2470. zone1[i][k]=1;
  2471. while(!occupied[i][k]&&k>=0)
  2472. zone1[i][--k]=1;
  2473. }
  2474.  
  2475. }
  2476. else
  2477. {
  2478. checkedby2[i+1][k+1]=1;
  2479. }}
  2480. k=j-1;
  2481. while(!occupied[i][k]&&k>0)
  2482. {
  2483. checkedby2[i+1][k+1]=1;
  2484. movability2[i][k--]=1;
  2485.  
  2486. }if(k<8 &&k>=0){
  2487. if(occupied[i][k]==1 || occupied[i][k]==0)
  2488. {
  2489. checkedby2[i+1][k+1]=1;
  2490. movability2[i][k]=1;
  2491. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[i][k]=='k'){
  2492. k++;
  2493. zone1[i][k]=1;
  2494. while(!occupied[i][k]&&k>=0)
  2495. zone1[i][++k]=1;
  2496. }
  2497. }
  2498. else
  2499. {
  2500. checkedby2[i+1][k+1]=1;
  2501. }}
  2502. }
  2503. if(domain[i][j]=='P')
  2504. {
  2505. k=i-1;
  2506. q=j+1;
  2507. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2508. checkedby2[k+1][q+1]=1;
  2509. if(occupied[k][q]==1)
  2510. movability2[k][q]=1;
  2511. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2512. zone1[i][j]=1;
  2513. }
  2514. }
  2515.  
  2516. q=j-1;
  2517. if((k<8 && q<8)&&(k>=0 && q>=0)){
  2518. checkedby2[k+1][q+1]=1;
  2519. if(occupied[k][q]==1)
  2520. movability2[k][q]=1;
  2521. if(checkedby2[kp1i+1][kp1j+1]==1&&domain[k][q]=='k'){
  2522. zone1[i][j]=1;
  2523. }
  2524. }
  2525. if(i==6)
  2526. {
  2527. k=i-1;
  2528. if(k<8 && k>=0){
  2529. if(!occupied[k][j]){
  2530. movability2[k][j]=1;}
  2531. k--;
  2532. if(k<8 && k>=0){
  2533. if(!occupied[k][j])
  2534. movability2[k][j]=1;}}
  2535. }else{
  2536. k=i-1;
  2537. if(k<8 && k>=0){
  2538. if(!occupied[k][j])
  2539. movability2[k][j]=1;}
  2540. }
  2541. }
  2542.  
  2543. }
  2544. }
  2545. }
  2546. }
  2547. void check_mate(void)
  2548. {
  2549. int i,j,k,q;
  2550. if (turn==1){
  2551.  
  2552. for( i=kp1i-1; i<=kp1i+1; i++)
  2553. {
  2554. for(j=kp1j-1; j<=kp1j+1; j++){
  2555. if(!checkedby2[i+1][j+1] &&(checkedby2[steps2[counter_steps2].domain2i][steps2[counter_steps2].domain2j]==0||checkedby1[steps2[counter_steps2].domain2i][steps2[counter_steps2].domain2j]==1)&& occupied[i][j]!=1 && (i<8 && i>=0 && j>=0 && j<8 ))
  2556. {
  2557. printf("Your King is checked by player 2!\n");
  2558. printf("Move your king or a piece to end the check\n");
  2559.  
  2560. movement();
  2561. set1();
  2562. set2();
  2563. set_checks1();
  2564. set_checks2();
  2565. if(checkedby2[kp1i+1][kp1j+1]){
  2566. do
  2567. {
  2568. printf("Incorrect move(doesn't end the check),Please Enter another move.\n");
  2569. switch_turns();
  2570. undo();
  2571. switch_turns();
  2572. set1();
  2573. set2();
  2574. set_checks1();
  2575. set_checks2();
  2576. movement();
  2577. set1();
  2578. set2();
  2579. set_checks1();
  2580. set_checks2();
  2581. }while(checkedby2[kp1i+1][kp1j+1]);
  2582. }return;
  2583. }
  2584. else{
  2585. end_game();
  2586. flaz=1;
  2587. break;
  2588. }
  2589. }if(flaz==1){break;}
  2590. }if(flaz==1){
  2591. for(i=0;i<ROWS;i++)
  2592. {
  2593. for(j=0;j<COLUMNS;j++)
  2594. {
  2595. if(movability1[i][j]==1 && zone1[i][j]==1)
  2596. {
  2597.  
  2598. printf("Move a piece to end the check\n");
  2599. movement();
  2600. set1();
  2601. set2();
  2602. set_checks1();
  2603. set_checks2();
  2604. if(checkedby1[kp2i+1][kp2j+1]){
  2605. do
  2606. {
  2607. printf("Incorrect move(doesn't end the check),Please Enter another move.\n");
  2608. switch_turns();
  2609. undo();
  2610. switch_turns();
  2611. set1();
  2612. set2();
  2613. set_checks1();
  2614. set_checks2();
  2615. movement();
  2616. set1();
  2617. set2();
  2618. set_checks1();
  2619. set_checks2();
  2620. }while(checkedby2[kp1i+1][kp1j+1]);
  2621. }
  2622. }
  2623.  
  2624.  
  2625. }
  2626. } }
  2627.  
  2628. }
  2629. else
  2630. {
  2631. for( i=kp2i-1; i<=kp2i+1; i++)
  2632. {
  2633. for(j=kp2j-1; j<=kp2j+1; j++){
  2634. if(!checkedby1[i+1][j+1] &&(checkedby1[steps1[counter_steps1].domain2i][steps1[counter_steps1].domain2j]==0||checkedby2[steps1[counter_steps1].domain2i][steps1[counter_steps1].domain2j]==1)&& occupied[i][j]!=1 && (i<8 && i>=0 && j>=0 && j<8 ))
  2635. {
  2636. printf("\nYour King is checked by player 1!\n");
  2637. printf("Move your king or a piece to end the check\n");
  2638.  
  2639. movement();
  2640. set1();
  2641. set2();
  2642. set_checks1();
  2643. set_checks2();
  2644. if(checkedby1[kp2i+1][kp2j+1]){
  2645. do
  2646. {
  2647. printf("Incorrect move(doesn't end the check),Please Enter another move.\n");
  2648. switch_turns();
  2649. undo();
  2650. switch_turns();
  2651. set1();
  2652. set2();
  2653. set_checks1();
  2654. set_checks2();
  2655. movement();
  2656. set1();
  2657. set2();
  2658. set_checks1();
  2659. set_checks2();
  2660. }while(checkedby1[kp2i+1][kp2j+1]);
  2661. }return;
  2662. }
  2663. else{
  2664. end_game();
  2665. flaz=1;
  2666. break;
  2667. }
  2668. }
  2669. if(flaz==1){break;}
  2670. }
  2671. if(flaz==1){
  2672. for(i=0;i<ROWS;i++)
  2673. {
  2674. for(j=0;j<COLUMNS;j++)
  2675. {
  2676. if(movability2[i][j]==1 && zone2[i][j]==1)
  2677. {
  2678. printf("Move a piece to end the check");
  2679.  
  2680. movement();
  2681. set1();
  2682. set2();
  2683. set_checks1();
  2684. set_checks2();
  2685. if(checkedby1[kp2i+1][kp2j+1]){
  2686. counter_steps2--;
  2687. do
  2688. {
  2689. printf("Incorrect move(doesn't end the check),Please Enter another move.\n");
  2690. switch_turns();
  2691. undo();
  2692. switch_turns();
  2693. set1();
  2694. set2();
  2695. set_checks1();
  2696. set_checks2();
  2697. movement();
  2698. set1();
  2699. set2();
  2700. set_checks1();
  2701. set_checks2();
  2702. }while(checkedby1[kp2i+1][kp2j+1]);
  2703. }return;
  2704. }
  2705.  
  2706.  
  2707. }
  2708. }
  2709. }
  2710. }
  2711. }
  2712. void save_step(int i1,int j1,int i2,int j2,char eaten,char piece)
  2713. {
  2714. if(turn==1)
  2715. {
  2716. pointer1++;
  2717. counter_steps1=pointer1;
  2718.  
  2719.  
  2720. steps1[counter_steps1].domain1i=i1;
  2721. steps1[counter_steps1].domain1j=j1;
  2722. steps1[counter_steps1].domain2i=i2;
  2723. steps1[counter_steps1].domain2j=j2;
  2724. steps1[counter_steps1].eaten=eaten;
  2725. steps1[counter_steps1].piece=piece;
  2726.  
  2727.  
  2728. }else
  2729. {
  2730. pointer2++;
  2731. counter_steps2=pointer2;
  2732. steps2[counter_steps2].domain1i=i1;
  2733. steps2[counter_steps2].domain1j=j1;
  2734. steps2[counter_steps2].domain2i=i2;
  2735. steps2[counter_steps2].domain2j=j2;
  2736. steps2[counter_steps2].eaten=eaten;
  2737. steps2[counter_steps2].piece=piece;
  2738.  
  2739. }
  2740. }
  2741. void undo(void)
  2742. {
  2743. int i1,j1,i2,j2;
  2744. char eaten;
  2745. char piece;
  2746. int checker;
  2747.  
  2748.  
  2749.  
  2750. if(turn==2)
  2751. {
  2752.  
  2753. if(pointer1<=0){
  2754. printf("No thing to undo.\nPlease play a move.");
  2755. movement();
  2756. return;
  2757. }else{
  2758.  
  2759. i2=steps1[pointer1].domain1i;
  2760. j2=steps1[pointer1].domain1j;
  2761. i1=steps1[pointer1].domain2i;
  2762. j1=steps1[pointer1].domain2j;
  2763. eaten=steps1[pointer1].eaten;
  2764. piece=steps1[pointer1].piece;
  2765.  
  2766. domain[i2][j2]=piece;
  2767. domain[i1][j1]=eaten;
  2768. if(domain[i1][j1]=='k')
  2769. {
  2770. kp1i=i2;
  2771. kp1j=j2;
  2772. }
  2773. if(isupper(domain[i1][j1])){
  2774. number_killed2--;}
  2775. pointer1--;
  2776. }
  2777. blackandwhite(i1,j1);
  2778.  
  2779. }
  2780. else
  2781. {
  2782.  
  2783. if(pointer2<=0){
  2784. printf("No thing to undo.\nPlease play a move.");
  2785. movement();
  2786. return;
  2787. }else{
  2788.  
  2789. i2=steps2[pointer2].domain1i;
  2790. j2=steps2[pointer2].domain1j;
  2791. i1=steps2[pointer2].domain2i;
  2792. j1=steps2[pointer2].domain2j;
  2793. eaten=steps2[pointer2].eaten;
  2794. piece=steps2[pointer2].piece;
  2795. domain[i2][j2]=piece;
  2796. domain[i1][j1]=eaten;
  2797. if(domain[i1][j1]=='K')
  2798. {
  2799. kp2i=i2;
  2800. kp2j=j2;
  2801. }
  2802. if(islower(domain[i1][j1])){
  2803. number_killed1--;}
  2804. }
  2805. blackandwhite(i1,j1);
  2806. pointer2--;
  2807. }
  2808.  
  2809. }
  2810. void redo(void)
  2811. {
  2812. int i1,j1,i2,j2;
  2813. char eaten,piece;
  2814. if(turn==1)
  2815. {
  2816. if(pointer1==counter_steps1)
  2817. {
  2818. printf("You can't re-do.\nPlease play a move.");
  2819. movement();
  2820. return;
  2821. }
  2822. else
  2823. {
  2824. pointer1++;
  2825. i1=steps1[pointer1].domain1i;
  2826. j1=steps1[pointer1].domain1j;
  2827. i2=steps1[pointer1].domain2i;
  2828. j2=steps1[pointer1].domain2j;
  2829. eaten=steps1[pointer1].eaten;
  2830. piece=steps1[pointer1].piece;
  2831.  
  2832. if(isupper(domain[i2][j2])){
  2833.  
  2834. killed2[number_killed2]=eaten;
  2835. number_killed2++;
  2836. }
  2837.  
  2838.  
  2839. if(domain[i1][j1]=='p' && i2==7)
  2840. {
  2841. premote(&domain[i1][j1]);
  2842. }
  2843. domain[i2][j2]=domain[i1][j1];
  2844. occupied[i1][j1]=0;
  2845. if(domain[i2][j2]=='k')
  2846. {
  2847. kp1i=i2;
  2848. kp1j=j2;
  2849. }
  2850.  
  2851. blackandwhite(i1,j1);
  2852.  
  2853.  
  2854. }
  2855. }else
  2856. {
  2857.  
  2858. if(pointer2==counter_steps2)
  2859. {
  2860. printf("You can't re-do.\nPlease play a move.");
  2861. movement();
  2862. return;
  2863. }
  2864. else
  2865. {
  2866. pointer2++;
  2867. i1=steps2[pointer2].domain1i;
  2868. j1=steps2[pointer2].domain1j;
  2869. i2=steps2[pointer2].domain2i;
  2870. j2=steps2[pointer2].domain2j;
  2871. eaten=steps2[pointer2].eaten;
  2872. piece=steps1[pointer1].piece;
  2873. if(islower(domain[i2][j2]))
  2874. {
  2875. killed1[number_killed1]=eaten;
  2876. number_killed1++;
  2877. }
  2878. if(domain[i1][j1]=='P' && i2==0)
  2879. {
  2880. premote(&domain[i1][j1]);
  2881. }
  2882. domain[i2][j2]=domain[i1][j1];
  2883. occupied[i1][j1]=0;
  2884. if(domain[i2][j2]=='K')
  2885. {
  2886. kp2i=i2;
  2887. kp2j=j2;
  2888. }
  2889.  
  2890. blackandwhite(i1,j1);
  2891.  
  2892. }
  2893. }
  2894.  
  2895. }
  2896. void read(char *i1,char *j1,char *i2,char *j2,char *promo)
  2897. {
  2898. int ch , i=0;
  2899. ch=getchar();
  2900. while(ch==' ' || ch=='\n')
  2901. {
  2902. ch=getchar();
  2903. }
  2904. *i1 = ch;
  2905. if(ch=='s' || ch=='l' || ch=='u' || ch=='r')
  2906. return;
  2907. *j1 = getchar();
  2908. *i2 = getchar();
  2909. *j2 = getchar();
  2910.  
  2911.  
  2912. while((ch = getchar()) != '\n')
  2913. {
  2914. if(i==0)
  2915. {
  2916. *promo=ch;
  2917. i++;
  2918. }
  2919. ch = ' ';
  2920. }
  2921.  
  2922.  
  2923.  
  2924. }
  2925. void save (void){
  2926.  
  2927. FILE *fp;
  2928. char save_name[20];
  2929. int ch , i=0,j=0;
  2930.  
  2931. printf("Enter file name : ");
  2932. ch=getchar();
  2933. while(ch==' ')
  2934. {
  2935. ch=getchar();
  2936. }
  2937. ch=getchar();
  2938. while(ch!='\n')
  2939. {
  2940. save_name[i++]=ch;
  2941. ch=getchar();
  2942.  
  2943. }
  2944. save_name[i++]='.';
  2945. save_name[i++]='t';
  2946. save_name[i++]='x';
  2947. save_name[i++]='t';
  2948. save_name[i++]='\0';
  2949.  
  2950. fp=fopen(save_name,"w");
  2951.  
  2952. for(i=0;i<ROWS;i++){
  2953. for( j=0;j<ROWS;j++){
  2954. fprintf(fp,"%c\n",domain[i][j]);
  2955. }}
  2956.  
  2957. fprintf(fp,"%d %d %d %d %d %d %d %d %d %d %d \n",number_killed1,number_killed2,counter_steps1,counter_steps2,turn,pointer1,pointer2,kp1i,kp1j,kp2i,kp2j);
  2958.  
  2959. for( j=0;j<number_killed1;j++){
  2960. fprintf(fp,"%c\n",killed1[j]);
  2961. }
  2962. for( j=0;j<number_killed2;j++){
  2963. fprintf(fp,"%c\n",killed2[j]);
  2964. }
  2965. for(j=0;j<counter_steps1+1;j++){
  2966. fprintf(fp,"%d %d %d %d %c %c \n",steps1[j].domain1i,steps1[j].domain1j,steps1[j].domain2i,steps1[j].domain2j,steps1[j].eaten,steps1[j].piece);
  2967. }
  2968. for(j=0;j<counter_steps2+1;j++){
  2969. fprintf(fp,"%d %d %d %d %c %c \n",steps2[j].domain1i,steps2[j].domain1j,steps2[j].domain2i,steps2[j].domain2j,steps2[j].eaten,steps2[j].piece);
  2970. }
  2971. fclose(fp);
  2972. }
  2973.  
  2974.  
  2975. void load (void){
  2976.  
  2977. FILE *fp;
  2978.  
  2979.  
  2980.  
  2981. int ch , i=0,j=0;
  2982.  
  2983. i=0;
  2984. j=0;
  2985. char save_name[20];
  2986. printf("Enter file name: ");
  2987. ch=getchar();
  2988. while((ch=getchar())!='\n')
  2989. {
  2990. save_name[i++]=ch;
  2991. }
  2992. save_name[i++]='.';
  2993. save_name[i++]='t';
  2994. save_name[i++]='x';
  2995. save_name[i++]='t';
  2996. save_name[i++]='\0';
  2997.  
  2998. fp=fopen(save_name,"r");
  2999. if(fp==NULL)
  3000. {
  3001. printf("FILE DOESN'T EXIST!\n");
  3002. return movement();
  3003. return;
  3004.  
  3005. }
  3006. for(i=0;i<ROWS;i++){
  3007. for( j=0;j<ROWS;j++){
  3008. fscanf(fp,"%c\n",&domain[i][j]);
  3009. }}
  3010.  
  3011. fscanf(fp,"%d %d %d %d %d %d %d %d %d %d %d \n",&number_killed1,&number_killed2,&counter_steps1,&counter_steps2,&turn,&pointer1,&pointer2,&kp1i,&kp1j,&kp2i,&kp2j);
  3012.  
  3013. for( j=0;j<number_killed1;j++){
  3014. fscanf(fp,"%c\n",&killed1[j]);
  3015. }
  3016. for( j=0;j<number_killed2;j++){
  3017. fscanf(fp,"%c\n",&killed2[j]);
  3018. }
  3019. for(j=0;j<counter_steps1+1;j++){
  3020. fscanf(fp,"%d %d %d %d %c %c \n",&steps1[j].domain1i,&steps1[j].domain1j,&steps1[j].domain2i,&steps1[j].domain2j,&steps1[j].eaten,&steps1[j].piece);
  3021. }
  3022. for(j=0;j<counter_steps2+1;j++){
  3023. fscanf(fp,"%d %d %d %d %c %c \n",&steps2[j].domain1i,&steps2[j].domain1j,&steps2[j].domain2i,&steps2[j].domain2j,&steps2[j].eaten,&steps2[j].piece);
  3024. }
  3025. fclose(fp);
  3026. }
  3027. void end_game(void)
  3028. {
  3029. if(turn==1)
  3030. {
  3031. winner=2;
  3032. system("COLOR B");
  3033. printf("\nThe Winner is PLAYER 2! CONGRATULATION!\n Goodluck Player 1 in another game :\). \a");
  3034. }else
  3035. {
  3036.  
  3037. winner=1;
  3038. system("COLOR B");
  3039. printf("\nThe Winner is PLAYER 1! CONGRATULATION!\n Goodluck Player 2 in another game :\). \a");
  3040. }
  3041. }
  3042. void set1(void)
  3043. {
  3044. int i,j,k,q;
  3045. for(k=0;k<ROWS;k++)
  3046. {
  3047. for(q=0;q<COLUMNS;q++)
  3048. {
  3049. movability1[k][q]=0;
  3050. checkedby1[k+1][q+1]=0;
  3051. zone1[k][q]=0;
  3052. if(islower(domain[k][q]))
  3053. occupied[k][q]=1;
  3054. else if(isupper(domain[k][q]))
  3055. occupied[k][q]=2;
  3056. else
  3057. occupied[k][q]=0;
  3058. }
  3059. }
  3060. }
  3061. void set2(void)
  3062. {
  3063. int i,j,k,q;
  3064. for(k=0;k<ROWS;k++)
  3065. {
  3066. for(q=0;q<COLUMNS;q++)
  3067. {
  3068. movability2[k][q]=0;
  3069. checkedby2[k+1][q+1]=0;
  3070. zone2[k][q]=0;
  3071. if(islower(domain[k][q]))
  3072. occupied[k][q]=1;
  3073. else if(isupper(domain[k][q]))
  3074. occupied[k][q]=2;
  3075. else
  3076. occupied[k][q]=0;
  3077. }
  3078. }
  3079. }
  3080. void switch_turns(void)
  3081. {
  3082. if(turn==1)
  3083. turn=2;
  3084. else
  3085. turn=1;
  3086. }
  3087. void checking_move (void){
  3088.  
  3089. if(turn==1){
  3090. if(checkedby2[kp1i+1][kp1j+1]==1){
  3091. do{
  3092. printf("Your king will be checked");
  3093. switch_turns();
  3094. undo();
  3095. switch_turns();
  3096. set1();
  3097. set2();
  3098. set_checks1();
  3099. set_checks2();
  3100. movement();
  3101. set1();
  3102. set2();
  3103. set_checks1();
  3104. set_checks2();
  3105. }while(checkedby2[kp1i+1][kp1j+1]);
  3106.  
  3107. }
  3108. }else{ if(checkedby1[kp2i+1][kp2j+1]==1){
  3109. do
  3110. {
  3111. printf("Your king will be checked");
  3112. switch_turns();
  3113. undo();
  3114. switch_turns();
  3115. set1();
  3116. set2();
  3117. set_checks1();
  3118. set_checks2();
  3119. movement();
  3120. set1();
  3121. set2();
  3122. set_checks1();
  3123. set_checks2();
  3124. }while(checkedby1[kp2i+1][kp2j+1]);}
  3125.  
  3126. }
  3127. }
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!