Colocando no gitlab do c3sl

Makefile

+CC = gcc
+CFLAGS = -g -Wall
+OBJ = jogo.o mapa.o funcoes.o
+LIBS = -lncurses
+DEPS = mapa.h funcoes.h
+all: jogo
+
+%.o: %.c $(DEPS) 
+	$(CC) $(CFLAGS) -c -o $@ $<    
+
+jogo: $(OBJ) 
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS) 
+
+exec: jogo
+	./jogo
+
+clean:
+	@rm -f *.o 
+
+purge: clean
+	@rm jogo

README.md

+# ci067p4_boulderdash
+
+LISTA DE COISAS!
+* Controles: anda, escape e help
+* Só Rockford abre caminho na dirt
+* Pode empurrar pedras
+* pedras caem e rolam
+* Explosão 3x3 acontece quando pera cai no rockford
+* Explosão quebra tudo menos parede de aço
+* Faz um tipo pra cada coisa - pedra etc
+    struct{
+      posiçãox
+      posiçãoy
+* Variáveis: vida dele, diamantes, tempo
+* tela de help
+* scores
+# IMPLEMENTAÇÕES
+* **1**Rockford, Dirt, Boulder, Steel Wall
+* **2**Diamond, Wall
+* **2.5**FAZER EM ARQUIVOS SEPARADOS!
+* **3**Firefly, Butterfly
+* **4**Magic Wall
+* **5**Amoeba
+* **6**Exit
+http://wiki.inf.ufpr.br/maziero/doku.php?id=ofcomp:jogo_ascii

funcoes.c

+
+#include "funcoes.h"   
+
+/* esta no .h
+
+#include "mapa.h" // funçoes init e imprime nivel->mapa 
+
+typedef struct {
+	int x;
+	int y;
+	int s2;
+	int score;
+} jogador_t;
+*/
+
+void load_level (nivel_t *nivel, char arquivo[6], jogador_t *rockford) {
+
+	init_mapa(nivel, arquivo);
+	rockford->score = 0;
+	nivel->total_diamantes = 0;
+	// percorrendo o mapa
+	for (int i=0; i < nivel->lin; i++) 
+		for (int j=0; j < nivel->col; j++) {  
+			if (nivel->mapa[index(i, j, nivel->col)] == RF) {	// procura a posição do rockford no mapa 
+				rockford->y = i;
+				rockford->x = j;		// primeiro eixo y, depois eixo x		
+			}
+			if (nivel->mapa[index(i, j, nivel->col)] == DIAMOND ) 
+				nivel->total_diamantes++;  
+		}
+
+	rockford->s2 = MAXVIDA;
+}
+
+double timestamp() {
+	struct timeval tp;
+	gettimeofday(&tp, NULL);
+	return(((double) (tp.tv_sec*1000.0 + tp.tv_usec/1000.0))/1000);  
+}  
+
+void print_info (nivel_t *nivel, jogador_t *rockford, int level, double tempo) {
+	move(nivel->lin, 3); 
+	attron(COLOR_PAIR(5));	// 5 está setado em mapa.c
+	addch(ACS_DIAMOND); 
+	attroff(COLOR_PAIR(5));
+
+	mvprintw(0, 4, "PEGUE TODOS OS DIAMANTES!");
+	mvprintw(nivel->lin, 5, "%d/%d", rockford->score, nivel->total_diamantes);
+	mvprintw(nivel->lin, 20, "%1.1lf", nivel->tempo_total - tempo);
+	mvprintw(nivel->lin, 35, "level %d", level);
+	mvprintw(nivel->lin+2, 4, "score total %d", rockford->score_total);
+	mvprintw(nivel->lin+4, 4, "h  - help");
+	mvprintw(nivel->lin+5, 4, "p  - proximo level");
+	mvprintw(nivel->lin+6, 4, "q  - sair do jogo");
+	refresh();	
+
+}
+
+void ajuda(){
+
+	clear();
+	mvprintw(2, 2, "BOULDER DASH");
+	mvprintw(4, 2, "@ ROCKFORD (você, projetista)");
+	mvprintw(5, 2, "# TERRA (ande à sua vontade) - sustenta pedras e diamantes");
+	mvprintw(6, 2, "o PEDRAS - elas podem te matar quando cairem de uma altura em você");
+	mvprintw(7, 2, "DIAMANTES - quanto maior o nível mais eles valem! ATENÇÂO: eles também são pedras e podem matar");
+
+	mvprintw(9, 2, "Para passar de nível, pegue todos os diamantes antes que o tempo acabe!");
+	mvprintw(10, 2, "Setas do teclado: mover Rockford");
+
+	mvprintw(15, 2, "Para sair, aperte qualquer tecla");
+	refresh();
+
+	char entrada =  getch();
+	char erro = entrada;
+	
+	while (entrada == erro)
+		entrada = getch();
+
+	clear();
+}
+
+// ----------------------------------------------------------------------
+
+void move_rf(nivel_t *nivel, jogador_t *rockford, int comando, int level){
+		int delta_x = 0, delta_y = 0;
+		switch (comando) {
+			case KEY_RIGHT: 
+				delta_x = 1;																											
+				break;
+
+			case KEY_LEFT:
+				delta_x = -1; 														
+				break;
+			
+			case KEY_DOWN:			
+				delta_y = 1;
+				break;
+	
+			case KEY_UP:
+				delta_y = -1;
+				break;
+
+			default:
+				break;
+		}
+			
+		/*
+			se nao tem parede tipo 1
+				se nao tem parede tipo 2
+					se tem pedra
+						e depois tem espaço  
+								mover pedra
+						se nao
+							deltas = 0 
+					se tem diamante
+						contar diamante	
+					andar
+		*/
+
+		if ((nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x, nivel->col)]) != STEELWALL) { 
+			if (nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x, nivel->col)] != STEELWALL2) {
+				if (nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x, nivel->col)] == ROCK) {		
+					if (nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x + delta_x, nivel->col)] == ' ') 
+						nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x + delta_x, nivel->col)] = ROCK;
+					else {
+						delta_x = 0;	delta_y = 0;	
+					} 
+				}
+				if (nivel->mapa[index( (rockford->y + delta_y), rockford->x + delta_x, nivel->col)] == DIAMOND) {
+						rockford->score ++;	
+						rockford->score_total += 1*level; // dimante tem o peso do level		
+				}
+				nivel->mapa[index(rockford->y, rockford->x, nivel->col)] = ' '; 	//apaga
+				rockford->y += delta_y;								// atualiza a posicao
+				rockford->x += delta_x;
+				nivel->mapa[index(rockford->y, rockford->x, nivel->col)] = RF;
+			}
+		}			 	
+}
+
+void gravidade(nivel_t *nivel, jogador_t *rockford) {
+	for (int y=0; y < nivel->lin; y++) 
+		for (int x=0; x < nivel->col; x++) 
+			if( (nivel->mapa[index(y, x, nivel->col)] == ROCK) || (nivel->mapa[index(y, x, nivel->col)] == DIAMOND)) 
+				rockPhysics(nivel, y, x, rockford, nivel->mapa[index(y, x, nivel->col)]);
+
+}
+
+void rockPhysics (nivel_t *nivel, int y, int x, jogador_t *rockford, char pedra) {
+
+	char embaixo = nivel->mapa[index((y+1), x, nivel->col)];
+	char direita = nivel->mapa[index(y, x+1, nivel->col)];
+	char esquerda = nivel->mapa[index(y, x-1, nivel->col)];
+
+	// verifica se pedra deve cair
+	if (embaixo == ' ') {
+		nivel->mapa[index(y, x, nivel->col)] = ' ';
+		nivel->mapa[index((y+1), x, nivel->col)] = pedra;
+
+		// verifica se queda causa explosao
+		if (nivel->mapa[index((y+2), x, nivel->col)] == RF) {	
+			explosao(nivel, (y+2), x-1, rockford);
+			rockford->s2 --;
+		}
+		// recarregamapa(); //reca o regamapa
+	}
+
+	// verifica se deve rolar pra direita ou pra esquerda
+	else if( (embaixo != DUST) && (embaixo != RF) ) {
+		if ( (nivel->mapa[index((y+1), x+1, nivel->col)] == ' ') && (direita == ' ')) {
+			nivel->mapa[index(y, x, nivel->col)] = ' ';
+			nivel->mapa[index((y+1), x+1, nivel->col)] = pedra; 
+		} 
+		else if ( (nivel->mapa[index((y+1), x-1, nivel->col)] == ' ') && (esquerda == ' ')) {
+			nivel->mapa[index(y, x, nivel->col)] = ' ';
+			nivel->mapa[index((y+1), x-1, nivel->col)] = pedra; 
+		}
+	} 
+}
+
+void explosao (nivel_t *nivel, int y, int x, jogador_t *rockford) {
+	// fazer todas as casas vizinhas terem * e depois ' ' 
+	// faz uma explosao 3x3	
+
+	init_pair(8, COLOR_YELLOW, COLOR_RED); 
+
+	for (int i = -1; i < 2; i++)  
+		for (int j = -1; j < 2; j++) { 
+			// paredes nao podem ser destruidas
+			if  (nivel->mapa[index((y+i), (x+j), nivel->col)] != STEELWALL) { 
+				if (nivel->mapa[index((y+i), (x+j), nivel->col)] != STEELWALL2) {
+					nivel->mapa[index((y+i), (x+j), nivel->col)] = ' ';
+				}
+			}
+		}
+
+	attron(COLOR_PAIR(8));
+	attron(A_BLINK);   
+	for (int i = -1; i < 2; i++) 
+		for (int j = -1; j < 2; j++)
+			mvprintw(y+i, x+j, "*");
+	attroff(COLOR_PAIR(8));
+	attroff(A_BLINK);   
+	refresh();
+	sleep(2.5);
+
+
+	// verifica se explosao causa outras quedas
+	for (int i = -2; i < 3; i++)
+		for (int j = -2; j < 3; j++) {
+			if((nivel->mapa[index(y, x, nivel->col)] == ROCK) || (nivel->mapa[index(y, x, nivel->col)] == DIAMOND)) 
+				rockPhysics(nivel, y+i, x+i, rockford, nivel->mapa[index((y+i), (x+j), nivel->col)] );
+		}
+}
+
+// -----------------------------------------------------------------------	
+
+void print_titulo () {
+
+	init_pair(9, COLOR_MAGENTA, COLOR_BLACK);
+	attron(COLOR_PAIR(9));
+	attron(A_BOLD);
+ 	mvprintw(2, 2, "\
+____              _     _             ____            _     \n\
+ | __ )  ___  _   _| | __| | ___ _ __  |  _ \\  __ _ ___| |__  \n\
+ |  _ \\ / _ \\| | | | |/ _` |/ _ \\ '__| | | | |/ _` / __| '_ \\ \n\
+ | |_) | (_) | |_| | | (_| |  __/ |    | |_| | (_| \\__ \\ | | |\n\
+ |____/ \\___/ \\__,_|_|\\__,_|\\___|_|    |____/ \\__,_|___/_| |_|\n");
+
+ 	refresh();
+ 	sleep(1.5);
+	attroff(COLOR_PAIR(9));
+	clear();	
+}
+
+void parabens () {
+	clear();
+	attron(COLOR_PAIR(5));
+	mvprintw(2, 2, "__        __        __   ___       __    /\n |__)  /\\  |__)  /\\  |__) |__  |\\ | /__`  / \n |    /~~\\ |  \\ /~~\\ |__) |___ | \\| .__/ .  \n");
+	refresh();
+	sleep(1.5);
+	attroff(COLOR_PAIR(5));
+}
+
+void solamento () {
+	clear();
+	attron(COLOR_PAIR(3));
+	mvprintw(2, 2, " ____            ______          ____       \n  /\\  _`\\         /\\__  _\\        /\\  _`\\     \n  \\ \\ \\L\\ \\       \\/_/\\ \\/        \\ \\ \\L\\ \\   \n   \\ \\ ,  /          \\ \\ \\         \\ \\ ,__/   \n    \\ \\ \\ \\   __     \\_\\ \\__  __   \\ \\ \\/ __ \n     \\ \\_\\ \\_\\/\\_\\    /\\_____\\/\\_\\   \\ \\_\\/\\_\\ \n      \\/_/\\/ /\\/_/    \\/_____/\\/_/    \\/_/\\/_/\n                                               ");
+	refresh();
+	sleep(1.5);
+	attron(COLOR_PAIR(3));
+	clear();
+}

