API tools faq
paste
Advertisement
Guest User

zvxvxzvxcv

a guest
Dec 9th, 2018
99
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.17 KB | None | 0 0
raw download clone embed print report
  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. }
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!