Facebook
From Cute Pelican, 2 Months ago, written in C.
Embed
Download Paste or View Raw
Hits: 53
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "gestion_sudoku.h"
  5.  
  6.  
  7. SUDOKU lire_fichier (char *nom) {
  8.         SUDOKU S;
  9.         FILE *f;
  10.         int  i, j, car;
  11.  
  12.         f=fopen(nom,"r");
  13.  
  14. //Initialise les cases de travail et les cases de départ
  15.         for (i=0;i<9;i++){
  16.                 for (j=0;j<9;j++){
  17.                         S.CI[j][i]=0;
  18.                         S.CT[j][i]=0;
  19.                 }
  20.         }
  21.  
  22.         if (f != NULL){
  23.                 for (i=0;i<9;i++){
  24.                         for (j=0;j<9;j++){
  25.                                 car=fgetc(f);
  26.                                 car=car-'0';
  27.  
  28. // Pour traiter les retours à la ligne
  29.                                 if (car == -38){ // -38 car c'est \n - 0 sur la table ascii
  30.                                         car=fgetc(f);
  31.                                         car=car-'0';
  32.                                 }
  33.  
  34. // Pour traiter les points
  35.                                 if (car == -2){ //  -2 car '.' - '0' sur la table ascii
  36.                                         car = 0;
  37.                                 }
  38.  
  39. // Pour traiter les cases de travail
  40.                                 if (car == -6){ // -6 car '*' - '0' sur la table ascii
  41.                                 car=fgetc(f);
  42.                                 car=car-'0';
  43.                                 S.CT[j][i]=car;
  44.                                 S.C[j][i]=car;
  45.                                 }
  46.  
  47. // Pour traiter les chiffres
  48.                                 else
  49.                                 S.CI[j][i]=car;
  50.                                 S.C[j][i]=car;
  51.                         }
  52.                 }
  53. }
  54. else{
  55.                 //printf("Impossible d'ouvrir le sudoku demand√©");
  56.                 S.CI[0][0]=-26;
  57. }
  58.         return S;
  59. }
  60.  
  61. void ecrire_fichier(SUDOKU S, int c) {
  62.         char *nom;
  63.         FILE* f;
  64.         int i, j, mod=0;
  65.  
  66.           nom = malloc(sizeof(char)*strlen("undo/sudoku999.sudoku"));
  67.         // G√®re l'√©criture de fichier de Sauvegarde
  68.         if (c==1){
  69.                 do
  70.           {
  71.             sprintf(nom, "sudoku%d.sudoku", mod);
  72.             f = fopen(nom, "r");
  73.  
  74.             if(f != NULL){
  75.               fclose(f);
  76.                                 mod++;
  77.                         }
  78.  
  79.           } while(f != NULL);
  80.  
  81.           sprintf(nom, "sudoku%d.sudoku", mod);
  82.  
  83.           f = fopen(nom, "w");
  84.  
  85.         for (j=0;j<9;j++){
  86.                 for (i=0;i<9;i++){
  87.                         //Dans le cas o√Ļ y'a rien
  88.                         if(S.CI[i][j]==0 && S.CT[i][j]==0){
  89.                                 fprintf(f, ".");
  90.                         }
  91.                         // Affiche les cases o√Ļ le joueur a d√©j√† jouer
  92.                         if(S.CI[i][j]==0 && S.CT[i][j]!=0){
  93.                                 fprintf(f, "*%d", S.CT[i][j]);
  94.                         }
  95.                         // Les cases inactives
  96.                         if(S.CI[i][j]!=0){
  97.                                 fprintf(f, "%d", S.CI[i][j]);
  98.                         }
  99.         }
  100.         fprintf(f, "\n");
  101.         }
  102. }
  103. // Ecrire dans le dossier undo
  104. if (c==2){
  105.  
  106.         do
  107.         {
  108.                 sprintf(nom, "undo%d.undo", mod);
  109.                 f = fopen(nom, "r");
  110.  
  111.                 if(f != NULL){
  112.                         fclose(f);
  113.                         mod++;
  114.                 }
  115.  
  116.         } while(f != NULL);
  117.  
  118.         sprintf(nom, "undo%d.undo", mod);
  119.  
  120.         f = fopen(nom, "w");
  121.  
  122. for (j=0;j<9;j++){
  123.         for (i=0;i<9;i++){
  124.                 //Dans le cas o√Ļ y'a rien
  125.                 if(S.CI[i][j]==0 && S.CT[i][j]==0){
  126.                         fprintf(f, ".");
  127.                 }
  128.                 // Affiche les cases o√Ļ le joueur a d√©j√† jouer
  129.                 if(S.CI[i][j]==0 && S.CT[i][j]!=0){
  130.                         fprintf(f, "*%d", S.CT[i][j]);
  131.                 }
  132.                 // Les cases inactives
  133.                 if(S.CI[i][j]!=0){
  134.                         fprintf(f, "%d", S.CI[i][j]);
  135.                 }
  136. }
  137.         fprintf(f, "\n");
  138.         }
  139. }
  140.                 fclose(f);
  141.                 free(nom);
  142. }
  143.  
  144. void sauvegarder(SUDOKU S, int i){
  145.         if (i==1){
  146.                 ecrire_fichier(S, 1);
  147.                 printf("SUDOKU sauvegard√©\n");
  148.         }
  149.  
  150. }
  151. void ecrire_S0() {
  152.         //S0 est le mod√®le du sodoku toujours juste, il sert de base aux autres qui sont des random de lui
  153.         char *nom;
  154.         FILE* f;
  155.  
  156.         nom="s0.sudoku";
  157.         f = fopen(nom, "w" );
  158.         fprintf(f, "123456789456789123789123456234567891567891234891234567345678912678912345912345678");
  159. //123456789\n456789123\n789123456\n234567891\n567891234\n891234567\n345678912\n678912345\n912345678
  160.         fclose(f);
  161.  
  162. }
  163.  
  164. void del_S0() {
  165.         //S0 est le mod√®le du soduko toujours juste, il sert de base aux autres qui sont des random de lui
  166.         char *nom;
  167.         remove("s0.sudoku");
  168. }
  169.