funcoes.h

+#ifndef __FUNCOES__
+#define __FUNCOES__
+#include <ncurses.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+#define MAXVIDA 1
+
+#include "mapa.h" // funçoes init e imprime mapa 
+
+typedef struct {
+	int x;
+	int y;
+	int s2;
+	int score;
+	int score_total; // peso do diamante varia com o nivel
+} jogador_t;
+
+void load_level (nivel_t *nivel, char arquivo[6], jogador_t *rockford);
+
+double timestamp();
+
+void print_info (nivel_t *nivel, jogador_t *rockford, int level, double tempo);
+
+void ajuda();
+
+// -------------------------------------------------------
+
+void move_rf(nivel_t *nivel, jogador_t *rockford, int comando, int level);
+
+void gravidade(nivel_t *nivel, jogador_t *rockford);
+
+void rockPhysics (nivel_t *nivel, int y, int x, jogador_t *rockford, char pedra) ;
+
+void explosao (nivel_t *nivel, int y, int x, jogador_t *rockford);
+
+// --------------------------------------------------------
+
+void print_titulo ();
+
+void parabens ();
+
+void solamento ();
+#endif
\ No newline at end of file

jogo.c

+#include "mapa.h" 		// funçoes init, imprime mapa 
+#include "funcoes.h" 
+
+#define LEVEL_MAX 4
+
+int main() {
+	initscr () ;		   		// inicializa a biblioteca ncurses
+ 	nodelay (stdscr, TRUE) ; 	// leitura não bloquea o loop
+	cbreak () ;		   			// nao ler teclas de controle (^C, ^Z, etc)
+  	keypad (stdscr, TRUE) ;  	// ativa leitura de teclas de setas, Fn, etc
+  	noecho () ;		   			// não escreve as teclas lidas na tela
+ 	curs_set (0) ;	   			// esconde o cursor do terminal
+	start_color();
+ 	
+ 	print_titulo();
+
+	int tecla;
+	nivel_t nivel;
+	jogador_t rockford; 
+	rockford.score_total = 0;
+	
+	double t0;		
+	double tagora;
+	double tempo;	
+
+	int level = 1;
+	char nome_level[6] = "levelx";
+	int passou;
+
+	while ( tecla != 'q') {
+
+		if (level > LEVEL_MAX)
+			level = 1;
+
+		// carrega novo level
+		nome_level[5] = level + '0'; 				 
+		load_level(&nivel, nome_level, &rockford);	
+		passou = 0;
+			
+		t0 = timestamp();		// registra o tempo de inicio	
+		tempo = tagora - t0;	// tempo atual
+
+		clear();
+		// só sai desse loop perdendo, passando de level ou com q
+		while ((rockford.s2 > 0) && (passou == 0) && (tecla != 'q') && (nivel.tempo_total - tempo > 0)) {  
+
+			tagora = timestamp(); // registra tempo deste ciclo
+			tempo = (tagora - t0); // calcula tempo decorrido
+
+			 		
+			imprime_mapa(&nivel);
+
+			print_info(&nivel, &rockford, level, tempo);
+			
+			usleep(40000); 
+
+			tecla = getch();
+			
+			if (tecla == 'h') {
+				ajuda();
+				tecla = 'q';
+			}
+
+			if (tecla == 'p')
+				passou = 1;
+			
+			// mover personagem
+			move_rf(&nivel, &rockford, tecla, level);	
+		
+			// verificar se pedras ou diamantes caem e rolam
+			gravidade(&nivel, &rockford);
+			
+			// msg de GANHOU 
+			if (rockford.score == nivel.total_diamantes) {
+				parabens();
+				passou=1;
+			}
+		}
+
+		// msg de PERDEU		
+		if ((rockford.s2 == 0) || (nivel.tempo_total - tempo <= 0)) {
+				rockford.score_total = 0;
+				solamento ();
+		}
+
+		level += passou;
+
+	}
+
+	getch(); 
+	endwin();			/* End curses mode		  */
+	free(nivel.mapa); 
+	return 0; 
+}

