SHARE
TWEET

zvxvxzvxcv

a guest Dec 9th, 2018 64 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. Universidade de Brasilia
  3. Instituto de Ciencias Exatas
  4. Departamento de Ciencia da Computacao
  5. Algoritmos e Programaçao de Computadores – 2/2018
  6. Aluno(a): Joao Francisco Gomes Targino
  7. Matricula: 180102991
  8. Turma: A
  9. Versao do compilador: 6.3.0
  10. Descricao: Este programa consiste em uma versao de puyo puyo em DIY feita por mim para o trabalho de APC da professora Carla Castanho
  11. */
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <time.h>
  16. #include <unistd.h>
  17. #include <fcntl.h>
  18. #include <string.h>
  19.  
  20. #ifdef _WIN32/*Teste para ver o sistema operacional e pegar o CLEAR de acordo com o mesmo para limpar a tela*/
  21. #else
  22.     #include <termios.h>
  23. #endif
  24.  
  25. #ifdef _WIN32/*Teste para ver o sistema operacional e pegar o CLEAR de acordo com o mesmo para limpar a tela*/
  26.     #define CLEAR "cls"
  27. #else
  28.     #define CLEAR "clear"
  29. #endif
  30.  
  31. #ifndef _WIN32/*Checar o sistema operacional, e se estiver no windows implementar kbhit e getch, senao somente adicionar a biblioteca conio.h*/
  32.     int kbhit(){
  33.         struct termios oldt, newt;
  34.         int ch, oldf;
  35.         tcgetattr(STDIN_FILENO,&oldt);
  36.         newt = oldt;
  37.         newt.c_lflag &= ~(ICANON | ECHO);
  38.         tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  39.         oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
  40.         fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
  41.         ch = getchar();
  42.         tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  43.         fcntl(STDIN_FILENO, F_SETFL, oldf);
  44.         if(ch != EOF){
  45.             ungetc(ch,stdin);
  46.         return 1;
  47.         }
  48.         return 0;
  49.     }
  50.     int getch(void) {
  51.         int ch;
  52.         struct termios oldt;
  53.         struct termios newt;
  54.         tcgetattr(STDIN_FILENO,&oldt);
  55.         newt = oldt;
  56.         newt.c_lflag &= ~(ICANON | ECHO);
  57.         tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  58.         ch = getchar();
  59.         tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  60.         return ch;
  61.     }
  62. #else
  63.     #include <conio.h>
  64. #endif
  65.  
  66. /*Define as expressoes que muda a cor dos caracteres no teminal*/
  67. #define GREEN "\x1b[32m"
  68. #define YELLOW "\x1b[33m"
  69. #define BLUE "\x1b[34m"
  70. #define MAGENTA "\x1b[35m"
  71. #define CYAN "\x1b[36m"
  72. #define RESET "\x1b[0m"
  73. #define RED "\x1b[31m"
  74. #define LGREEN "\x1b[92m"  
  75. #define LBLUE "\x1b[94m"    
  76. #define LMAGENTA "\x1b[95m"
  77. #define LCYAN "\x1b[96m"
  78. #define LYELLOW "\x1b[93m"  
  79. /*Variaveis Globais*/
  80. typedef struct {
  81.     char nick[11];
  82.     int score;
  83. }Player; /*struct do tipo player para o ranking*/
  84.  
  85. FILE *Replay;
  86. FILE *Config;
  87. char tabuleiro[1000][1000];
  88. int altura=13, largura=8, perdeu=0;
  89. int velocidade=720000, pontos=0, qntpecas=5 ;
  90. char p1, p2;
  91. int k=1, k1;/*Contadores de movimentaçao das pecas*/
  92. int vetline[99], vetcolumn[99], iguais=0, destruir=4;/*Vetores auxiliares e contador para a quebra das pecas*/
  93. int s, desapareceu = 0, rank=0;/*Variaveis de controle s=quando desce a peca de uma vez, desapareceu = quando as pecas quebraram, rank=ativa ou desativa modo rankeado*/
  94.  
  95.  
  96. void corpecas(int i, int j){ /*Checa o char da matriz, e caso seja uma letra printa com uma cor*/
  97.     if(tabuleiro[i][j] == 'A'){
  98.         printf(RED "A" RESET);
  99.     }
  100.     else if(tabuleiro[i][j] == 'B'){
  101.         printf(BLUE "B" RESET);
  102.     }
  103.     else if(tabuleiro[i][j] == 'C'){
  104.         printf(GREEN "C" RESET);
  105.     }
  106.     else if(tabuleiro[i][j] == 'D'){
  107.         printf(MAGENTA "D" RESET);
  108.     }
  109.     else if(tabuleiro[i][j] == 'E'){
  110.         printf(CYAN "E" RESET);
  111.     }
  112.     else if(tabuleiro[i][j] == 'F'){
  113.         printf(LGREEN "F" RESET);
  114.     }
  115.     else if(tabuleiro[i][j] == 'G'){
  116.         printf(LBLUE "G" RESET);
  117.     }
  118.     else if(tabuleiro[i][j] == 'H'){
  119.         printf(LCYAN "H" RESET);
  120.     }
  121.     else if(tabuleiro[i][j] == 'I'){
  122.         printf(LMAGENTA "I" RESET);
  123.     }
  124.     else if(tabuleiro[i][j] == 'J'){
  125.         printf(YELLOW "J" RESET);
  126.     }
  127.     else if(tabuleiro[i][j] == '+'){
  128.         printf(LYELLOW "+" RESET);
  129.     }
  130.     else{
  131.         printf("%c",tabuleiro[i][j]);
  132.     }
  133. }
  134.  
  135. void printtab(){    /*Printa o tabuleiro*/
  136.     int c=0, i=0;
  137.     printf("PONTOS:"YELLOW" %d\n\n"RESET, pontos);
  138.     for (c=0; c<altura; c++){
  139.         for(i=0; i<largura; i++){
  140.             corpecas(c, i);
  141.         }
  142.         printf("\n");
  143.     }
  144. }
  145.  
  146. int Existe(int linha, int coluna){/*Verifica se a peca que eu estou comparando ja foi contada*/
  147.     int c;
  148.     for(c=0; c<iguais; c++){
  149.         if (vetline[c] == linha && vetcolumn[c] == coluna){
  150.             return 1;
  151.         }
  152.     }
  153.     return 0;
  154. }
  155.  
  156. void Contar_Iguais(int linha, int coluna){/*Verifica se 4 ou mais pecas iguais estao encostando*/
  157.     char peca=tabuleiro[linha][coluna];
  158.     if (iguais == 0){/*Se for a primeira peca a ser testada, somente aloca nos vetores auxiliares para saber que ja foi contada*/
  159.         vetline[iguais] = linha;
  160.         vetcolumn[iguais] = coluna;
  161.         iguais++;
  162.     }
  163.     if((tabuleiro[linha+1][coluna] == peca) && (tabuleiro[linha+1][coluna] != ' ') && (Existe(linha+1, coluna) == 0)){
  164.         vetline[iguais] = linha+1;                                  
  165.         vetcolumn[iguais] = coluna;                             /*Verifica abaixo da peca*/
  166.         iguais++;
  167.         Contar_Iguais(linha+1, coluna);
  168.     }
  169.     if((tabuleiro[linha-1][coluna] == peca) && (tabuleiro[linha-1][coluna] != ' ') && (Existe(linha-1, coluna) == 0)){
  170.         vetline[iguais] = linha-1;
  171.         vetcolumn[iguais] = coluna;                             /*Acima*/
  172.         iguais++;
  173.         Contar_Iguais(linha-1, coluna);
  174.     }
  175.     if((tabuleiro[linha][coluna+1] == peca) && (tabuleiro[linha][coluna+1] != ' ') && (Existe(linha, coluna+1) == 0)){
  176.         vetline[iguais] = linha;
  177.         vetcolumn[iguais] = coluna+1;                           /*Lado direito*/
  178.         iguais++;
  179.         Contar_Iguais(linha, coluna+1);
  180.     }
  181.     if((tabuleiro[linha][coluna-1] == peca) && (tabuleiro[linha][coluna-1] != ' ') && (Existe(linha, coluna-1) == 0)){
  182.         vetline[iguais] = linha;
  183.         vetcolumn[iguais] = coluna-1;                           /*Lado esquerdo*/
  184.         iguais++;
  185.         Contar_Iguais(linha, coluna-1);
  186.     }
  187.    
  188.     return;
  189. }
  190.  
  191. void Quebra_Desce(){/*Desce as pecas que acima das que quebraram*/
  192.     int x, y, c1, c;
  193.     for (c1=0; c1<iguais; c1++){                              
  194.         x = vetline[c1];                               /*x e y pegam dos vetores as linhas e colunas onde as pecas estavam*/
  195.         y = vetcolumn[c1];                       /*e checa se ha peca acima disso e se abaixo ainda existe espaco caso precise descer de novo*/
  196.         while(tabuleiro[x-1][y] != ' ' && tabuleiro[x][y] == ' '){
  197.             tabuleiro[x][y] = tabuleiro[x-1][y];
  198.             tabuleiro[x-1][y] = ' ';
  199.             system(CLEAR);
  200.             printtab();
  201.             usleep(velocidade);
  202.             c=x;
  203.             while(tabuleiro[c+1][y] == ' ' && tabuleiro[c][y] != ' '){
  204.                 c++;
  205.                 tabuleiro[c][y] = tabuleiro[c-1][y];
  206.                 tabuleiro[c-1][y] = ' ';
  207.                 system(CLEAR);
  208.                 printtab();
  209.                 usleep(velocidade);
  210.             }
  211.             if(tabuleiro[x-2][y] != ' '){
  212.                 x--;
  213.             }
  214.         }
  215.     }
  216. }
  217.  
  218. void Destroy(){/*Tranforma as pecas em '+' e depois de mostrar na tela apaga e manda para as funcoes de descer as pecas que estavam em cima*/
  219.     int x, y, c1;
  220.     desapareceu=1;/*Variavel de controle avisa que foram quebradas pecas*/
  221.     for(c1=0; c1<iguais; c1++){
  222.         x = vetline[c1];
  223.         y = vetcolumn[c1];
  224.         tabuleiro[x][y] = '+';
  225.     }
  226.     system(CLEAR);
  227.     printtab();
  228.     usleep(velocidade);
  229.     for(c1=0; c1<iguais; c1++){
  230.         x = vetline[c1];
  231.         y = vetcolumn[c1];
  232.         tabuleiro[x][y] = ' ';
  233.     }
  234.     pontos += iguais;/*Cada peca igual da 1 ponto*/
  235.     system(CLEAR);
  236.     printtab();                            
  237.     usleep(velocidade);                          
  238.     Quebra_Desce();                        
  239. }                                          
  240.  
  241. void Checar_Caida(int bonus){/*Verifica se na posicao onde as pecas sumiram descceram novas pecas e se sim manda para a funcao de contar e eventualmente a de destruir*/
  242.     int c, x, y, quebradas = iguais;
  243.     for(c=0;c<quebradas;c++){
  244.         iguais=0;
  245.         x = vetline[c];
  246.         y = vetcolumn[c];
  247.         Contar_Iguais(x, y);
  248.         if(iguais >= destruir){
  249.             Destroy();
  250.             pontos += iguais*bonus;/*Adiciona um bonus de pontos*/
  251.         }
  252.     }
  253. }
  254.  
  255. void Manda_Pecas(int x, int y){/*Recebe as posicoes de p1 e p2 quando elas param de cair*/
  256.     int bonus=1;
  257.     iguais=0;
  258.     if(tabuleiro[x][y] != ' ' && tabuleiro[x][y] != '#'){ /*Manda para a funcao de contar quantas pecas iguais a ela exisem dos lados*/
  259.         Contar_Iguais(x, y);                   /*Se existirem mais de x(definido nas configuracoes pelo usuario) pecas manda para o funcao de destruir as pecas*/
  260.         if(iguais >= destruir){                                      
  261.             Destroy();
  262.             while(iguais >= 4){
  263.                 bonus++;  /*Se pecas forem destruidas checa as posicoes onde as pecas estavam*/
  264.                 Checar_Caida(bonus);
  265.             }
  266.         }
  267.     }
  268. }
  269.  
  270. /*A partir de agora, toda variavel w que aparecer na funcao diz se as pecas estao horizontais(w=0) ou verticais(w=1)*/
  271.  
  272. void descer_rapido(int w){ /*Funcao para caso 's' seja apertado, desce as pecas de uma vez sem reversao*/
  273.     if(w){ /*Descida especifica para se a peca estiver na orientacao vertical*/
  274.         while((w == 1) && (tabuleiro[k][k1+1] == ' ')){
  275.                 tabuleiro[k-2][k1+1] = ' ';
  276.                 tabuleiro[k-1][k1+1] = p1;
  277.                 tabuleiro[k][k1+1] = p2;
  278.                 k++;
  279.                 system(CLEAR);
  280.                 printtab();
  281.                 usleep(velocidade/10);
  282.         }
  283.     }
  284.     else{ /*Descida para peca em posicao horizontal*/
  285.         while ((tabuleiro[k][k1] == ' ')&&(tabuleiro[k][k1+1] == ' ')){/*Caso as duas pecas forem cair juntas*/
  286.             tabuleiro[k-1][k1+1]=' ';
  287.             tabuleiro[k-1][k1]=' ';
  288.             tabuleiro[k][k1+1]=p2;
  289.             tabuleiro[k][k1]=p1;
  290.             k++;
  291.             system(CLEAR);
  292.             printtab();
  293.             usleep(velocidade/10);
  294.         }
  295.         while ((tabuleiro[k][k1] == ' ')&&(tabuleiro[k][k1+1] != ' ')){/*Caso houver uma letra abaixo da p2*/
  296.                 tabuleiro[k-1][k1]=' ';
  297.                 tabuleiro[k][k1]=p1;
  298.                 k++;
  299.                 system(CLEAR);
  300.                 printtab();
  301.                 usleep(velocidade/10);
  302.         }
  303.         while ((tabuleiro[k][k1] != ' ')&&(tabuleiro[k][k1+1] == ' ')){/*Caso houver uma letra abaixo de p1*/
  304.             tabuleiro[k-1][k1+1]=' ';
  305.             tabuleiro[k][k1+1]=p2;
  306.             k++;
  307.             system(CLEAR);
  308.             printtab();
  309.             usleep(velocidade/10);
  310.         }
  311.     Manda_Pecas(k-1, k1);
  312.     Manda_Pecas(k-1, k1+1);
  313.     }
  314.     s=1;/*Variavel de controle para a peca nao entrar na funcao de movimentacao novamente*/
  315. }
  316.  
  317. int teclaw(int w){/*Chega se alguma tecla de movimentacao foi apertado caso a orientacao da peca seja vertical*/
  318.     char tecla, aux;
  319.     int c;
  320.     if(w==1){
  321.     for(c=0; c<5; c++){
  322.         if (kbhit()){
  323.                 tecla=getch();
  324.                 if((tecla == 'd' || tecla == 'D') && (tabuleiro[k-1][k1+2] == ' ') && (tabuleiro[k-2][k1+2] == ' ')){/*Mexer as pecas para direita*/
  325.                     k1++;
  326.                     tabuleiro[k-1][k1] = ' ';
  327.                     tabuleiro[k-2][k1] = ' ';
  328.                     tabuleiro[k-2][k1+1]= p1;
  329.                     tabuleiro[k-1][k1+1]= p2;
  330.                     system(CLEAR);
  331.                     printtab();
  332.                 }
  333.                 else if((tecla == 'a' || tecla == 'A') && (tabuleiro[k-1][k1] == ' ') && (tabuleiro[k-2][k1] == ' ')){/*Mexer as pecas para esquerda*/
  334.                     k1--;
  335.                     tabuleiro[k-1][k1+2] = ' ';
  336.                     tabuleiro[k-2][k1+2] = ' ';
  337.                     tabuleiro[k-2][k1+1]= p1;
  338.                     tabuleiro[k-1][k1+1]= p2;
  339.                     system(CLEAR);
  340.                     printtab();
  341.                    
  342.                 }
  343.                 else if(tecla == 's' || tecla == 'S'){/*Acelerar a descida das pecas*/
  344.                     descer_rapido(w);
  345.                     s=1;
  346.                     break;
  347.                 }
  348.                 else if ((tecla == 'w' || tecla == 'W') && (tabuleiro[k-1][k1] == ' ')&& (tabuleiro[k][k1+1] == ' ')){/*Muda a orientacao para horizontal*/
  349.                         w--;
  350.                         tabuleiro[k-2][k1+1] = ' ';
  351.                         break;
  352.                 }
  353.                 else if(tecla == 32){/*Troca as pecas de lugar*/
  354.                     aux = p1;
  355.                     p1 = p2;
  356.                     p2 = aux;
  357.                     system(CLEAR);
  358.                     printtab();
  359.                 }
  360.             }
  361.             usleep(velocidade/5);
  362.         }
  363.     }
  364.     return w;
  365. }
  366.      
  367. void movew(int w){ /*Funcao de descida se a orientacao da peca for vertical*/
  368.     while((w == 1) && (tabuleiro[k][k1+1] == ' ')){/*Checa abaixo da peca que esta mais em baixo e se for vazio desce as duas pecas*/
  369.         tabuleiro[k-2][k1+1] = ' ';
  370.         tabuleiro[k-1][k1+1] = p1;
  371.         tabuleiro[k][k1+1] = p2;
  372.         k++;
  373.         system(CLEAR);
  374.         printtab();
  375.         w = teclaw(w);/*Ir para a funcao de checar tecla*/
  376.     }
  377.     Manda_Pecas(k-2, k1+1);
  378.     Manda_Pecas(k-1, k1+1);
  379. }
  380.  
  381. int teclas(){/*Chega se alguma tecla de movimentacao foi apertado caso a orientacao da peca seja horizontal*/
  382.     int c, aux, w=0;
  383.     char tecla;
  384.     s=0;
  385.     for(c=0; c<5; c++){
  386.         if (kbhit()){
  387.             tecla = getch();
  388.             if (w == 0){
  389.                 if((tecla == 'd' || tecla == 'D') && (tabuleiro[k][k1+2] == ' ') && (tabuleiro[k][k1] == ' ') && (tabuleiro[k][k1+1] == ' ')){
  390.                     k1++;                                               /*Mexer as pecas para direita*/
  391.                     tabuleiro[k-1][k1-1] = ' ';
  392.                     tabuleiro[k-1][k1]= p1;
  393.                     tabuleiro[k-1][k1+1]= p2;
  394.                     system(CLEAR);
  395.                     printtab();
  396.                 }      
  397.                 else if((tecla == 'a' || tecla == 'A') && (tabuleiro[k][k1-1] == ' ') && (tabuleiro[k][k1] == ' ') && (tabuleiro[k][k1+1] == ' ')){
  398.                     k1--;                                                   /*Mexer as pecas para esquerda*/
  399.                     tabuleiro[k-1][k1+2] = ' ';
  400.                     tabuleiro[k-1][k1+1] = p2;
  401.                     tabuleiro[k-1][k1]= p1;
  402.                     system(CLEAR);
  403.                     printtab();
  404.                 }
  405.                 else if(tecla == 32){/*Trocar as pecas de lugar*/
  406.                     aux = p1;
  407.                     p1 = p2;
  408.                     p2 = aux;
  409.                     system(CLEAR);
  410.                     printtab();
  411.                 }
  412.                 else if((tecla == 'w') || (tecla == 'W')){/*Trocar orientacao para vertical*/
  413.                     if((w == 0) && (tabuleiro[k-2][k1+1] == ' ')){
  414.                     w++;
  415.                     tabuleiro[k-1][k1] = ' ';
  416.                     tabuleiro[k-2][k1+1] = p1;  
  417.                     system(CLEAR);
  418.                     printtab();          
  419.                     }
  420.                 }
  421.                 else if((tecla == 's') || (tecla == 'S')){/*Acelerar a descida das pecas e quebrar a funcao de pegar mais teclas*/
  422.                     descer_rapido(w);
  423.                     break;
  424.                 }
  425.             }
  426.             if (w == 1){
  427.                 movew(w);/*Ir para a funcao de mover pecas verticais*/
  428.             }
  429.         }
  430.         usleep(velocidade/5);
  431.     }
  432.     return w;
  433. }
  434.  
  435.        
  436. void moverpecas(){/*Verifica as pecas vazias para descer ou nao a peca que foi gerada*/
  437.     int w;
  438.     k=1;/*Muda a variavel global de linha para comecar da linha 1 do tabuleiro*/
  439.     s=0;/*Volta a variavel de controle de descer rapido para o padrao*/
  440.     desapareceu=0;
  441.     while ((tabuleiro[k][k1] == ' ')&&(tabuleiro[k][k1+1] == ' ') && s != 1){ /*Caso as pecas forem descer juntas (horizonal)*/
  442.         tabuleiro[k-1][k1+1]=' ';
  443.         tabuleiro[k-1][k1]=' ';
  444.         tabuleiro[k][k1+1]=p2;
  445.         tabuleiro[k][k1]=p1;
  446.         k++;
  447.         system(CLEAR);
  448.         printtab();
  449.         w = teclas();
  450.         if (w == 1 && desapareceu == 1){/*Quebra a funcao de descer caso as orientacao seja vertical, e a peca tenha sido destruida para mandar outra peca*/
  451.             break;
  452.         }
  453.     }
  454.     if (w != 1 && s!= 1){
  455.         while ((tabuleiro[k][k1] == ' ')&&(tabuleiro[k][k1+1] != ' ')){/*Caso a p1 fique solta e a p2 nao (horizontal)*/
  456.             tabuleiro[k-1][k1]=' ';
  457.             tabuleiro[k][k1]=p1;
  458.             system(CLEAR);
  459.             printtab();
  460.             k++;
  461.             usleep(velocidade);
  462.         }
  463.         while ((tabuleiro[k][k1] != ' ')&&(tabuleiro[k][k1+1] == ' ')){/*Caso a p2 fique solta e a p1 nao (horizontal)*/
  464.             tabuleiro[k-1][k1+1]=' ';
  465.             tabuleiro[k][k1+1]=p2;
  466.             k++;
  467.             system(CLEAR);
  468.             printtab();
  469.             usleep(velocidade);
  470.         }
  471.     Manda_Pecas(k-1, k1);
  472.     Manda_Pecas(k-1, k1+1); /*Manda as posicoes onde as pecas pararam para verificacao de iguais ao seu redor*/  
  473.     }
  474. }
  475.  
  476. void tab(){/*Pega altura e largura que sao dadas nas configuraçoes ou no inicio do jogo, caso as configuraçoes nao mudem*/
  477.     int c=0, i=0;
  478.     for(c=0; c<altura; c++){
  479.         for(i=0; i<largura; i++){ /*Aloca '#' nas primeiras e ultimas colunas, e na ultima linha do tabuleiro e ' ' no resto*/
  480.             if((c == altura-1)){
  481.                 tabuleiro[c][i] = '#';
  482.             }
  483.             else if((i == 0)){
  484.                 tabuleiro[c][i] = '#';
  485.             }
  486.             else if((i == largura-1)){
  487.                 tabuleiro[c][i] = '#';
  488.             }
  489.             else{
  490.                 tabuleiro[c][i] = ' ';
  491.             }
  492.         }
  493.     }
  494. }
  495.  
  496. void criarchar(){/*Randomiza as duas pecas*/
  497.     p1 = 'A' + rand() % (qntpecas);
  498.     p2 = 'A' + rand() % (qntpecas);
  499. }
  500.  
  501. void Jogo(int replay){
  502.     int posinicial, perdeu=0;
  503.     char arquivo[20];
  504.     pontos =0;
  505.     tab();/*carrega o tabuleiro*/
  506.     if(replay==2){/*Se o usuario quiser jogar um replay ja existente deve-se digitar o nome do arquivo e serao carregadas as pecas*/
  507.         printf("Digite o nome do arquivo de replay desejado com a extensao .txt no final\n");
  508.         scanf("%s",arquivo);
  509.         if((Replay = fopen(arquivo,"r")) == NULL){/*Se o arquivo não existir, volta ao menu*/
  510.             printf("Arquivo nao existente, voltando para o menu\n");
  511.             usleep(5000000);
  512.             return;
  513.         }
  514.        
  515.     }
  516.     while (!perdeu){
  517.         posinicial = 1 + (rand() % (largura-3));/*Calcula a coluna inicial do primeiro caracter, e coloca o segundo a direita*/
  518.         if (tabuleiro[0][posinicial] != ' '||tabuleiro [0][posinicial+1] != ' '){
  519.             perdeu=1;               /*Se a coluna de p1 ou p2 conicidir com alguma peca que esta no topo do tabuleiro a pessoa perde*/
  520.         }
  521.         else{/*Se nada existir nas colunas iniciais as pecas sao geradas, colocadas nas colunas e sao mandadas para as funcoes de movimentacao*/
  522.             if(rank==0){
  523.                 if(replay == 1){/*Se o usuario quiser criar um replay as pecas sao salvas em um arquivo de texto toda vez que sao criadas*/
  524.                     criarchar();
  525.                     fprintf(Replay,"%c %c\n", p1, p2);
  526.                 }
  527.                 else if(replay == 2){/*quando o usuario quer jogar um  replay existente, o jogo acaba quando as pecas no arquivo acabam*/
  528.                     if(feof(Replay)){
  529.                         perdeu=1;
  530.                         fclose(Replay);
  531.                     }
  532.                     else{
  533.                     fscanf(Replay,"%c %c\n", &p1, &p2);
  534.                     }
  535.                 }
  536.             }
  537.             else{    
  538.                 criarchar();/*Se o modo rankeado estiver ativado nenhum arquivo de texto é aberto*/
  539.             }
  540.             if(!perdeu){
  541.                 tabuleiro[0][posinicial] = p1;
  542.                 tabuleiro[0][posinicial+1]= p2;
  543.                 system(CLEAR);
  544.                 printtab();
  545.                 usleep(720000);
  546.                 k1=posinicial;/*Variavel glogal de coluna recebe as colunas iniciais*/
  547.                 moverpecas();
  548.             }
  549.         }
  550.     }
  551.     system(CLEAR);
  552.     printtab();
  553.     printf("\n");
  554.     printf("Voce perdeu, boa sorte na proxima");
  555.     usleep(5000000);
  556.     getch();
  557. }
  558.  
  559.  
  560. void setConfig(){/*Se existir um arquivo de texto com configuracoes, seus numeros sao carregados nas variveis globais do jogo*/
  561.     Config = fopen("config.txt","r");
  562.         if(Config != NULL){
  563.             fscanf(Config,"%d %d %d %d %d", &altura, &largura, &qntpecas, &destruir, &velocidade);
  564.         }
  565.     fclose(Config);
  566. }
  567.  
  568. void naorank(){/*Caso modo rankeado desativado, serao dadas as opcoes de criar ou abrir um txt para replay*/
  569.     char file[100];
  570.     int replay=0;
  571.     printf("Digite uma opcao a seguir:\n\n");
  572.         printf("1 - Criar um novo replay\n");
  573.         printf("2 - Jogar um replay ja criado\n\n");
  574.         scanf("%d", &replay);
  575.         system(CLEAR);
  576.         switch(replay){
  577.             case 1:/*Abre ou criar um arquivo de texto para guardar as pecas*/
  578.                 setConfig();
  579.                 replay=1;
  580.                 printf("Digite o nome desejado para o arquivo que sera criado.\n Obs.: coloque txt no final:\n");
  581.                 scanf("%s",file);
  582.                 Replay = fopen(file,"w");
  583.                 Jogo(replay);
  584.                 fclose(Replay);
  585.                 return;
  586.             break;
  587.  
  588.             case 2:/*Abre um arquivo de texto para leitura das pecas*/
  589.                 setConfig();
  590.                 replay=2;
  591.                 Jogo(replay);
  592.                 return;
  593.             break;
  594.  
  595.             default:
  596.                 naorank();
  597.             break;
  598.     }
  599. }
  600.  
  601. void OrdenaRanking(Player *rankeada, int n){/*Recebe um vetor de tipo Player e ordena de acordo com a pontuacao*/
  602.     int i, j;
  603.     Player aux;
  604.     for(i=0; i<n; i++){
  605.         for(j=i+1; j<n; j++){
  606.             if(rankeada[j].score > rankeada[i].score){
  607.                 aux=rankeada[j];
  608.                 rankeada[j]=rankeada[i];
  609.                 rankeada[i]=aux;
  610.             }
  611.         }
  612.     }
  613. }
  614.  
  615. void registerMatch(char* nickname){/*Quando um jogo no modo rankeado acaba, tenta alocar a nova pontuacao no arquivo binario*/
  616.     int c=0;
  617.     FILE *bin;
  618.     Player rankeada[10];
  619.     bin = fopen("ranking.bin","rb");
  620.         if(bin == NULL){/*Se ainda nao existir um binario abre um para escrita, aloca pontuacao e nome na primeira posicao do vetor*/
  621.             bin = fopen("ranking.bin","wb");
  622.                 strcpy(rankeada[0].nick, nickname);
  623.                 rankeada[0].score= pontos;
  624.                 for(c=0; c<10;c++){
  625.                     if(c!=0){
  626.                         strcpy(rankeada[c].nick, "");/*Aloca /0 como nick, e 0 como pontuacao em todos as outras 9 posicoes*/
  627.                         rankeada[c].score = 0;
  628.                     }
  629.                     fwrite(&rankeada[c], sizeof(Player), 1, bin);
  630.                 }
  631.             fclose(bin);
  632.         }
  633.         else{/*Se ja existe um binario, abre para leitura*/
  634.             for(c=0;c<10;c++){
  635.                 fread(&rankeada[c], sizeof(Player), 1, bin);
  636.             }
  637.             if (rankeada[9].score < pontos){/*Se a ultima pontuacao contida no vetor for menor que a do jogo atual, ela é descartada e a nova entra no vetor*/
  638.                 strcpy(rankeada[9].nick, nickname);
  639.                 rankeada[9].score= pontos;
  640.             }
  641.         }
  642.         OrdenaRanking(rankeada, 10);/*Quando sair de qualquer um dos casos acima, o vetor do tipo Player é ordenado e gravado no arquivo binario*/
  643.         bin = fopen("ranking.bin","wb");
  644.         for(c=0; c<10;c++){
  645.             fwrite(&rankeada[c], sizeof(Player), 1, bin);
  646.         }
  647.     fclose(bin);
  648. }
  649.  
  650. void simrank(){/*Se modo rankeado ativado, e salvo o nick do jogador*/
  651.     char nickname[100];
  652.     printf("Digite seu nickname com no maximo 10 caracteres\n");
  653.         scanf("%s", nickname);
  654.         while(strlen(nickname)>10){
  655.             printf("Nickname muito longo, digite novamente\n");
  656.             scanf("%s", nickname);
  657.         }
  658.         altura=15;/*Variaveis sao mudadas para o padrao de rankeada*/
  659.         largura=9;
  660.         qntpecas=7;
  661.         destruir=5;
  662.         velocidade=720000;
  663.         Jogo(0);
  664.         registerMatch(nickname);/*Depois de acabado, manda para ver se a pontuacao entra no top 10 do ranking*/
  665.         return;
  666. }
  667.  
  668.  
  669. void config(){
  670.     system(CLEAR);
  671.     printf("CONFIGURACOES:\n\n");
  672.     int op;
  673.  
  674.     Config= fopen("config.txt","w");/*Coloca no arquivo de texto as configuracoes, depois de sair dos cases*/
  675.             fprintf(Config,"%d %d %d %d %d", altura, largura, qntpecas, destruir, velocidade);
  676.     fclose(Config);/*caso nao seja nada mudado, as variaveis globais estao setadas como padrao, e entram no arquivo de texto*/
  677.  
  678.     printf("Digite algum dos numeros a seguir para alterar as configuracoes\n\n");
  679.     printf("1 - Tabuleiro\n");
  680.     printf("2 - Pecas\n");
  681.     printf("3 - Ativar modo rankeado\n");
  682.     printf("4 - Voltar\n");
  683.     scanf("%d",&op);
  684.     switch(op){
  685.         case 1:
  686.             system(CLEAR);
  687.             printf("Digite o tamanho do tabuleiro desejado, primeiro a altura e depois a largura\n");
  688.             scanf("%d %d", &altura, &largura); /*Muda as variaveis de tamnaho do tabuleiro*/
  689.             config();
  690.         break;
  691.  
  692.         case 2:
  693.             system(CLEAR);
  694.             printf("Digite a variedade de pecas que voce deseja que o jogo tenha:\n");
  695.             printf("Minimo= 2 pecas; Maximo = 10 pecas; Padrao = 5 pecas\n");
  696.             scanf("%d", &qntpecas);/*Muda a variedade de pecas que aparecerao no jogo*/
  697.             while (qntpecas<2 || qntpecas>10){
  698.                 system(CLEAR);
  699.                 printf("Quantidade invalida\n");
  700.                 printf("Digite a variedade de pecas que voce deseja que o jogo tenha:\n");
  701.                 printf("Minimo= 2 pecas; Maximo = 10 pecas; Padrao = 5 pecas");
  702.                 scanf("%d", &qntpecas);
  703.             }
  704.  
  705.             system(CLEAR);
  706.             printf("Digite a quantidade de pecas que deverao ficar conectadas para que a pontuacao seja dada\n");
  707.             printf("Minimo= 3 pecas; Maximo = 10 pecas; Padrao = 4 pecas\n");
  708.             scanf("%d",&destruir);/*Muda quantas pecas conectadas fazem pontos no jogo*/
  709.             while (destruir<3 || destruir>10){
  710.                 system(CLEAR);
  711.                 printf("Quantidade invalida\n");
  712.                 printf("Digite a quantidade de pecas que deverao ficar conectadas para que a pontuacao seja dada\n");
  713.                 printf("Minimo= 3 pecas; Maximo = 10 pecas; Padrao = 4 pecas");
  714.                 scanf("%d", &destruir);
  715.             }
  716.  
  717.             system(CLEAR);
  718.             printf("Digite o tempo de atualizaçao do tabuleiro em microssegundos (velocidade de caida das pecas)\n");
  719.             printf("Padrao = 720000 microssegundos\n");
  720.             scanf("%d",&velocidade);/*Muda a velocidade que as pecas caem no tabuleiro*/
  721.             config();
  722.         break;
  723.  
  724.         case 3:
  725.             system(CLEAR);
  726.             printf("Modo rankeado\n\n");
  727.             printf("Digite 1 para ativar e 0 para desativar\n");
  728.             scanf("%d", &rank);/*Ativa ou dessativa o rank*/
  729.             while (rank > 1 || rank < 0){
  730.                 system(CLEAR);
  731.                 printf("Modo rankeado\n\n");
  732.                 printf("Digite 1 para ativar e 0 para desativar\n");
  733.                 scanf("%d", &rank);
  734.             }
  735.             config();
  736.         break;
  737.  
  738.         case 4:
  739.             return;
  740.         break;
  741.  
  742.         default:
  743.             config();
  744.         break;
  745.     }
  746. }
  747.  
  748. void menu(){
  749.     int op;
  750.     system(CLEAR);
  751.     if (rank ==1 ){
  752.         printf(RED"     O MODO RANKEADO ESTA ATIVADO\n"RESET);/*Mostra uma mensagem de aviso caso modo rankeado esteja ativado*/
  753.     }
  754.     printf("1 - Jogar\n");
  755.     printf("2 - Intrucoes\n");
  756.     printf("3 - Configuracoes\n");
  757.     printf("4 - Ranking\n");
  758.     printf("5 - Sair\n");
  759.     printf("Digite o numero correspondente a opcao desejada:\n");
  760.     scanf("%d",&op);
  761.     switch(op) {
  762.         case 1:/*Se a opcao 1 for escolhida e checado a flag de rankeada, caso esteja ativado vai para funcao especifica de jogo rankeado, caso nao, vai para funcao de replay*/
  763.             system(CLEAR);
  764.             if(rank==0){
  765.                 naorank();
  766.             }
  767.             else{
  768.                 simrank();
  769.             }
  770.             menu();
  771.         break;
  772.  
  773.         case 2:/*Se digitada a opçao 2 serao dadas as instruçoes*/
  774.             system(CLEAR);
  775.             printf("INSTRUCOES:\n");
  776.             printf("\n");
  777.             printf("Os controles sao:\n");
  778.             printf("W - muda a orientacao das pecas // A - move a peca para esquerda //\n D - move a peca para direita // S - desce a peca de uma vez na coluna que ela estiver, sem reversao\n");
  779.             printf("Espaco = troca a posicao das duas pecas entre si\n\n");
  780.             printf("As pecas destroem quando voce junta 4 ou mais, e cada peca te da um ponto\n");
  781.             printf("Caso depois das pecas detruirem e as que tiverem acima dessa cairem e tambem tiverem uma formacao de 4 ou mais,\n voce ganha dois pontos por cada uma dessas pecas novas destruidas\n\n");
  782.             printf("As pecas sao geradas em colunas aleatorias da primeira linha do tabuleiro,\n entao o jogo acabara quando a coluna gerada de uma das pecas ja estiver ocupada por outra\n");
  783.             printf("\n");
  784.             printf("Tecla <ENTER> para continuar!");
  785.             getchar();
  786.             menu();
  787.         break;
  788.  
  789.         case 3:/*Se digitada a opçao 3 as configuraçoes serao abertas*/
  790.             config();
  791.             menu();
  792.         break;
  793.  
  794.         case 4:/*Se digitada a opçao 4 sera mostrado o rank*/
  795.             system(CLEAR);
  796.             int c;
  797.             FILE *bin;
  798.             Player rankeada[10];
  799.             bin = fopen("ranking.bin","rb");
  800.                 printf(RED"\t\t  RANKING\n"RESET);
  801.                 if (bin == NULL){/*Mostra a mensagem dizendo que nao ha jogos no ranking*/
  802.                     printf("Ainda não existe nenhuma pontuacao maior que 0 que mereceu o ranking");
  803.                     getch();
  804.                 }
  805.                 else{/*Carrega o binario de ranking para leitura e mostra nick e pontuacao*/
  806.                     bin = fopen("ranking.bin","rb");
  807.                         for(c=0;c<10;c++){
  808.                             fread(&rankeada[c], sizeof(Player), 1, bin);
  809.                         }
  810.                     fclose(bin);
  811.                     for(c=0;c<10;c++){
  812.                         if(strlen(rankeada[c].nick) > 0){
  813.                             if(c==0){
  814.                                 printf("\n\n");
  815.                                 printf(YELLOW"\t\t  %s %dPTS\n",rankeada[c].nick,rankeada[c].score);
  816.                                 printf(YELLOW"\t\t  _______\n");
  817.                                 printf("\t\t |       |\n");
  818.                                 printf("\t\t(|       |)\n");
  819.                                 printf("\t\t |   #1  |\n");
  820.                                 printf("\t\t  \\     /\n");
  821.                                 printf("\t\t    --- \n");
  822.                                 printf("\t\t   _|_|_\n\n"RESET);
  823.                             }  
  824.                             else{
  825.                                 printf("\t\t#%d-", c+1);
  826.                                 printf(YELLOW"%s  %dPTS\n"RESET,rankeada[c].nick, rankeada[c].score);
  827.                             }
  828.                         }
  829.                     }
  830.                 }
  831.                 printf("\nTecla <ENTER> para continuar!");
  832.                 getch();
  833.             menu();
  834.         break;
  835.  
  836.         case 5:/*E por fim se a opçao for 5 o jogo fechara*/
  837.             exit(0);
  838.         break;
  839.  
  840.         default:
  841.             menu();
  842.         break;
  843.     }
  844. }
  845.  
  846. void Nome_Jogo(){/*escreve o nome do jogo e espera o jogador digitar*/
  847.     system(CLEAR);
  848.     printf("\n");
  849.     printf("\n");
  850.     printf(RED "       ============" BLUE "  ========="CYAN"   ========="YELLOW" ============"MAGENTA" ===="GREEN" =========\n");
  851.     printf(RED"            ||      "BLUE" ||     //   "CYAN"||          "YELLOW"   ||       "MAGENTA"||"GREEN"  ||       \n");
  852.     printf(RED"            ||      "BLUE" ||    //    "CYAN"||          "YELLOW"   ||       "MAGENTA"||"GREEN"  ||        \n");
  853.     printf(RED"            ||      "BLUE" ||  \\\\    "CYAN"  ||======  "YELLOW"     ||     "MAGENTA"  ||"GREEN"  =========\n");
  854.     printf(RED"            ||      "BLUE" ||   \\\\   "CYAN"  ||        "YELLOW"     ||     "MAGENTA"  ||"GREEN"         ||\n");
  855.     printf(RED"            ||      "BLUE" ||    \\\\  "CYAN"  ||        "YELLOW"     ||     "MAGENTA"  ||"GREEN"         ||\n");
  856.     printf(RED"            ||      "BLUE" ||     \\\\ "CYAN"  ========= "YELLOW"     ||     "MAGENTA" ===="GREEN" =========\n"RESET);
  857.     printf("\n");
  858.     printf("\t\t Digite qualquer tecla para ir ao menu");
  859.     while( kbhit() != 1){
  860.     }
  861. }
  862.  
  863. int main(){
  864.     srand(time(0));
  865.     Nome_Jogo(); /*Abre a funcao que printa o nome do Jogo na tela*/
  866.     menu();
  867.     return 0;
  868. }
RAW Paste Data
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
 
Top