API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 9th, 2018
118
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.12 KB | None | 0 0
raw download clone embed print report
  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. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!