level1

+7 14 10
+1-----------2
+|#####oooooo|
+|###########|
+|###########|
+|#@  o +++ o|
+3-----------4
\ No newline at end of file

level2

+9 43 70 
+1----------------------------------------2
+|#   ### ###+#o#####o##o###+######o######|
+|#o@o#################+o+##o##+###o##++##|
+|######## ### ########o#o##o##o###o######|
+|o#  ##++#####o#### # #o###o##o#o#o####++|
+|o#oo###### ##ooo##o ###########+#o#ooooo|
+|###o#+o######+#oo##############o########|
+3----------------------------------------4
\ No newline at end of file

level3

+10 43 120
+1----------------------------------------2
+|############+###########################|
+|######++####++#####o############ooo#####|
+|oo###################o#######ooo++++oooo|
+|ooo####+##oo+##### @ #o########o+++#+ooo|
+|oo++##o###oo####### ooo#######oo+++ooooo|
+|o#+###+##+++###########################o|
+|#######################################o|
+3----------------------------------------4
\ No newline at end of file

level4

+11 24 100
+1---------------------2
+|##### ###### ###+oo  |
+|#####o#o#o#o###  ##  |
+|#+####+++++++o ##### |
+|#####o+# @ #+o#####  |
+|#+###o+##o##+o ####  |
+|#####o+++++++o   ### |
+|#####ooooooooo ####  |
+|++   ##o#ooo#o ##### |
+3---------------------4

