c-doku.c

1、较复杂的数独游戏

    do
    {
        // On charge la grille avec les cases supprimees
        chargegrille(grille,taille,tabgrille);
        // Choisit une case au hasard
        i = rand() % (taille-1);
        j = rand() % (taille-1);
        // Si la case contient quelquechose
        if(grille[i][j].affiche != 0)
        {
            // Sauvegarde la derniere grille valide (celle en cours)
            sauvegrille(grille,taille,tabvalide);

            // Supprime les deux cases tirees
            grille[i][j].affiche = 0;
            grille[taille-i-1][taille-j-1].affiche = 0;

            // Sauvegarde la grille avec les cases supprimees
            sauvegrille(grille,taille,tabgrille);

            // Resoud la grille
            razcompte(compte);
            histpc = supprimecoups(histpc);
            resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
        }

        // On teste suivant le niveau si les conditions sont remplies
        switch(niveau)
        {
            case 1 :
            case 2 :
                    // Niveau "tres facile" et "facile", on utilise que la methode logique1
                    if(compte->ll != 0 || compte->lc != 0 || compte->lb != 0)
                    {
                        boucle = 0;
                    }
            break;
            case 3 :
                    // Niveau "moyen", on utilise les methodes logique1, logiquelignes, logiquecolonnes
                    if(compte->lb != 0)
                    {
                        boucle = 0;
                    }
            break;
            case 4 :
            case 5 :
                    // Niveau "difficile" et "tres difficile", on utilise les methodes logique1,
                    // logiquelignes, logiquecolonnes et la methode resoudback qui ne peut utiliser qu'une supposition
                    if(compte->lb > 1)
                    {
                        boucle = 0;
                    }
            break;
        }
    // Tant que la resolution est possible on retire deux cases supplementaires
    }
    while(boucle == 1);

    // La resolution n'est plus possible, on charge la derniere grille valide
    chargegrille(grille,taille,tabvalide);

    switch(taille)
    {
        case 4 :
                switch(niveau)
                {
                    case 1 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 8)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 2 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 6)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 3 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 4)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 4 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 6)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 5 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 4)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                }
        break;
        case 6 :
                switch(niveau)
                {
                    case 1 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 16)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 2 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 14)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 3 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 11)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 4 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 14)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 5 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 11)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                }
        break;
        case 9 :
                switch(niveau)
                {
                    case 1 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 37)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 2 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 32)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 3 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 29)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 4 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 32)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                    case 5 :
                            // Si le nombre de cases restantes n'est pas satisfaisant, on relance la fontion
                            if(casesrestantes(grille,taille) > 28)
                            {
                                resoudtout(grille,zonex,zoney,zoneh,zonel,taille,compte);
                                enleve(grille,zonex,zoney,zoneh,zonel,taille,compte,niveau);
                            }
                    break;
                }
        break;
    }

    // Bloque les cases d'origine du Sudoku cree
    for(i=0;i<taille;i++)
    {
        for(j=0;j<taille;j++)
        {
            if(grille[i][j].affiche !=0)
            {
                grille[i][j].bloquee = 1;
            }
            else
            {
                grille[i][j].bloquee = 0;
            }
        }
    }
}

// Remplit completement la grille de chiffres, de maniere aleatoire
// Renvoie 1 si le remplissage a reussi
// Renvoie 0 si le remplissage a echoue
int remplirgrille(cell **grille, int zonex, int zoney, int zoneh, int zonel, int taille)
{
    int i = 0;
    int j = 0;
    int k = 0;
    int n = 0;
    int r = 0;
    int somme = 0;
    int tabrandom[10];

    for(i=0;i<taille;i++)
    {
        for(j=0;j<taille;j++)
        {
            somme = 0;
            n = 0;

            // On elimine les conditions de la case
            elimine(grille,i,j,zonex,zoney,zoneh,zonel,taille);

            // Somme le nombre de possibilites restantes pour une case
            for(k=0;k<(taille+1);k++)
            {
                somme += grille[i][j].tab[k];
            }

            // On vide le tabrandom[]
            for(k=0;k<(taille+1);k++)
            {
                tabrandom[k] = 0;
            }

            // On met maintenant les chiffres possibles restants dans ce tableau
            for(k=0;k<(taille+1);k++)
            {
                if(grille[i][j].tab[k] == 1)
                {
                    tabrandom[n] = k;
                    n++;
                }
            }

            // Si il ne reste plus qu'une possibilite on parcoure le tableau
            // des possibilites pour la trouver et on l'affiche
            if(somme == 1)
            {
                for(k=0;k<(taille+1);k++)
                {
                    if(grille[i][j].tab[k] == 1)
                    {
                        grille[i][j].affiche = k;
                    }
                }
            }
            else
            {
                if(somme != 0)
                {
                    // Il y a plusieurs possibilites, on effectue un random sur
                    // l'indice du tableau tabrandom[] pour selectionner au hasard
                    // un des chiffres restants
                    r = rand() % n;
                    grille[i][j].affiche = tabrandom[r];
                }
                else
                {
                    // Sinon c'est que la disposition des chiffres deja places ne permet
                    // pas de finir le remplissage, donc on renvoie 0 pour recommencer
                    return 0;
                }
            }
        }
    }
    // La grille est remplie, en retourne 1;
    return 1;
}


