API tools faq
paste
Advertisement
Essam_khames

Untitled

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