mapa.c

+/*
+#include <ncurses.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define index(i,j,n) (i*n + j) // matriz alocada linearmente 
+
+#define STEELWALL '|'
+#define STEELWALL2 '-'
+#define DUST '#' 
+#define RF	'®'  
+#define ROCK 'o' 
+#define DIAMOND '+' 
+*/
+
+
+
+#include "mapa.h" 
+
+void init_mapa (nivel_t *nivel, char arquivo[6]) { // arquivo vai ser level1, level2...
+	FILE* level;
+	level = fopen (arquivo, "r");
+	if (!level) {
+		perror ("Erro ao abrir arquivo de leitura");
+		exit(1);  
+	}   
+
+	fscanf(level, "%d", &(nivel->lin)); 
+	fscanf(level, "%d", &(nivel->col));
+	fscanf(level, "%d", &(nivel->tempo_total));
+	nivel->mapa = malloc ((nivel->lin)*(nivel->col)*sizeof(char)); 
+	fread(nivel->mapa, (nivel->lin+1)*(nivel->col+1)*sizeof(char), 1, level); 
+	fclose(level); 
+}  
+
+void colorir (int n, char c) {
+	attron(COLOR_PAIR(n));
+	printw("%c", c);
+	attroff(COLOR_PAIR(n)); 
+}  
+
+
+void imprime_mapa (nivel_t *nivel) {
+	start_color();
+
+
+	if ( (has_colors() == FALSE) || (can_change_color() == FALSE)) {
+		endwin();
+		printf("Your terminal does not support color\n");
+		exit(1);
+	}  
+
+
+	init_color (COLOR_YELLOW, 252, 249, 187) ;
+	
+//	init_pair(1, COLOR_BLACK, COLOR_WHITE); // borda 
+	init_pair(2, COLOR_YELLOW, COLOR_BLACK); // poeira 
+	init_pair(3, COLOR_RED, COLOR_BLACK); // pedra 
+//	init_pair(3, 192, 189, 189); // pedra tentei rgb nao vai
+	init_pair(4, COLOR_GREEN, COLOR_BLACK); // rockford 
+	init_pair(5, COLOR_CYAN, COLOR_BLACK); // diamantes
+	init_pair(6, COLOR_RED, COLOR_BLACK); // explosao 
+
+	char c;
+	attron(A_BOLD);
+
+	move(0,2);
+	for (int i=0; i<nivel->lin; i++) 
+		for (int j=0; j<nivel->col; j++) {
+			c = nivel->mapa[index(i,j,nivel->col)]; 
+			switch (c) 
+			{ 
+				case DUST:
+					colorir(2, c);
+					break;
+    
+				case ROCK:
+					colorir(3, c);
+					break;
+
+				case '@' :
+					colorir(4,RF);
+					break;
+			
+				case DIAMOND:
+					attron(A_BLINK);   
+					attron(COLOR_PAIR(5));
+					addch(ACS_DIAMOND); 
+					attroff(COLOR_PAIR(5)); 
+					attroff(A_BLINK); 
+					break;
+	
+				case '*':
+					colorir(6,c);  
+					break;					
+
+				// bordas
+				case '1':
+				case '2':
+					addch(ACS_TTEE);  
+					break;
+				case '3':
+				case '4':
+					addch(ACS_S1);  
+					break;
+				case STEELWALL:
+					addch(ACS_VLINE);
+					break;  	
+				case STEELWALL2:
+					addch(ACS_S3);
+					break;
+
+				default:
+					printw("%c", nivel->mapa[index(i,j,nivel->col)]); 		
+			}
+		}  		  
+}  

mapa.h

+#ifndef __MAPA__
+#define __MAPA__
+
+#include <ncurses.h>
+#include <stdlib.h>
+#include <stdio.h>
+#define index(i,j,n) (i*n + j) // matriz alocada linearmente 
+
+#define STEELWALL '|'
+#define STEELWALL2 '-'
+#define DUST '#' 
+#define RF	'@'  
+#define ROCK 'o' 
+#define DIAMOND '+' 
+
+typedef struct {
+	char *mapa;
+	int lin;
+	int col;
+	int total_diamantes;
+	int tempo_total;
+} nivel_t;
+
+
+void init_mapa (nivel_t *nivel, char arquivo[6]); 
+
+void colorir (int n, char c);
+
+void imprime_mapa (nivel_t *nivel);
+#endif