/*
    Fonction permettant au joueur de jouer la grille en mode graphique
*/

pcoup joue_allegro(cell **grille, int zonex, int zoney, int zoneh, int zonel, int casex, int casey, int taille, int niveau, int type, BITMAP* buffer, BITMAP* edit, BITMAP* fond, BITMAP* _1, BITMAP* _2, BITMAP* _3, BITMAP* _4, BITMAP* _5, BITMAP* _6, BITMAP* _7, BITMAP* _8, BITMAP* _9, int *xtemp, int *ytemp, int *xtempcell, int *ytempcell, int *editactif, int controle_actif, int *erreur)
{
    // Permet de recuperer les coordonnees de la case survolee par la souris
    int cell_x = 10;
    int cell_y = 10;

    int fini = 0;
    int presence = 0;
    int val = 10;

    int ligne = 0;
    int colonne = 0;
    int valeur = 0;

    pcoup aux = hist;

    // On affiche la grille
    affichegrille_allegro(grille,taille,niveau,type,controle_actif,buffer,fond,_1,_2,_3,_4,_5,_6,_7,_8,_9);

    // Si le controle est active
    if(controle_actif == 1)
    {
        *erreur = controle(grille,zoneh,zonel,taille,&ligne,&colonne,&valeur);
        switch(*erreur)
        {
            case 1 : textprintf_ex(buffer,font, 185, 70, makecol(0, 0, 0),-1, "La grille comporte une erreur !! Il y a plusieurs %i dans la ligne %i",valeur,ligne+1);
            break;
            case 2 : textprintf_ex(buffer,font, 185, 70, makecol(0, 0, 0),-1, "La grille comporte une erreur !! Il y a plusieurs %i dans la colonne %i",valeur,colonne+1);
            break;
            case 3 : textprintf_ex(buffer,font, 185, 70, makecol(0, 0, 0),-1, "La grille comporte une erreur !! Il y a plusieurs %i dans la zone [%i] [%i]",valeur,ligne+1,colonne+1);
            break;
        }
    }

    // On teste la position de la souris, et suivant la taille de la grille
    // on va pouvoir recuperer les coordonnees de la case survolee et/ou cliquee
    if(taille == 4 && mouse_x > 200 && mouse_x < 374 && mouse_y > 110 && mouse_y < 285)
    {
        if(mouse_x > 200 && mouse_x < 242)
        {
            cell_x = 0;
        }
        if(mouse_x > 243 && mouse_x < 285)
        {
            cell_x = 1;
        }
        if(mouse_x > 289 && mouse_x < 331)
        {
            cell_x = 2;
        }
        if(mouse_x > 332 && mouse_x < 374)
        {
            cell_x = 3;
        }
        if(mouse_y > 110 && mouse_y < 152)
        {
            cell_y = 0;
        }
        if(mouse_y > 153 && mouse_y < 195)
        {
            cell_y = 1;
        }
        if(mouse_y > 200 && mouse_y < 242)
        {
            cell_y = 2;
        }
        if(mouse_y > 243 && mouse_y < 285)
        {
            cell_y = 3;
        }
    }
    if(taille == 6 && mouse_x > 200 && mouse_x < 461 && mouse_y > 110 && mouse_y < 375)
    {
        if(mouse_x > 200 && mouse_x < 242)
        {
            cell_x = 0;
        }
        if(mouse_x > 243 && mouse_x < 285)
        {
            cell_x = 1;
        }
        if(mouse_x > 286 && mouse_x < 328)
        {
            cell_x = 2;
        }
        if(mouse_x > 333 && mouse_x < 375)
        {
            cell_x = 3;
        }
        if(mouse_x > 376 && mouse_x < 418)
        {
            cell_x = 4;
        }
        if(mouse_x > 419 && mouse_x < 461)
        {
            cell_x = 5;
        }
        if(mouse_y > 110 && mouse_y < 152)
        {
            cell_y = 0;
        }
        if(mouse_y > 153 && mouse_y < 195)
        {
            cell_y = 1;
        }
        if(mouse_y > 200 && mouse_y < 24