daily pastebin goal
51%
SHARE
TWEET

Untitled

a guest Dec 9th, 2018 63 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. ######################################################
  3. # Universidade de Brasilia                           #
  4. # Instituto de Ciencias Exatas                       #
  5. # Departamento de Ciencia da Computacao              #
  6. #                                                    #
  7. # Algoritmos e Programacao de Computadores - 2/2018  #
  8. #                                                    #
  9. # Aluna : Giovana Pinho Garcia                       #
  10. # Matricula : 18/0101374                             #
  11. # Turma : A                                          #
  12. # Versao  do Compilador : 6.3.0                      #
  13. #                                                    #
  14. # Descricao : Jogo similar ao tetris com letras      #
  15. ######################################################
  16. */
  17.  
  18.  
  19.  
  20. #include <stdio.h>
  21. #include <stdlib.h>
  22. #include <unistd.h>
  23. #include <fcntl.h>
  24. #include <time.h>
  25. #include <string.h>
  26.  
  27. /*Expressões que mudam a cor dos caracteres no terminal*/
  28. #define GREEN "\x1b[32m"
  29. #define YELLOW "\x1b[33m"
  30. #define BLUE "\x1b[34m"
  31. #define MAGENTA "\x1b[35m"
  32. #define CYAN "\x1b[36m"
  33. #define RESET "\x1b[0m"
  34. #define RED "\x1b[31m"
  35. #define BPURPLE "\033[1;35m"
  36. #define BGREEN "\033[1;32m"
  37. #define BBLUE "\033[1;34m"
  38. #define BRED "\033[1;31m"
  39. #define BYELLOW "\033[1;33m"
  40.  
  41.  
  42. #ifdef _WIN32
  43. #define CLEAR "cls"
  44. #else
  45. #define CLEAR "clear"
  46. #endif
  47.  
  48. int altura, largura, posicao, qtdIguais=0, vL[100], vC[100], pontos=0, pts=0, cont=0, vezes=1, tempoS, tempo;
  49. char tabuleiro[1000][1000];
  50. char p1, p2; //char para as pecas 1 e 2
  51. int x1, l1, x2, l2; //coordenadas de p1 e p2
  52. int Qtdpecas, QtdConect;
  53. int ativado=0; //modo rankeado ativado ou nao
  54. char vazio[] = "\0";
  55.  
  56. typedef struct{
  57.     char nick[11];
  58.     int score;
  59. }Player;
  60.  
  61. Player jogador[11];
  62.  
  63.  
  64.  
  65. /*funcao para implementar getch e kbhit*/
  66. #ifndef _WIN32
  67.     #include <termios.h>
  68.     int kbhit(){
  69.         struct termios oldt, newt;
  70.         int ch, oldf;
  71.     tcgetattr(STDIN_FILENO,&oldt);
  72.     newt = oldt;
  73.     newt.c_lflag &= ~(ICANON | ECHO);
  74.     tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  75.     oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
  76.     fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
  77.  
  78.     ch = getchar();
  79.  
  80.     tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  81.     fcntl(STDIN_FILENO, F_SETFL, oldf);
  82.  
  83.     if(ch != EOF){
  84.         ungetc(ch,stdin);
  85.         return 1;
  86.     }
  87.     return 0;
  88. }
  89.  
  90. int getch(void) {
  91.     int ch;
  92.     struct termios oldt;
  93.     struct termios newt;
  94.     tcgetattr(STDIN_FILENO,&oldt);
  95.     newt = oldt;
  96.     newt.c_lflag &= ~(ICANON | ECHO);
  97.     tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  98.     ch = getchar();
  99.     tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  100.     return ch;
  101. }
  102.  
  103. #else
  104. #include <conio.h>
  105. #endif
  106.  
  107. /*funcao para printar as intrucoes*/
  108. void instrucoes(){
  109.     printf("O jogo possui diversos tijolos aleatorios, que cairao de posicoes randomicas a partir do topo do tabuleiro. O jogador tem ");
  110.     printf("como objetivo conseguir o maior numero de pontos antes do fim do jogo.\n\n");
  111.     printf("O jogador controla as pecas que caem. Este pode executar os seguintes comandos:\n");
  112.     printf("1. Movimentar-se horizontalmente, sem ultrapassar os limites do grid. Utilizando as teclas 'a' e 'd'.\n");
  113.     printf("2. Acelerar a descida da peca. O movimento eh irreversivel ate que a peca alcance a superficie inferior do tabuleiro. Utilizando a tecla 's'.\n");
  114.     printf("3. Alterar a ordem dos caracteres de uma peca enquanto cai. Utilizando a tecla 'w'.\n");
  115.     printf("4. Alterar a orientacao da peca entre vertical e horizontal. Utilizando a tecla 'w'.\n\n");
  116.     printf("Quando um conjunto de 4 ou mais caracteres conectados eh encontrado o jogador recebe um ponto para cada caractere ");
  117.     printf("conectado e todos os caracteres desse conjunto sao apagados. Se outro conjunto de 4 ou mais caracteres for formado pelo ");
  118.     printf("desaparecimento das pecas do conjunto anterior o jogador recebera os pontos relativos a esse conjunto, alem de receber um ");
  119.     printf("bonus por ter feito um combo, quanto maior o combo maior deve ser o bonus.\n\n");
  120.     printf("A partida deve ser encerrada caso as pecas alcancem o topo do tabuleiro, e novas pecas nao consigam mais ser inseridas por falta de espaco.\n\n");
  121. }
  122.  
  123. /*funcao para criar caracteres pseudo-aleatorios*/
  124. void criachar(){
  125.     srand(time(0));
  126.     p1 = 'A' + rand() % Qtdpecas;
  127.     p2 = 'A' + rand() % Qtdpecas;
  128. }
  129.  
  130. /*funcao que define a posicao aleatoria das pecas*/
  131. void posicaopecas(){
  132.     srand(time(0));
  133.     posicao = (rand() % (largura-3)) + 1;
  134. }
  135.  
  136. /*funcao para printar o tabuleiro na tela*/
  137. void mostratabuleiro(){
  138.     int i, j;
  139.     system(CLEAR);
  140.     pontos += pts;
  141.     printf("PONTOS : %d\n\n", pontos);
  142.     pts = 0;
  143.     for(i=0; i<altura; i++){
  144.         for(j=0; j<largura; j++){
  145.             if ((tabuleiro[i][j]>= 'A')&&(tabuleiro[i][j]<= 'J')){
  146.                 switch(tabuleiro[i][j]){
  147.                     case 'A':printf(GREEN"%c"RESET, tabuleiro[i][j]);
  148.                             break;
  149.                     case 'B':printf(RED"%c"RESET, tabuleiro[i][j]);
  150.                             break;
  151.                     case 'C':printf(CYAN"%c"RESET, tabuleiro[i][j]);
  152.                             break;
  153.                     case 'D':printf(MAGENTA"%c"RESET, tabuleiro[i][j]);
  154.                             break;
  155.                     case 'E':printf(YELLOW"%c"RESET, tabuleiro[i][j]);
  156.                             break;
  157.                     case 'F':printf(BGREEN"%c"RESET, tabuleiro[i][j]);
  158.                             break;
  159.                     case 'G':printf(BBLUE"%c"RESET, tabuleiro[i][j]);
  160.                             break;
  161.                     case 'H':printf(BPURPLE"%c"RESET, tabuleiro[i][j]);
  162.                             break;
  163.                     case 'I':printf(BRED"%c"RESET, tabuleiro[i][j]);
  164.                             break;
  165.                     case 'J':printf(BYELLOW"%c"RESET, tabuleiro[i][j]);
  166.                             break;
  167.                     default:break;
  168.                 }
  169.             }
  170.             else{
  171.                 printf("%c", tabuleiro[i][j]);
  172.             }
  173.         }
  174.         printf("\n");
  175.     }
  176.     printf("\n");
  177. }
  178.  
  179. /*funcao para mecher as pecas para o lado e mudar de horizontal para vertical*/
  180. void mecherpeca(){
  181.     int i;
  182.     char move;
  183.     if((((tabuleiro[l1+1][x1] == ' ' || tabuleiro[l1+1][x1] == p2) && (tabuleiro[l2+1][x2] == ' ')) && ((tabuleiro[l2+1][x2] == ' ' || tabuleiro[l2+1][x2] == p1) && tabuleiro[l1+1][x1] == ' '))){
  184.         for(i = 0; i < 40; i++){
  185.             /*ler a acao que o jogador quer executar*/
  186.             if(kbhit()){
  187.                 move = getch();
  188.                 /*mover a peca para direita*/
  189.                 if(move == 'd'){
  190.                     if((tabuleiro[l1][x1+1] == ' ') || (tabuleiro[l2][x2+1] == ' ')){
  191.                         tabuleiro[l1][x1] = ' ';
  192.                         tabuleiro[l2][x2] = ' ';
  193.  
  194.                         x1++;
  195.                         x2++;
  196.  
  197.                         tabuleiro[l1][x1] = p1;
  198.                         tabuleiro[l2][x2] = p2;
  199.                     }
  200.                 }
  201.                 /*mover a peca para esquerda*/
  202.                 if(move == 'a'){
  203.                     if((tabuleiro[l1][x1-1] == ' ') || (tabuleiro[l2][x2-1] == ' ')){
  204.                         tabuleiro[l1][x1] = ' ';
  205.                         tabuleiro[l2][x2] = ' ';
  206.  
  207.                         x1--;
  208.                         x2--;
  209.  
  210.                         tabuleiro[l1][x1] = p1;
  211.                         tabuleiro[l2][x2] = p2;
  212.                     }
  213.                 }
  214.                 /*mudar a posicao da peca no sentido horario*/
  215.                 if(move == 'w'){
  216.                     /*horizontal para vertical*/
  217.                     if(l1 == l2){
  218.                         if(x1<x2){
  219.                             tabuleiro[l1][x1] = ' ';
  220.                             x1 = x2;
  221.                             l1--;
  222.                             tabuleiro[l1][x1] = p1;
  223.                         }
  224.                         else {
  225.                             tabuleiro[l2][x2] = ' ';
  226.                             x2 = x1;
  227.                             l2--;
  228.                             tabuleiro[l2][x2] = p2;
  229.                         }
  230.                     }
  231.                     /*vertical para horizontal*/
  232.                     else if(x1 == x2){
  233.                         if((l1<l2) && (tabuleiro[l2][x2+1] == ' ')){
  234.                             tabuleiro[l1][x1] = ' ';
  235.                             x1++;
  236.                             l1 = l2;
  237.                             tabuleiro[l1][x1] = p1;
  238.                         }
  239.                         else if((l2<l1) && (tabuleiro[l1][x1+1] == ' ')){
  240.                             tabuleiro[l2][x2] = ' ';
  241.                             x2++;
  242.                             l2 = l1;
  243.                             tabuleiro[l2][x2] = p2;
  244.                         }
  245.                     }
  246.                 }
  247.                 /*aumentar a velocidade*/
  248.                 if(move == 's'){
  249.                     tempo = tempoS/100000;
  250.                 }
  251.                 mostratabuleiro();
  252.             }
  253.             usleep(tempo/40);
  254.         }
  255.     }
  256. }
  257.  
  258. /*funcao para checar se essa posicao ja foi contada no contador*/
  259. int jaexiste(int l, int c){
  260.     int i;
  261.     for(i=0; i<qtdIguais; i++){
  262.         if(vL[i] == l && vC[i] == c){
  263.             return 1;
  264.         }
  265.     }
  266.     return 0;
  267. }
  268.  
  269. /*funcao recursiva para encontrar as letras juntas*/
  270. void EncIgual(int l, int c, int valor){
  271.     if(qtdIguais == 0){
  272.         vL[0] = l;
  273.         vC[0] = c;
  274.         qtdIguais++;
  275.     }
  276.     if(valor == tabuleiro[l+1][c] && jaexiste(l+1, c) == 0){
  277.         vL[qtdIguais] = l+1;
  278.         vC[qtdIguais] = c;
  279.         qtdIguais++;
  280.         EncIgual(l+1, c, valor);
  281.     }
  282.     if(valor == tabuleiro[l-1][c] && jaexiste(l-1, c) == 0){
  283.         vL[qtdIguais] = l-1;
  284.         vC[qtdIguais] = c;
  285.         qtdIguais++;
  286.         EncIgual(l-1, c, valor);
  287.     }
  288.     if(valor == tabuleiro[l][c+1] && jaexiste(l, c+1) == 0){
  289.         vL[qtdIguais] = l;
  290.         vC[qtdIguais] = c+1;
  291.         qtdIguais++;
  292.         EncIgual(l, c+1, valor);
  293.     }
  294.     if(valor == tabuleiro[l][c-1] && jaexiste(l, c-1) == 0){
  295.         vL[qtdIguais] = l;
  296.         vC[qtdIguais] = c-1;
  297.         qtdIguais++;
  298.         EncIgual(l, c-1, valor);
  299.     }
  300.     return;
  301. }
  302.  
  303. /*funcao para trasformar os * em espacos e descer as pecas*/
  304. void Descerpecas(){
  305.     int i, j, k, linha;
  306.     for(j=1; j<largura-1; j++){
  307.         for(i=altura-2; i>0; i--){
  308.             if(tabuleiro[i][j] == '*'){ // transforma * em espaco
  309.                 tabuleiro[i][j] = ' ';
  310.                 k = i;
  311.                 cont = 1;
  312.                 while((tabuleiro[k-1][j] != ' ') && (k-1 >= 0)){ // transforma * em espaco
  313.                     if(tabuleiro[k-1][j] == '*'){
  314.                         tabuleiro[k-1][j] = ' ';
  315.                     }
  316.                     else{
  317.                         linha = k-1;
  318.                         while(tabuleiro[linha + 1][j] == ' '){ // desce a letra ate embaixo nao ser espaco
  319.                             tabuleiro[linha + 1][j] = tabuleiro[linha][j];
  320.                             tabuleiro[linha][j] = ' ';
  321.                             linha++;
  322.                         }
  323.                     }
  324.                     k--;
  325.                 }
  326.             }
  327.         }
  328.     }
  329.     usleep(500000);
  330.     mostratabuleiro();
  331. }
  332.  
  333. /*funcao para descer p1 e p2*/
  334. void DescerPecasPrincipais(){
  335.     while((tabuleiro[l1+1][x1] == ' ') || (tabuleiro[l2+1][x2] == ' ')){
  336.         mostratabuleiro();
  337.         /*faz as pecas p1 e p2 descerem*/
  338.         if(l1<l2){
  339.             if(tabuleiro[l2+1][x2] == ' '){
  340.                 l2++;
  341.                 tabuleiro[l2-1][x2] = ' ';
  342.                 tabuleiro[l2][x2] = p2;
  343.             }
  344.             if(tabuleiro[l1+1][x1] == ' '){
  345.                 l1++;
  346.                 tabuleiro[l1-1][x1] = ' ';
  347.                 tabuleiro[l1][x1] = p1;
  348.             }
  349.         }
  350.         else if(l2<l1 || l1==l2){
  351.             if(tabuleiro[l1+1][x1] == ' '){
  352.                 l1++;
  353.                 tabuleiro[l1-1][x1] = ' ';
  354.                 tabuleiro[l1][x1] = p1;
  355.             }
  356.             if(tabuleiro[l2+1][x2] == ' '){
  357.                 l2++;
  358.                 tabuleiro[l2-1][x2] = ' ';
  359.                 tabuleiro[l2][x2] = p2;
  360.             }
  361.         }
  362.         mecherpeca();
  363.     }
  364. }
  365.  
  366. /*funcao para sumir com as pecas juntas e pontuar*/
  367. void SumirPecas(){
  368.     int x, y, i;
  369.     qtdIguais = 0;
  370.     EncIgual(l1, x1, tabuleiro[l1][x1]);
  371.     /*confere se tem 4 ou mais iguais juntas*/
  372.     if(qtdIguais >= QtdConect){
  373.         pts += qtdIguais; //conta os pontos
  374.         for(i=0; i<qtdIguais; i++){
  375.             y = vL[i];
  376.             x = vC[i];
  377.             tabuleiro[y][x] = '*'; //troca por *
  378.         }
  379.         mostratabuleiro();
  380.         Descerpecas();
  381.     }
  382.     if(tabuleiro[l2][x2] != ' '){
  383.         qtdIguais = 0;
  384.         EncIgual(l2, x2, tabuleiro[l2][x2]);
  385.         /*confere se tem 4 ou mais iguais juntas*/
  386.         if(qtdIguais >= QtdConect){
  387.             pts += qtdIguais; //conta os pontos
  388.             for(i=0; i<qtdIguais; i++){
  389.                 y = vL[i];
  390.                 x = vC[i];
  391.                 tabuleiro[y][x] = '*'; //troca por *
  392.             }
  393.             mostratabuleiro();
  394.             Descerpecas(); //transforma * em espaco e desce as pecas
  395.         }
  396.     }
  397. }
  398.  
  399. /*funcao para sumir as pecas que cairam e implementar o bonnus*/
  400. void SumirPecasBonus(){
  401.     int x, y, i, j, k;
  402.     vezes = 1;
  403.     while(cont != 0){
  404.         cont = 0;
  405.         vezes++; //para implementar o bonus
  406.         for(i=1; i<altura; i++){
  407.             for(j=1; j<largura; j++){
  408.                 if((tabuleiro[i][j] != ' ') && (tabuleiro[i][j] != '#')){
  409.                     qtdIguais = 0;
  410.                     EncIgual(i, j, tabuleiro[i][j]);//checar quantas iguais adjacentes
  411.                     if(qtdIguais >= QtdConect){
  412.                         pts += (qtdIguais*vezes);
  413.                         for(k=0; k<qtdIguais; k++){
  414.                             y = vL[k];
  415.                             x = vC[k];
  416.                             tabuleiro[y][x] = '*';
  417.                         }
  418.                         mostratabuleiro();
  419.                         Descerpecas();
  420.                     }
  421.                 }
  422.             }
  423.         }
  424.     }
  425. }
  426.  
  427. /*define tamanho da tabuleiro*/
  428. void DimensoesTabuleiro(){
  429.     int a, l;
  430.     FILE* f;
  431.  
  432.     printf("Recomendado\nnao colocar matriz menor que 5x5 ou maior que 30x30\n");
  433.     printf("Altura: \n");
  434.     scanf("%d", &a);
  435.     printf("Largura: \n");
  436.     scanf("%d", &l);
  437.     f = fopen("conf.txt", "r+");
  438.     altura = a;
  439.     largura = l;
  440.     fprintf(f, "%d %d ", a, l);
  441.     fclose(f);
  442.     system(CLEAR);
  443. }
  444.  
  445. /*define a qunantidade de pecas, as pecas conectadas e a velocidade das pecas*/
  446. void QuantidadePecas(){
  447.     int p, c, a1, a2, a3, a4, escolha, s;
  448.  
  449.     do{
  450.         do{
  451.             printf("1 - Quntidade de pecas\n");
  452.             printf("2 - Quantidade de pecas necessarias para pontuar\n");
  453.             printf("3 - Velocidade das pecas\n");
  454.             printf("4 - Voltar\n");
  455.             scanf("%d", &escolha);
  456.         }while(escolha != 1 && escolha != 2 && escolha != 3 && escolha != 4);
  457.         system(CLEAR);
  458.  
  459.  
  460.         if(escolha == 1){
  461.  
  462.             FILE* f;
  463.             f = fopen("conf.txt", "r+");
  464.  
  465.             /*quantidade de pecas*/
  466.             printf("ATENCAO : Minimo 2, Maximo 10, Default 5.\n");
  467.             printf("Quantidade de pecas:\n");
  468.             scanf("%d", &p);
  469.             fscanf(f, "%d %d ", &a1, &a2);
  470.             if(p>=2 && p<=10){
  471.                 Qtdpecas = p;
  472.                 fprintf(f,"%d ", p);
  473.             }
  474.             system(CLEAR);
  475.         }
  476.  
  477.         else if(escolha == 2){
  478.  
  479.             FILE* f;
  480.             f = fopen("conf.txt", "r+");
  481.  
  482.             /*quantidade de pecas conectadas para pontuar*/
  483.             printf("ATENCAO : Minimo 3, Maximo 10, Default 4.\n");
  484.             printf("Quantidade de pecas necessarias para se pontuar:\n");
  485.             scanf("%d", &c);
  486.             fscanf(f, "%d %d %d ", &a1, &a2, &a3);
  487.             if(c>=3 && c<=10){
  488.                 QtdConect = c;
  489.                 fprintf(f,"%d ", c);
  490.  
  491.             }
  492.             system(CLEAR);
  493.         }
  494.  
  495.         else if(escolha == 3){
  496.  
  497.             FILE* f;
  498.             f = fopen("conf.txt", "r+");
  499.  
  500.             /*velocidade que as pecas caem*/
  501.             do{
  502.                 printf("Velocidade que as pecas caem:\n");
  503.                 printf("1 - Rapido\n");
  504.                 printf("2 - Medio\n");
  505.                 printf("3 - Lento\n");
  506.                 scanf("%d", &s);
  507.             }while(s != 1 && s != 2 && s != 3);
  508.  
  509.             if(s == 1){
  510.                 tempoS = 360000;
  511.             }
  512.             else if(s == 2){
  513.                 tempoS = 720000;
  514.             }
  515.             else if(s == 3){
  516.                 tempoS = 820000;
  517.             }
  518.             fscanf(f, "%d %d %d %d ", &a1, &a2, &a3, &a4);
  519.             fprintf(f,"%d", s);
  520.             fclose(f);
  521.             system(CLEAR);
  522.         }
  523.     }while(escolha != 4);
  524. }
  525.  
  526. /*funcao para arrumar as configuracoes para o modo rankeado*/
  527. void AtivarRank(){
  528.     ativado++;
  529.     if(ativado%2 != 0){
  530.         FILE* f;
  531.  
  532.         f = fopen("conf.txt", "w");
  533.  
  534.         fprintf(f, "%d %d %d %d %d", 15, 9, 7, 5, 720000);
  535.         altura = 15;
  536.         largura = 9;
  537.         Qtdpecas = 7;
  538.         QtdConect = 5;
  539.         tempoS = 720000;
  540.         fclose(f);
  541.  
  542.         ativado = 1;
  543.     }
  544.     else{
  545.         ativado = 0;
  546.         FILE* f;
  547.  
  548.         f = fopen("conf.txt", "w");
  549.  
  550.         fprintf(f, "%d %d %d %d %d", 13, 8, 5, 4, 720000);
  551.         altura = 13;
  552.         largura = 8;
  553.         Qtdpecas = 5;
  554.         QtdConect = 4;
  555.         tempoS = 720000;
  556.         fclose(f);
  557.     }
  558. }
  559.  
  560. /*funcao para mostrar o ranking*/
  561. void Rank(){
  562.     int i;
  563.     char comecar;
  564.     FILE* fbin;
  565.  
  566.     fbin = fopen("ranking.bin", "rb");
  567.  
  568.     if(fbin == NULL){
  569.         printf("Nao ha jogadores rankeados\n");
  570.     }
  571.  
  572.     else{
  573.         fread(&jogador, sizeof(Player), 1, fbin);
  574.         for(i=0; i<10; i++){
  575.             if(jogador[i].score != 0){
  576.                 printf("%s %d\n", jogador[i].nick, jogador[i].score);
  577.             }
  578.         }
  579.         fclose(fbin);
  580.     }
  581.     printf("Aperte enter para voltar ao menu\n");
  582.  
  583.     /*esperar ate o jogador dar enter*/
  584.     getchar();
  585.     getchar();
  586.     system(CLEAR);
  587. }
  588.  
  589. /*funcao para ordenar vetor*/
  590. void BubbleSortSruct(){
  591.     int i, j;
  592.     Player aux;
  593.     for(j=0; j<11; j++){
  594.         for(i=0; i<10; i++){
  595.             if(jogador[i].score < jogador[i+1].score){
  596.                 aux = jogador[i];
  597.                 jogador[i] = jogador[i+1];
  598.                 jogador[i+1] = aux;
  599.             }
  600.         }
  601.     }
  602. }
  603.  
  604. /*funcao para criar e atualizar o ranking*/
  605. void RegisterMatch(){
  606.     int i;
  607.     FILE* fbin;
  608.  
  609.     fbin = fopen("ranking.bin", "rb");
  610.  
  611.     /*caso ainda nao existir criar um arquivo binario*/
  612.     if(fbin == NULL){
  613.  
  614.         strcpy(jogador[0].nick, jogador[10].nick);
  615.         jogador[0].score = pontos;
  616.  
  617.         for(i=1; i<10; i++){
  618.             strcpy(jogador[i].nick, vazio);
  619.             jogador[i].score = 0;
  620.         }
  621.  
  622.         fbin = fopen("ranking.bin", "wb");
  623.         fwrite(&jogador, sizeof(Player), 1, fbin);
  624.         fclose(fbin);
  625.     }
  626.     /*atualizar o ranking apos a partida*/
  627.     else{
  628.         fread(&jogador, sizeof(Player), 1, fbin);
  629.         fclose(fbin);
  630.  
  631.         jogador[10].score = pontos;
  632.  
  633.         BubbleSortSruct();
  634.  
  635.         fbin = fopen("ranking.bin", "wb");
  636.         fwrite(&jogador, sizeof(Player), 1, fbin);
  637.         fclose(fbin);
  638.     }
  639. }
  640.  
  641. /*funcao para criar o arquivo de texto das configuracoes*/
  642. void CriarArquivo(){
  643.     FILE* f;
  644.     f = fopen("conf.txt", "r");
  645.     if(f == NULL){
  646.         f = fopen("conf.txt", "w");
  647.         fprintf(f, "%d %d %d %d %d", 13, 8, 5, 4, 720000);
  648.         altura = 13;
  649.         largura = 8;
  650.         Qtdpecas = 5;
  651.         QtdConect = 4;
  652.         tempoS = 720000;
  653.     }
  654.     else{
  655.         fscanf(f, "%d %d %d %d %d", &altura, &largura, &Qtdpecas, &QtdConect, &tempoS);
  656.     }
  657.     fclose(f);
  658. }
  659.  
  660. /*funcao das configuracoes*/
  661. void configuracoes(){
  662.     int escolha;
  663.     do{
  664.         /*printa as opcoes de configuracoes*/
  665.         printf("1 - Tabuleiro\n");
  666.         printf("2 - Pecas\n");
  667.         if(ativado == 1){
  668.             printf("3 - Ativar modo Ranqueado : Ativado\n");
  669.         }
  670.         else{
  671.             printf("3 - Ativar modo Ranqueado : Desativado\n");
  672.         }
  673.         printf("4 - Voltar\n");
  674.         scanf("%d", &escolha);
  675.         system(CLEAR);
  676.  
  677.         /*vai para a funcao que o jogador escolheu*/
  678.         switch(escolha){
  679.             case 1 : DimensoesTabuleiro(); break;
  680.             case 2 : QuantidadePecas(); break;
  681.             case 3 : AtivarRank(); break;
  682.             case 4 : break;
  683.             default :
  684.                 getchar();
  685.                 getchar();
  686.                 break;
  687.         }
  688.  
  689.     }while(escolha != 4);
  690. }
  691.  
  692. /*funcao para jogar*/
  693. void jogar(){
  694.     int i=0, j=0, y, x, k, escolha=0, FimdeJogo=0, nulo=0;
  695.     char file[1000], nickname[100] = "aaaaaaaaaaa";
  696.  
  697.     while(escolha != 1 && escolha != 2 && ativado == 0){
  698.         /*modo replay ou nao*/
  699.         printf("Se quiser jogar um jogo novo digite 1.\n");
  700.         printf("Se quiser jogar modo replay digite 2\n");
  701.         scanf("%d", &escolha);
  702.     }
  703.  
  704.     /*pegar o nickname da pessoa no modo rankeado*/
  705.     while(ativado == 1 && strlen(nickname) > 10){
  706.         printf("Minimo 1 caractere e Maximo 10 caracteres\n");
  707.         printf("Digite seu nickname:\n");
  708.         scanf("%s", nickname);
  709.         system(CLEAR);
  710.     }
  711.  
  712.     strcpy(jogador[10].nick, nickname);
  713.  
  714.     FILE* fd;
  715.  
  716.     /*jogar um novo jogo*/
  717.     if(escolha == 1){
  718.         printf("Digite o nome do arquivo texto:\n");
  719.         scanf("%s", file);
  720.         /*escrever no arquivo*/
  721.         fd = fopen(file, "w");
  722.     }
  723.  
  724.     /*jogar modo replay*/
  725.     else if(escolha == 2){
  726.         do{
  727.             printf("Digite o nome do arquivo que voce quer usar como replay:\n");
  728.             scanf("%s", file);
  729.             /*ler do arquivo*/
  730.             fd = fopen(file, "r");
  731.             nulo = 0;
  732.             /*pedir nome do arquivo novamente se ele nao existir*/
  733.             if(fd == NULL){
  734.                 printf("Esse arquivo nao existe\n");
  735.                 nulo = 1;
  736.             }
  737.         }while(nulo == 1);
  738.     }
  739.  
  740.     /*define a borda da matriz*/
  741.     for(i=0; i < altura; i++){
  742.         for(j=0; j < largura; j++){
  743.             if((j == 0) || (j == (largura-1)) || (i == (altura-1))){
  744.                 tabuleiro[i][j] = '#';
  745.             }
  746.             else{
  747.                 tabuleiro[i][j] = ' ';
  748.             }
  749.         }
  750.     }
  751.  
  752.     /*loop do jogo para continuar ate nao caber mais pecas*/
  753.     pontos = 0;
  754.     while(FimdeJogo == 0){
  755.  
  756.         /*caso seja modo rankeado*/
  757.         if(escolha == 0){
  758.             criachar();
  759.         }
  760.         /*escrever no arquivo*/
  761.         else if(escolha == 1){
  762.             criachar();
  763.             fprintf(fd, "%c%c", p1, p2);
  764.         }
  765.         /*ler do arquivo*/
  766.         else if(escolha == 2){
  767.             if(!feof(fd)){
  768.                 fscanf(fd, "%c%c", &p1, &p2);
  769.             }
  770.         }
  771.  
  772.         /*checa se chegou no final do arquivo*/
  773.         if(escolha == 2 && feof(fd)){
  774.             break;
  775.         }
  776.  
  777.         posicaopecas();
  778.         tabuleiro[0][posicao] = p1;
  779.         tabuleiro[0][posicao+1] = p2;
  780.         x1=posicao;
  781.         l1=0;
  782.         x2=posicao+1;
  783.         l2=0;
  784.         tempo = tempoS;
  785.         mostratabuleiro();
  786.         usleep(720);
  787.  
  788.         /*loop para cairem as pecas*/
  789.         DescerPecasPrincipais();
  790.  
  791.         /*fazer as pecas que estao juntas virarem asterisco*/
  792.         SumirPecas();
  793.  
  794.         /*para sumir pecas que cairam e implementar o bonus*/
  795.         SumirPecasBonus();
  796.  
  797.         /*checa a condicao para o jogo continuar*/
  798.         for(j=1; j<largura-2; j++){
  799.             if(tabuleiro[0][j] != ' '){
  800.                 FimdeJogo = 1;
  801.             }
  802.         }
  803.     }
  804.     if(ativado == 0){
  805.         fclose(fd);
  806.     }
  807.     printf("FIM DE JOGO\n");
  808.     printf("SUA PONTUACAO FOI %d\n\n", pontos);
  809.  
  810.     if(ativado == 1){
  811.         RegisterMatch();
  812.     }
  813. }
  814.  
  815. int main(){
  816.     int escolha, i, j, comecar;
  817.  
  818.     system(CLEAR);
  819.  
  820.     printf("     TETRIS      \n");
  821.     printf("Tecle enter para continuar\n");
  822.     /*esperar ate o jogador dar enter*/
  823.     getchar();
  824.     getchar();
  825.     system(CLEAR);
  826.  
  827.     CriarArquivo();
  828.  
  829.     /*loop para printar menu ate o jogador selecionar sair*/
  830.     do {
  831.         /*prints do menu*/
  832.         printf("1 - Jogar\n");
  833.         printf("2 - Instrucoes\n");
  834.         printf("3 - Configuracoes\n");
  835.         printf("4 - Ranking\n");
  836.         printf("5 - Sair\n");
  837.         printf("Digite o numero correspondente a opcao desejada:\n");
  838.         scanf("%d", &escolha);
  839.         system(CLEAR);
  840.  
  841.         /*vai para a funcao que o jogador escolheu*/
  842.         switch(escolha){
  843.             case 1: jogar(); break;
  844.             case 2: instrucoes(); break;
  845.             case 3: configuracoes(); break;
  846.             case 4: Rank(); break;
  847.             case 5: break;
  848.             default:
  849.                 getchar();
  850.                 getchar();
  851.                 break;
  852.         }
  853.  
  854.     }while (escolha != 5);
  855.  
  856.     return 0;
  857. }
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