API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 25th, 2018
75
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 12.00 KB | None | 0 0
raw download clone embed print report
  1. /*pour compiler ce fichier : gcc -o EXEC PICROSS.c -Wall -lncurses
  2. Pour installer la librairie complète ncurses sur votre machine via le terminal, il faut taper la commande : sudo apt-get install libncurses*
  3. */
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <time.h>
  7. #include <ncurses.h>
  8. #include <unistd.h>
  9. #include <math.h>
  10. #include <signal.h>
  11. #include <string.h>
  12. #include <termios.h>
  13. #include <fcntl.h>
  14.  
  15.  
  16. int L, C; /*L pour désigner la ligne et C la colonne du clic de la souris*/
  17.  
  18. //gcc -o arun arun.c -Wall -lncruses
  19.  
  20. /**Initialisation de ncurses**/
  21. void ncurses_initialiser() {
  22. initscr(); /* Démarre le mode ncurses */
  23. cbreak(); /* Pour les saisies clavier (desac. mise en buffer) */
  24. noecho(); /* Désactive l'affichage des caractères saisis */
  25. keypad(stdscr, TRUE); /* Active les touches spécifiques */
  26. refresh(); /* Met a jour l'affichage */
  27. curs_set(FALSE); /* Masque le curseur */
  28. }
  29.  
  30.  
  31. /**Initialisation des couleurs**/
  32. void ncurses_couleurs() {
  33. /* Vérification du support de la couleur */
  34. if(has_colors() == FALSE) {
  35. endwin();
  36. fprintf(stderr, "Le terminal ne supporte pas les couleurs.\n");
  37. exit(EXIT_FAILURE);
  38. }
  39.  
  40. /* Activation des couleurs */
  41. start_color();
  42. //init_color(COLOR_BLACK, 1000, 1000, 1000);
  43. init_pair(1, COLOR_WHITE, COLOR_BLACK);
  44. init_pair(2, COLOR_GREEN, COLOR_BLACK);
  45.  
  46. }
  47.  
  48. /**Initialisation de la souris**/
  49. void ncurses_souris() {
  50. if(!mousemask(ALL_MOUSE_EVENTS, NULL)) {
  51. endwin();
  52. fprintf(stderr, "Erreur lors de l'initialisation de la souris.\n");
  53. exit(EXIT_FAILURE);
  54. }
  55.  
  56. if(has_mouse() != TRUE) {
  57. endwin();
  58. fprintf(stderr, "Aucune souris n'est détectée.\n");
  59. exit(EXIT_FAILURE);
  60. }
  61. }
  62.  
  63.  
  64. /**Pour récupérer les coordonnées (x,y) du clic de la souris**/
  65. int click_souris()
  66. {
  67. MEVENT event ;
  68. int ch;
  69.  
  70. while((ch = getch()) != KEY_F(1))
  71. {
  72. switch(ch)
  73. {
  74. case KEY_F(2): /*Pour quitter la boucle*/
  75. return 1;
  76. case KEY_MOUSE:
  77. if(getmouse(&event) == OK)
  78. {
  79. C = event.x;
  80. L = event.y;
  81. if(event.bstate & BUTTON1_CLICKED)
  82. {
  83. return 0;
  84. }
  85. }
  86. }
  87. }
  88. return 0;
  89. }
  90.  
  91. void initTAB(int size, int iArray[]){//initialise un tableau 1D à 0
  92. int i;
  93. for(i=0 ; i<size ; i++){
  94. iArray[i]=0;
  95. }
  96. }
  97.  
  98. void initArray(int lin, int col,int iArray[lin][col]){//initialize un tableau à 2 dimension
  99. int i,j;
  100. for(i=0; i<lin; i++){
  101. for(j=0; j<col; j++){
  102. iArray[i][j]=0;
  103. }
  104. }
  105. }
  106.  
  107. void alea(int nblin, int nbcol, int TABbis[nblin][nbcol]){// choisit un nombre aléatoire entre 0 1
  108. int i,j;
  109. for(i=0; i<nblin; i++){
  110. for(j=0; j<nbcol; j++){
  111. if(rand()%2==0){// si le nombre aléatoireest paire
  112. TABbis[i][j]=1;// la case en question prend 1 sinon 2
  113. }else{
  114. TABbis[i][j]=2;
  115. }}}}
  116.  
  117.  
  118. void col_init(int nblin, int nbcol, int dim2, int TAB[nblin][nbcol] ,int Tab2[nblin][dim2]){//permet d'avoir le nombre de cases correctes sur les colonnes
  119. int i,j,k;
  120. for (i=0;i<nblin;i++){
  121. j=0;
  122. k=0;
  123. while(j<nbcol){
  124. if(TAB[i][j]==2){
  125. while(TAB[i][j]==2 && j<nbcol){
  126. Tab2[i][k]++;
  127. j++;
  128. }
  129. k++;
  130. }
  131. j++;
  132. }}}
  133.  
  134. void lin_init(int nblin, int nbcol, int dim1, int TAB[nblin][nbcol] ,int Tab3[dim1][nbcol]){// permet d'avoir le nombre de cases correctes sur les lignes
  135. int i,j,k;
  136. for(i=0; i<nbcol;i++){
  137. j=0;
  138. k=0;
  139. while(j<nblin){
  140. if (TAB[i][j]==2){
  141. while(TAB[j][i]==2 && j<nblin){
  142. Tab3[k][i]++;
  143. j++;
  144. }
  145. k++;
  146. }
  147. j++;
  148. }}}
  149.  
  150.  
  151. void dimension (char image, int *nblin, int *nbcol){//si le joueur veut utiliser le mode image on commence par les dimensions de celle ci
  152. char ima[7] = "./X.txt";
  153. ima[2]=image;//image= la lettre entrée par l'utilisateur (1ère position position)-> on change le chemain d'accès avec le tableau
  154. FILE *FIC;
  155. FIC = fopen(ima, "r"); //ouvre le fichier, r pour read
  156. if(FIC==NULL){//si l'image ne correspond pas
  157. endwin();//restore le terminal (quitte lncurse)
  158. printf("impossible de trouver l'image: %s \n", ima);
  159. exit(-1);//on quitte le jeux
  160. }else{//sinon
  161. fscanf(FIC,"%d %d", nblin, nbcol);// on commence par prendre les dimension de l'image
  162. fclose(FIC);//ferme le flux
  163. }
  164. }
  165.  
  166. void RemplisageImage(char image, int nblin, int nbcol, int TABbis[nblin][nbcol]){//remplie le tableau de jeux avec les données du fichier .txt
  167. char ima[7] = "./X.txt";
  168. int i, j, temp;
  169. ima[2]=image;// même principe que précédemment
  170. FILE *FIC;
  171. FIC = fopen(ima, "r");
  172. fseek(FIC, 1, SEEK_SET);//définie la position du fichier sur le flux à l'endroit indiqué (seek_set signifie au début du fichier)
  173. for(i=0 ; i<nblin ; i++){
  174. for(j=0 ; j<nbcol ; j++){
  175. fscanf(FIC,"%d", &temp);
  176. TABbis[i][j] = temp+1;//remplie la matrice
  177. }
  178. }
  179. }
  180.  
  181. /*Pour récupérer les données saisies par l'utilisateur sans bloquer le jeu*/
  182. char key_pressed() {
  183. struct termios oldterm, newterm;
  184. int oldfd;
  185. char c, result = 0;
  186. tcgetattr (STDIN_FILENO, &oldterm);
  187. newterm = oldterm;
  188. newterm.c_lflag &= ~(ICANON | ECHO);
  189. tcsetattr (STDIN_FILENO, TCSANOW, &newterm);
  190. oldfd = fcntl(STDIN_FILENO, F_GETFL, 0);
  191. fcntl (STDIN_FILENO, F_SETFL, oldfd | O_NONBLOCK);
  192. c = getchar();
  193. tcsetattr (STDIN_FILENO, TCSANOW, &oldterm);
  194. fcntl (STDIN_FILENO, F_SETFL, oldfd);
  195. if (c != EOF) {
  196. ungetc(c, stdin);
  197. result = getchar();
  198. }
  199. return result;
  200. }
  201.  
  202. void ShowArray (int lin, int col, int dim1, int dim2, int iArray[lin][col], int iArray_2[dim1][col],int iArray_3[lin][dim2],int indice_l[],int indice_c[]){//cette fonction permet l'affichage du tableau de jeux
  203. int i,j;
  204. //ligne supérieur
  205. move(0, dim2*4);
  206. addch(ACS_ULCORNER);
  207. for(i=0 ; i< col-1; i++){
  208. addch(ACS_HLINE);// -
  209. addch(ACS_HLINE);
  210. addch(ACS_HLINE);
  211. addch(ACS_TTEE);// T
  212. }
  213. addch(ACS_HLINE);
  214. addch(ACS_HLINE);
  215. addch(ACS_HLINE);
  216. addch(ACS_URCORNER);// coin en heut à droite
  217. printw("\n");
  218. for(i = 0 ; i < dim1 ; i++){
  219. move(i+1, dim2*4);
  220. for(j = 0 ; j < col ; j++){
  221. addch(ACS_VLINE);
  222. if(indice_c[j]==1){
  223. if(i==0){printw(" v");}//si la ligne/colonne est complété
  224. else{printw(" ");}
  225. }else{
  226. if(iArray_2[i][j] == 0 && i!=0){printw(" ");}
  227. else{printw("%3d", iArray_2[i][j]);}
  228. }
  229. }
  230. addch(ACS_VLINE);// |
  231. printw("\n");
  232. }
  233. addch(ACS_ULCORNER);// coin en haut à gauche
  234. addch(ACS_HLINE);
  235. addch(ACS_HLINE);
  236. addch(ACS_HLINE);
  237. for(i = 0 ; i < lin ; i++){
  238. if(i!=0){
  239. addch(ACS_LTEE);// L
  240. addch(ACS_HLINE);
  241. addch(ACS_HLINE);
  242. addch(ACS_HLINE);
  243. }
  244. for(j=1 ; j< dim2 + col ; j++){
  245. if(j<dim2){
  246. addch(ACS_HLINE);
  247. addch(ACS_HLINE);
  248. addch(ACS_HLINE);
  249. addch(ACS_HLINE);
  250. }else{
  251. addch(ACS_PLUS);// +
  252. addch(ACS_HLINE);
  253. addch(ACS_HLINE);
  254. addch(ACS_HLINE);
  255. }
  256. }
  257.  
  258. addch(ACS_RTEE);// T vers la droite
  259. printw("\n");
  260.  
  261. addch(ACS_VLINE);
  262. if(indice_l[i] == 0){
  263. printw("%3d", iArray_3[i][0]);// %3d 3 éspaces à afficher
  264. for(j=1 ; j < dim2 ; j++){ //tab aide ligne
  265. if(iArray_3[i][j] == 0 && j != 0){printw(" ");}
  266. else{printw(" %3d", iArray_3[i][j]);}
  267. }
  268. }else{
  269. move(2+dim1+i*2, (dim2-1)*4+3);
  270. printw("v");
  271. }
  272. for(j=0 ; j<col ; j++){ //tab jeu
  273. addch(ACS_VLINE);
  274. switch(iArray[i][j]){
  275. case 1:
  276. printw(" x ");//1 clique
  277. break;
  278. case 2:
  279. addch(ACS_CKBOARD);//2 clique (gros rectangle)
  280. addch(ACS_CKBOARD);
  281. addch(ACS_CKBOARD);
  282. break;
  283. default:
  284. printw(" ");//si on clique une 3 ème fois
  285. break;
  286. }
  287. }
  288. addch(ACS_VLINE);
  289. printw("\n");
  290. }
  291.  
  292. addch(ACS_LLCORNER);
  293. addch(ACS_HLINE);
  294. addch(ACS_HLINE);
  295. addch(ACS_HLINE);
  296. for(j=1 ; j< dim2 + col ; j++){
  297. if(j<dim2){
  298. addch(ACS_HLINE);
  299. addch(ACS_HLINE);
  300. addch(ACS_HLINE);
  301. addch(ACS_HLINE);
  302. }else{
  303. addch(ACS_BTEE);
  304. addch(ACS_HLINE);
  305. addch(ACS_HLINE);
  306. addch(ACS_HLINE);
  307. }
  308. }
  309. addch(ACS_LRCORNER);
  310. printw("\n");
  311.  
  312. }
  313.  
  314. void action(int lin, int col, int TABJ[lin][col], int TAB[lin][col], int numl, int numc, int decol, int delin, int indice_l[], int indice_c[]){//permet de modifier le plateau de jeux en même temps que le joueur joue
  315. int nbcol, nblin, i;
  316. nbcol = (numc-(decol*4)-2)/4;
  317. nblin = (numl-(delin+1))/2;
  318. if(nbcol>=0 && nblin>=0 && nbcol<col && nblin<lin && (numc-(decol*4)-2)%4==0 && (numl-(delin+2))%2==0){
  319. TABJ[nblin][nbcol] = (TABJ[nblin][nbcol]+1)%3;
  320. }
  321. for(i=0; i<col ; i++){
  322. if(TABJ[nblin][i]==TAB[nblin][i]){indice_l[nblin]=1;}
  323. else{
  324. indice_l[nblin]=0;
  325. break;
  326. }
  327. }
  328. for(i=0; i<lin ; i++){
  329. if(TABJ[i][nbcol]==TAB[i][nbcol]){indice_c[nbcol]=1;}
  330. else{
  331. indice_c[nbcol]=0;
  332. break;
  333. }
  334. }
  335. }
  336.  
  337. int Fin_de_partie(int size, int iArray[]);
  338.  
  339.  
  340. void LANCEMENT_PARTIE(int choix){
  341. //initiallisation de la partie
  342. int lin, col;
  343. char num;
  344. if(choix == 0){//dimension pour le mode image pré-configuré
  345. clear();
  346. printw("choisissez votre image en saisissant la lettre qui convient");
  347. scanw("%c", &num);
  348. dimension(num, &lin, &col);
  349. }else{ //choix des dimensions pour le mode aléatoire
  350. do{
  351. clear();
  352. move(5,2);
  353. printw("entrez un nombre de ligne (>0) :");
  354. if(scanw("%d", &lin)!=1){
  355. endwin();
  356. printf("input error\n");
  357. exit(-1);
  358. }
  359. }while(lin<=0);
  360. do{
  361. clear();
  362. move(5,2);
  363. printw("entrez un nombre de colonne (>0) :");
  364. if(scanw("%d", &col)!=1){
  365. endwin();
  366. printf("input error\n");
  367. exit(-1);
  368. }
  369. }while(col<=0);
  370. }
  371. int TAB[lin][col];
  372. if(choix == 0){
  373.  
  374. RemplisageImage(num, lin, col, TAB);
  375. } //mode image
  376. else{ //mode aléa
  377. srand(time(NULL));
  378. alea(lin, col, TAB);
  379. }
  380.  
  381. int i, j, TABJ[lin][col], indice_l[lin], indice_c[col];
  382. if(col%2 == 0){i = col/2; }
  383. else{ i = (col/2) +1; }
  384. int TAB_Gauche[lin][i];
  385. if(lin%2 == 0){
  386. j = lin/2; }
  387. else{
  388. j = (lin/2) +1; }
  389. int TAB_Haut[j][col];
  390.  
  391. initArray(lin, col, TABJ);//PB
  392. initArray(lin, i, TAB_Gauche);
  393. initArray(j, col, TAB_Haut);
  394. //col_init(lin, col, i, TAB, TAB_Gauche);
  395. lin_init(lin, col, j, TAB, TAB_Haut);
  396. initTAB(lin, indice_l);
  397. initTAB(lin, indice_c);
  398.  
  399. //lancement de la partie
  400. do{
  401. clear();
  402. ShowArray(lin, col, j, i, TABJ, TAB_Haut, TAB_Gauche, indice_l, indice_c);
  403. printw("\n");
  404. click_souris();
  405. action(lin, col, TABJ, TAB, L, C, i, j, indice_l, indice_c);
  406. }while(Fin_de_partie(lin, indice_l) == 0);
  407. clear();
  408. move(5,2);
  409. printw("félicitation vous avez gagné (tapez entrer)");
  410. scanw("");
  411. }
  412.  
  413.  
  414.  
  415.  
  416.  
  417.  
  418. int LANCEMENT_JEU(){
  419. int i, j, choix=-1;
  420. char PICROSS;//affichage du jeux
  421. FILE *FIC;
  422. FIC = fopen("PICROSS.txt", "r");
  423. while((PICROSS = fgetc(FIC))!= EOF){
  424. printw("%c", PICROSS);
  425. }
  426. fclose(FIC);
  427. move(10,0);//mode
  428. printw("Jouer en mode aléatoire ou a avec une image (il y en a 3 disponibles) ?\n" );
  429. for(i=0 ; i<2 ; i++){
  430. addch(ACS_ULCORNER);
  431. for(j=1 ; j<=9 ; j++){
  432. addch(ACS_HLINE);
  433. }
  434. addch(ACS_URCORNER);
  435. printw(" ");
  436. }
  437. printw("\n");
  438. addch(ACS_VLINE);
  439. printw("aléatoire");
  440. addch(ACS_VLINE);
  441. printw(" ");
  442. addch(ACS_VLINE);
  443. printw("image ");
  444. addch(ACS_VLINE);
  445. printw("\n");
  446. for(i=0 ; i<2 ; i++){
  447. addch(ACS_LLCORNER);
  448. for(j=1 ; j<=9 ; j++){
  449. addch(ACS_HLINE);
  450. }
  451. addch(ACS_LRCORNER);
  452. printw(" ");
  453. }
  454. do{
  455. click_souris();
  456. if((L<=13) && (L>=11)){
  457. if(C>=0 && C<=10){
  458. choix=1;
  459. }
  460. else{
  461. if(C>=15 && C<=25){choix=0;}
  462. }
  463. }
  464. }while(choix == -1);
  465. return choix;
  466. }
  467.  
  468.  
  469.  
  470. int Fin_de_partie(int size, int iArray[]){
  471. int i;
  472. for(i=0 ; i<size ; i++){
  473. if(iArray[i] == 0){
  474. return 0;
  475. }
  476. }
  477. return 1;
  478. }
  479.  
  480.  
  481. int main(int argc, char *argv[]) {
  482. int choix;
  483. int jouer;
  484. do{
  485.  
  486. ncurses_initialiser(); //Initialisation de ncurses
  487. ncurses_souris();
  488. clear();
  489. choix = LANCEMENT_JEU(); // début du jeux
  490. LANCEMENT_PARTIE(choix); //Lancement du jeu
  491. endwin(); // Suspendre la session ncurses et restaurer le terminal
  492.  
  493. printf("continuez la partie ? (1 pour oui et 2 pour non)");
  494. //ffluch(stdin);
  495. scanf("%d", &jouer);
  496. }while(jouer ==1);
  497. printf("\n");
  498.  
  499. return 0;
  500. }
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!