API tools faq
paste
Guest User

Untitled

a guest
May 24th, 2018
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.77 KB | None | 0 0
raw download clone embed print report
  1.     #include<stdio.h>
  2.     #include<stdlib.h>
  3.     #include"graphdsu.h"
  4.     #include<math.h>
  5.     #include <time.h>
  6.      
  7.     #define NBCOL 10 //Nombre de colonnes de la grille
  8.     #define NBLIG 8 //Nom de lignes de la grille
  9.     #define LARG 60 //Taille des cases en pixel
  10.     #define NBCOUL 6 //Nombre de couleurs possibles par me
  11.      
  12.     //Formes
  13.     #define RECTANGLE 0
  14.     #define CERCLE 1
  15.     #define TRIANGLE 2
  16.      
  17.     typedef struct Case Case;
  18.     struct Case
  19.     {
  20.             int m_forme; /*valeur prise dans {0,1,2} */
  21.             int m_couleur; /*valeur comprise entre 1 et NBCOUL*/
  22.             int m_ligne; /*valeur comprise entre 1 et NBLIG */
  23.             int m_colonne; /*valeur comprise entre 1 et NBCOL */
  24.     };
  25.      
  26.     typedef Case Grille[NBLIG][NBCOL];
  27.      
  28.     void init_case(Case *Pcase); //Initialise la case
  29.     void dessin_case(Case *Pcase,int Pcoul_fond); //Dessine la case
  30.     void init_grille(Grille Pgrille); //Initialise la grille
  31.     void copie_case(Case *Pcase_1, Case *Pcase_2); //Copie une case dans une autre
  32.     void faire_tomber(Grille Pgrille, Case *Pcase_bas, int Phauteur); //Fait tomber les case
  33.     int eliminer_sequence(Grille Pgrille); //Elimine la séquence de cases
  34.     void jouer(Grille);
  35.      
  36.     int recherche_seq_hori_forme(Grille Pgrille, Case *Pcase, Case** Pcase_gauche);
  37.     int recherche_seq_hori_couleur(Grille Pgrille, Case *Pcase, Case** Pcase_gauche);
  38.     int recherche_seq_verti_forme(Grille Pgrille, Case *Pcase, Case** Pcase_bas);
  39.     int recherche_seq_verti_couleur(Grille Pgrille, Case *Pcase, Case** Pcase_bas);
  40.      
  41.     int main()
  42.     {
  43.             srand(time(NULL));
  44.             Grille grille_jeu;
  45.             int points;
  46.            
  47.             Initialiser(NBCOL * (LARG) + 100, NBLIG * (LARG));
  48.             init_grille(grille_jeu);
  49.             points = eliminer_sequence(grille_jeu);
  50.             printf("*");
  51.             AttendreClic();
  52.             return 0;
  53.     }
  54.      
  55.     void init_case(Case *Pcase)
  56.     {
  57.             Pcase->m_forme = rand() % 3;
  58.             int couleur;
  59.             do {couleur = (rand() % 6);}while (couleur == 1);
  60.      
  61.             Pcase->m_couleur = couleur;
  62.     }
  63.      
  64.     void dessin_case(Case *Pcase, int Pcoul_fond)
  65.     {
  66.             int x0,y0,x1,y1;
  67.             int x_centre,y_centre,r;
  68.             int x2,y2,x3,y3;
  69.            
  70.      
  71.             ChangeCouleur(Pcoul_fond);
  72.      
  73.             y0 = Pcase->m_ligne * LARG;
  74.             x0 = Pcase->m_colonne * LARG;
  75.      
  76.             y1 = Pcase->m_ligne * LARG + LARG;
  77.      
  78.             x1 = Pcase->m_colonne * LARG + LARG;
  79.      
  80.             RectanglePlein(x0,y0,x1,y1);
  81.            
  82.             ChangeCouleur(Pcase->m_couleur);
  83.      
  84.            
  85.      
  86.             switch (Pcase->m_forme)
  87.             {
  88.      
  89.                     case 0:
  90.                             x0 = x0 + 5;
  91.      
  92.                             y0 = y0 + 5;
  93.      
  94.                             x1 = x1 - 5;
  95.      
  96.                             y1 = y1 - 5;
  97.      
  98.                             RectanglePlein(x0,y0,x1,y1);
  99.      
  100.                             break;
  101.      
  102.      
  103.      
  104.                     case 1:
  105.      
  106.                             x_centre = x1 - (LARG / 2);
  107.                             y_centre = y1 - (LARG / 2);
  108.      
  109.                             r = (LARG / 2) - 5;
  110.      
  111.                             CerclePlein(x_centre, y_centre, r);
  112.                             break;
  113.                            
  114.      
  115.                     case 2:
  116.                             x3 = x0 + 5;
  117.                             y3 = y0 + LARG - 5;
  118.                             x2 = x1 - 5;
  119.      
  120.                             y2 = y1 - 5;
  121.                             y1 = y0 + 5;
  122.      
  123.                             x1 = (x1 + x0) / 2;
  124.      
  125.                             TrianglePlein(x3, y3, x1, y1, x2, y2);
  126.                             break;
  127.      
  128.             }
  129.     }
  130.      
  131.     void init_grille(Grille Pgrille)
  132.     {
  133.             int i,j;
  134.      
  135.            
  136.      
  137.             for(i = 0; i < NBLIG; i++)
  138.             {
  139.      
  140.                     for(j = 0; j < NBCOL; j++)
  141.                     {
  142.      
  143.                             init_case(&Pgrille[i][j]);
  144.      
  145.                             Pgrille[i][j].m_ligne = i;
  146.      
  147.                             Pgrille[i][j].m_colonne = j;
  148.      
  149.                             dessin_case(&Pgrille[i][j],1);
  150.      
  151.                     }
  152.      
  153.             }
  154.     }
  155.      
  156.     int recherche_seq_hori_forme(Grille Pgrille, Case* Pcase, Case** Pcase_gauche)
  157.     {
  158.             int i;
  159.             int longueur = 0;
  160.             int longueur_droite = 0;
  161.             int longueur_gauche = 0;
  162.            
  163.             for (i = Pcase->m_colonne; i < NBCOL; i++)
  164.             {
  165.                     if (Pgrille[Pcase->m_ligne][i].m_forme == Pgrille[Pcase->m_ligne][i+1].m_forme && (i+1 < NBCOL) && Pgrille[Pcase->m_ligne][i].m_forme == Pcase->m_forme)
  166.                     {
  167.                             longueur_droite++;
  168.                     }
  169.                     else
  170.                     {
  171.                             break;
  172.                     }
  173.             }
  174.             for (i = Pcase->m_colonne; i >= 0; i--)
  175.             {
  176.                     if (Pgrille[Pcase->m_ligne][i].m_forme == Pgrille[Pcase->m_ligne][i-1].m_forme && (i-1 >= 0) && Pgrille[Pcase->m_ligne][i].m_forme == Pcase->m_forme)
  177.                     {
  178.                             longueur_gauche++;
  179.                     }
  180.                     else
  181.                     {
  182.                             break;
  183.                     }
  184.             }
  185.            
  186.             longueur = longueur_droite + longueur_gauche + 1;
  187.             if (longueur < 5)
  188.             {
  189.                     *Pcase_gauche = NULL;
  190.                     return 0;
  191.             }
  192.             else
  193.             {
  194.                     *Pcase_gauche = &Pgrille[Pcase->m_ligne][i];
  195.                     return longueur;
  196.             }
  197.     }
  198.      
  199.     int recherche_seq_hori_couleur(Grille Pgrille, Case* Pcase, Case** Pcase_gauche)
  200.     {
  201.             int i;
  202.             int longueur = 0;
  203.             int longueur_droite = 0;
  204.             int longueur_gauche = 0;
  205.            
  206.             for (i = Pcase->m_colonne; i < NBCOL; i++)
  207.             {
  208.                     if (Pgrille[Pcase->m_ligne][i].m_couleur == Pgrille[Pcase->m_ligne][i+1].m_couleur && (i+1 < NBCOL) && Pgrille[Pcase->m_ligne][i].m_couleur == Pcase->m_couleur)
  209.                     {
  210.                             longueur_droite++;
  211.                     }
  212.                     else
  213.                     {
  214.                             break;
  215.                     }
  216.             }
  217.             for (i = Pcase->m_colonne; i >= 0; i--)
  218.             {
  219.                     if (Pgrille[Pcase->m_ligne][i].m_couleur == Pgrille[Pcase->m_ligne][i-1].m_couleur && (i-1 >= 0) && Pgrille[Pcase->m_ligne][i].m_couleur == Pcase->m_couleur)
  220.                     {
  221.                             longueur_gauche++;
  222.                     }
  223.                     else
  224.                     {
  225.                             break;
  226.                     }
  227.             }
  228.             longueur = longueur_droite + longueur_gauche + 1;
  229.             if (longueur < 3)
  230.             {
  231.                     *Pcase_gauche = NULL;
  232.                     return 0;
  233.             }
  234.             else
  235.             {
  236.                     *Pcase_gauche = &Pgrille[Pcase->m_ligne][i];
  237.                     return longueur;
  238.             }
  239.     }
  240.      
  241.     int recherche_seq_verti_forme(Grille Pgrille, Case* Pcase, Case** Pcase_bas)
  242.     {
  243.             int i;
  244.             int longueur = 0;
  245.             int longueur_haut = 0;
  246.             int longueur_bas = 0;
  247.             for (i = Pcase->m_ligne; i >= 0; i--)
  248.             {
  249.                     if (Pgrille[i][Pcase->m_colonne].m_forme == Pgrille[i-1][Pcase->m_colonne].m_forme && (i-1 >= 0) && Pgrille[i][Pcase->m_colonne].m_forme == Pcase->m_forme)
  250.                     {
  251.                             longueur_haut++;
  252.                     }
  253.                     else
  254.                     {
  255.                             break;
  256.                     }
  257.             }
  258.             for (i = Pcase->m_ligne; i < NBLIG; i++)
  259.             {
  260.                     if (Pgrille[i][Pcase->m_colonne].m_forme == Pgrille[i+1][Pcase->m_colonne].m_forme && (i+1 < NBLIG) && Pgrille[i][Pcase->m_colonne].m_forme == Pcase->m_forme)
  261.                     {
  262.                             longueur_bas++;
  263.                     }
  264.                     else
  265.                     {
  266.                             break;
  267.                     }
  268.             }
  269.             longueur = longueur_bas + longueur_haut + 1;
  270.             if (longueur < 3)
  271.             {
  272.                     *Pcase_bas = NULL;
  273.                     return 0;
  274.             }
  275.             else
  276.             {
  277.                     *Pcase_bas = &Pgrille[i][Pcase->m_colonne];
  278.                     return longueur;
  279.             }
  280.     }
  281.      
  282.     int recherche_seq_verti_couleur(Grille Pgrille, Case* Pcase, Case** Pcase_bas)
  283.     {
  284.             int i;
  285.             int longueur = 0;
  286.             int longueur_haut = 0;
  287.             int longueur_bas = 0;
  288.             for (i = Pcase->m_ligne; i >= 0; i--)
  289.             {
  290.                     if (Pgrille[i][Pcase->m_colonne].m_couleur == Pgrille[i-1][Pcase->m_colonne].m_couleur && (i-1 >= 0) && Pgrille[i][Pcase->m_colonne].m_couleur == Pcase->m_couleur)
  291.                     {
  292.                             longueur_haut++;
  293.                     }
  294.                     else
  295.                     {
  296.                             break;
  297.                     }
  298.             }
  299.             for (i = Pcase->m_ligne; i < NBLIG; i++)
  300.             {
  301.                     if (Pgrille[i][Pcase->m_colonne].m_couleur == Pgrille[i+1][Pcase->m_colonne].m_couleur && (i+1 < NBLIG) && Pgrille[i][Pcase->m_colonne].m_couleur == Pcase->m_couleur)
  302.                     {
  303.                             longueur_bas++;
  304.                     }
  305.                     else
  306.                     {
  307.                             break;
  308.                     }
  309.             }
  310.             longueur = longueur_bas + longueur_haut + 1;
  311.             if (longueur < 3)
  312.             {
  313.                     *Pcase_bas = NULL;
  314.                     return 0;
  315.             }
  316.             else
  317.             {
  318.                     *Pcase_bas = &Pgrille[i][Pcase->m_colonne];
  319.                     return longueur;
  320.             }
  321.     }
  322.      
  323.     void copie_case(Case *Pcase_1, Case *Pcase_2)
  324.     {
  325.             /*
  326.             int tmp1,tmp2;
  327.             tmp1 = Pcase_1->m_forme;
  328.             tmp2 = Pcase_1->m_couleur;
  329.             Pcase_1->m_forme = Pcase_2->m_forme;
  330.             Pcase_1->m_couleur = Pcase_2->m_couleur;
  331.             Pcase_2->m_forme = tmp1;
  332.             Pcase_2->m_couleur = tmp2;
  333.             */
  334.             *Pcase_1 = *Pcase_2;
  335.     }
  336.      
  337.     void faire_tomber(Grille Pgrille, Case *Pcase_bas, int Phauteur)
  338.     {
  339.             int i;
  340.             for(i = Pcase_bas->m_ligne ; i > -1; i--)
  341.             {
  342.                     if(i - Phauteur >= 0)
  343.                     {
  344.                             copie_case(&Pgrille[i][Pcase_bas->m_colonne],&Pgrille[i - Phauteur][Pcase_bas->m_colonne]);
  345.                     }
  346.                     else
  347.                     {
  348.                             init_case(&Pgrille[i][Pcase_bas->m_colonne]);
  349.                     }
  350.             }
  351.     }
  352.      
  353.     int eliminer_sequence(Grille Pgrille)  
  354.     {
  355.             int i = 0;
  356.             int j = 0;
  357.             int hauteur = 0;
  358.             int chaine = 0;
  359.             int sequences = 0;
  360.             Case *case_base = NULL;
  361.             for(i = 0; i < NBLIG; i++)
  362.             {
  363.                     for(j = 0; j < NBCOL; j++)
  364.                     {
  365.                             hauteur = recherche_seq_verti_forme(Pgrille,&Pgrille[i][j],&case_base);
  366.                             printf("%d\n",hauteur);
  367.                             if(hauteur > 0)
  368.                             {
  369.                                     faire_tomber(Pgrille,case_base,hauteur);
  370.                                     i = 0;
  371.                                     j = 0;
  372.                                     sequences++;
  373.                             }
  374.                             /*else
  375.                             {
  376.                                     hauteur = recherche_seq_verti_couleur(Pgrille,&Pgrille[i][j],&case_base);
  377.                                     if(hauteur > 0)
  378.                                     {
  379.                                             faire_tomber(Pgrille,case_base,hauteur);
  380.                                             i = 0;
  381.                                             j = 0;
  382.                                             sequences++;
  383.                                     }
  384.                                     else
  385.                                     {
  386.                                             hauteur = recherche_seq_hori_forme(Pgrille,&Pgrille[i][j],&case_base);
  387.                                             if(hauteur > 0)
  388.                                             {
  389.                                                     for(chaine = 0; chaine < hauteur; chaine++)
  390.                                                     {
  391.                                                             faire_tomber(Pgrille,case_base,1);
  392.                                                             case_base->m_colonne++;
  393.                                                     }
  394.                                                     i = 0;
  395.                                                     j = 0;
  396.                                                     sequences++;
  397.                                             }
  398.                                             else
  399.                                             {
  400.                                                     hauteur = recherche_seq_hori_couleur(Pgrille,&Pgrille[i][j],&case_base);
  401.                                                     if(hauteur > 0)
  402.                                                     {
  403.                                                             for(chaine = 0; chaine < hauteur; chaine++)
  404.                                                             {
  405.                                                                     faire_tomber(Pgrille,case_base,1);
  406.                                                                     case_base->m_colonne++;
  407.                                                             }
  408.                                                             i = 0;
  409.                                                             j = 0;
  410.                                                             sequences++;
  411.                                                     }
  412.                                             }
  413.                                     }
  414.                             }*/
  415.                     }
  416.             }
  417.             return sequences;
  418.     }
Add Comment
Please, Sign In to add comment
Public Pastes
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!