Commit 28849a83 authored by Bruno Freitas Tissei's avatar Bruno Freitas Tissei
Browse files

Comentarios terminados

parent 02619c93
/* ==========================================================
* Projeto destinado a disciplina de Oficina de Computacao
*
* Autores: Bruno Freitas Tissei e Ivo de Souza Bueno Junior
* Disciplina: Oficina de Computacao
* Entrega: 17/12/2015
* ========================================================== */
#include "maps.h"
// variavel auxiliar para a leitura do sprite mapa
char input[WIDTH];
// arquivos de sprite de cada level
char mapfile[8][100] = {"./sprites/map1.txt", "./sprites/map2.txt", "./sprites/map3.txt",
"./sprites/map4.txt", "./sprites/map5.txt", "./sprites/map6.txt",
"./sprites/map7.txt", "./sprites/congrats.txt"};
// o jogador
rockford player;
// variaveis para implementacao da lista encadeada que armazena os vagalumes
firefly *firstff, *lastff;
// vetor de cores que serah lido do sprite de cada level
int colors[8][3];
// 123mudar
int alter;
// jogador estah morto?
int dead;
// deslocamento da matriz para imprimir o mapa no centro da tela
int offy, offx;
// linhas e colunas da matriz mapa
int row, col;
int leveltime, waittime, falltime;
// tempos que auxiliam no atraso da mudanca de level, tempo da explosao e tempo de queda
int leveltime, explosiontime, falltime;
// numero do mapa atual
int mapnumber;
int done, lightning;
int hold;
// jogador terminou o level?
int done;
// o relampago estah ativo?
int lightning;
// tempo do relampago
int lightningtime;
// posicao da saida
int extx, exty;
// tempo de atraso para o empurrao das pedras
int pushdelay;
// maior score
int highscore;
// tempo de atraso para as cores dos vagalumes
int blink1, blink2, blink3;
int nff;
// numero de vagalumes
int nfireflies;
// arquivo que contem a ultima pontuacao
FILE *lastscorefile;
// arquivo que contem a maior pontuacao
FILE *highscorefile;
// le o sprite do mapa e armazena na memoria
// *m = o mapa
// mapn = numero do level a ser carregado
// pscore = o score do jogador a ser carregado junto ao level
void readFileMap(map *m, int mapn, int pscore) {
int i, j;
done = lightning = false;
blink1 = 4;
blink2 = 5;
blink3 = 6;
hold = 0;
nff = 0;
lightningtime = 0;
nfireflies = 0;
pushdelay = 0;
mapnumber = mapn;
waittime = 0;
explosiontime = 0;
falltime = 0;
m->sprite = fopen(mapfile[mapnumber], "r");
// cria a lista encadeada para armazenar os vagalumes
firstff = (firefly*) malloc(sizeof(firefly));
lastff = firstff;
lastff->next = NULL;
// le a quantidade de diamantes, pontuacao de cada diamante e o tempo limite para completar o level
// esses valores sao fornecidos junto ao sprite de cada level
fscanf(m->sprite, "%d %d %d", &m->diamonds, &m->score, &leveltime);
// le as cores que variam pra cada sprite do level
for (i = 0; i < 8; i++)
for (j = 0; j < 3; j++)
fscanf(m->sprite, "%d", &colors[i][j]);
// le a matriz do sprite do level
for (i = 0; i < HEIGHT; i++) {
fscanf(m->sprite, "%s", input);
for (j = 0; j < WIDTH; j++) {
// caso a posicao na matriz seja o jogador, defina os atributos do jogador
if (input[j] == '5') {
player.x = i;
player.y = j;
......@@ -58,9 +97,11 @@ void readFileMap(map *m, int mapn, int pscore) {
player.diamonds = 0;
player.score = pscore;
dead = false;
// caso a posicao na matriz seja a saida, armazene a posicao da saida
} else if (input[j] == '4') {
extx = i;
exty = j;
// caso a posicao na matriz seja um vagalume, adicione um vagalume com seus devidos atribudos na lista encadeada
} else if (input[j] == 'M') {
lastff->next = (firefly*) malloc(sizeof(firefly));
lastff = lastff->next;
......@@ -69,7 +110,7 @@ void readFileMap(map *m, int mapn, int pscore) {
lastff->dir = 8;
lastff->dead = false;
lastff->next = NULL;
nff++;
nfireflies++;
}
m->grid[j][i] = input[j];
}
......@@ -77,12 +118,15 @@ void readFileMap(map *m, int mapn, int pscore) {
fclose(m->sprite);
setColors();
// define o offx e offy baseado no tamanho da tela
getmaxyx(stdscr, row, col);
offy = (row / 2) - (12 * 3);
offx = (col / 2) - (20 * 6);
}
// carrega as cores do mapa a partir do sprite correspontes
void setColors() {
// inicia as cores do mapa a partir da matriz de cores
init_color(COLOR_WHITE, colors[0][0], colors[0][1], colors[0][2]);
init_color(COLOR_BLACK, colors[1][0], colors[1][1], colors[1][2]);
init_color(COLOR_RED, colors[2][0], colors[2][1], colors[2][2]);
......@@ -92,46 +136,47 @@ void setColors() {
init_color(COLOR_MAGENTA, colors[6][0], colors[6][1], colors[6][2]);
init_color(COLOR_CYAN, colors[7][0], colors[7][1], colors[7][2]);
// dirt color
// cor da terra
init_pair(1, COLOR_BLACK, COLOR_RED);
// dirt color 2
// cor da terra 2
init_pair(13, COLOR_GREEN, COLOR_RED);
// rock gray color 3
// cor cinza da pedra
init_pair(10, COLOR_BLACK, COLOR_BLUE);
// rock yellow color 2
// cor amarela da pedra
init_pair(8, COLOR_BLACK, COLOR_WHITE);
// rock gray color 2
// cor cinza da pedra 2
init_pair(3, COLOR_BLACK, COLOR_GREEN);
// wall color
// cor da parede
init_pair(4, COLOR_BLACK, COLOR_WHITE);
// steel color
// cor do limite do level (metal)
init_pair(5, COLOR_WHITE, COLOR_BLUE);
// rockford color
// cor do rockford
init_pair(6, COLOR_BLUE, COLOR_BLACK);
// diamond color
// cor do diamante
init_pair(7, COLOR_MAGENTA, COLOR_BLACK);
//explosion color
// cor da exposao
init_pair(9, COLOR_WHITE, COLOR_BLACK);
//number color
// cor amarela dos numeros
init_pair(2, COLOR_YELLOW, COLOR_BLACK);
//white number color
// cor branca dos numeros
init_pair(11, COLOR_CYAN, COLOR_BLACK);
//rockford legs
//rockford leg
init_pair(12, COLOR_RED, COLOR_BLACK);
}
// salva a pontuacao do jogador nos arquivos correspondentes
void saveScore() {
lastscorefile = fopen("./data/lastscore.txt", "w+");
highscorefile = fopen("./data/highscore.txt", "r");
......@@ -139,6 +184,7 @@ void saveScore() {
fprintf(lastscorefile, "%d", player.score);
fscanf(highscorefile, "%d", &highscore);
fclose(highscorefile);
// verifica se a pontuacao deve ser salva como highscore ou nao
if (highscore < player.score) {
highscorefile = fopen("./data/highscore.txt", "w+");
fprintf(highscorefile, "%d", player.score);
......@@ -147,138 +193,206 @@ void saveScore() {
fclose(lastscorefile);
}
// logica do mapa
// *m = o mapa
// action = acao do jogador (teclado)
// *ismenu = estah no menu?
// *loadMenu = carregar no menu
void updateMap(map *m, int action, int *ismenu, int *loadMenu) {
int k, l;
// calcula meio da tela caso o jogador mude o tamanho da janela durante o jogo
getmaxyx(stdscr, row, col);
offy = (row / 2) - (12 * 3);
offx = (col / 2) - (20 * 6);
// se o usuario apertar ESC...
if (action == 9) {
// salva a pontuacao
saveScore();
// volta ao menu
*ismenu = true;
*loadMenu = true;
} else {
// altera direcao do jogador de acordo com a acao
player.dir = action;
// incrementa o tempo de atraso para empurrao da pedra
pushdelay = (pushdelay + 1) % 30;
// se o jogador pegar todos os diamantes...
if (player.diamonds >= m->diamonds) {
// a pontuacao para cada diamante eh alterada
m->score = 15;
// o jogador terminou a fase e pode ir para a proxima
done = true;
lightning = hold <= 8;
// o relampago soh ocorre por 8 ticks
lightning = lightningtime <= 8;
}
// se o jogador nao estiver morto...
if (!dead) {
// se o jogador terminou a fase e jah estah na saida...
if (done && player.x == extx && player.y == exty) {
// se o tempo da fase jah acabou...
if (leveltime == 0) {
// salva o score
saveScore();
// carrega o proximo level
readFileMap(m, mapnumber + 1, player.score);
}
// se nao terminou estah na saida...
} else {
// atualize a posicao do jogador (ou seja, se ele estiver na saida ele nao deve se movimentar)
updateRockford(&player, m, action, done, pushdelay);
// se o tempo do level jah terminou e ele NAO estah na saida, o jogador morre
if (leveltime == 0)
dead = true;
}
// se ele estiver morreu
} else {
waittime++;
if (waittime < 21) {
// o tempo que controla a explosao aumenta
explosiontime++;
// primeiro estado da explosao
if (explosiontime < 21) {
for(k = -1; k <= 1; k++)
for(l = -1; l <= 1; l++)
if(m->grid[player.y+k][player.x+l] != '1')
m->grid[player.y+k][player.x+l] = 'x';
} else if (waittime <= 21) {
// segundo estado da explosao (vazio)
} else if (explosiontime <= 21) {
for(k = -1; k <= 1; k++)
for(l = -1; l <= 1; l++)
if(m->grid[player.y+k][player.x+l] != '1')
m->grid[player.y+k][player.x+l] = '0';
} else if (waittime > 100)
// carrega o mesmo mapa depois de um breve tempo
} else if (explosiontime > 100)
readFileMap(m, mapnumber, player.score);
}
}
}
// desenha o mapa na tela
// *m = o mapa
// time = relogio
void renderMap(map *m, int time) {
int i, j, magnitude;
if (mapnumber == 7)
// mostra o score final caso o "level" seja a tela "congratulations"
if (mapnumber == 7) {
for (i = 21, magnitude = 100000; i <= 26; i++, magnitude /= 10)
m->grid[i][20] = ((player.score / magnitude) % 10) + 'A';
else {
// posiciona o HUB na tela na posicao correta da matriz
// ( grid[i][j] = numero[i] )
} else {
// quantidade de diamantes
m->grid[3][0] = ((m->diamonds / 10) % 10) + 'A';
m->grid[4][0] = (m->diamonds % 10) + 'A';
// simbolo do diamante
m->grid[5][0] = 'K';
// pontuacao de cada diamante
m->grid[6][0] = ((m->score / 10) % 10) + 'A';
m->grid[7][0] = (m->score % 10) + 'A';
// quantidade de diamantes do jogador
m->grid[12][0] = ((player.diamonds / 10) % 10) + 'A';
m->grid[13][0] = (player.diamonds % 10) + 'A';
// tempo do level
for (i = 25, magnitude = 100; i <= 27; i++, magnitude /= 10)
m->grid[i][0] = ((leveltime / magnitude) % 10) + 'A';
// pontuacao do jogador
for (i = 31, magnitude = 100000; i <= 36; i++, magnitude /= 10)
m->grid[i][0] = ((player.score / magnitude) % 10) + 'A';
}
// se o jogadore jah terminou o level e estah na saida...
if (done && player.x == extx && player.y == exty) {
// se o tempo ainda nao acabou...
if (leveltime != 0) {
// acrescenta o tempo restante na pontuacao do jogador
leveltime--;
player.score++;
}
// se ainda nao estah na saida...
} else {
// tempo restante diminui a cada segundo
if (time == 29 && leveltime != 0)
leveltime--;
}
// se estah na hora de mostrar o relampago acrescenta o tempo do relampago
if (lightning)
hold++;
lightningtime++;
// muda as cores dos vagalumes no tempo certo
if (!(time % 2)) {
blink1 = (blink1 % 3) + 4;
blink2 = (blink2 % 3) + 4;
blink3 = (blink3 % 3) + 4;
}
if (nff && !(time % 4))
// se existe vagalume e estah no tempo certo, atualize os vagalumes
if (nfireflies && !(time % 4))
updateFirefly(m, firstff, &dead, done);
// loop que percorre a matriz do sprite do mapa
for (i = 0; i < WIDTH; i++) {
for (j = 0; j < HEIGHT; j++) {
updatePhysics(m, m->grid[i][j], i, j, offx, offy, time, falltime, waittime, &dead);
// atualiza a fisica
updatePhysics(m, m->grid[i][j], i, j, offx, offy, time, falltime, explosiontime, &dead);
// incrementa o tempo de queda
falltime = (falltime + 1) % 7;
// desenha o HUB da tela de "congratulations"
if (mapnumber == 7 && ((m->grid[i][j] >= 'a' && m->grid[i][j] <= 'z') ||
m->grid[i][j] == '@' || m->grid[i][j] == '#' || m->grid[i][j] == '!'))
renderLetter(m->grid[i][j], i, j, offx, offy);
// desenha o HUB do jogo
if (m->grid[i][j] >= 'A' && m->grid[i][j] <= 'K')
renderHUB(m->grid[i][j], i, j, offx, offy);
// desenha cada elemento da matriz do sprite
switch (m->grid[i][j]) {
// fundo
case('0'):
renderChar(empty, i, j, offx, offy, lightning ? 4 : 6);
break;
// borda do mapa (metal)
case('1'):
renderChar((j == 1 || j == 22) ? steel : steel2, i, j, offx, offy, 5);
break;
// terra
case('2'):
renderDirt(i, j, offx, offy);
break;
// parede 1
case('z'):
renderChar(wall, i, j, offx, offy, 4);
break;
// parede 2
case('w'):
renderChar(wall2, i, j, offx, offy, 4);
break;
// saida
case('4'):
// a saida pisca se o jogador terminou a fase
renderChar(ext, i, j, offx, offy, 5);
if (done && time >= 15)
renderChar(empty, i, j, offx, offy, 4);
break;
// jogador
case('5'):
renderRockford(&player, i, j, offx, offy);
break;
// vagalume
case('M'):
renderFirefly(i, j, offx, offy, blink1, blink2, blink3);
break;
// pedra
case('6'):
// avalia se a pedra deve cair ou nao
if ((m->grid[i][j+1] == '6' || m->grid[i][j+1] == 'w' ||
m->grid[i][j+1] == 'z' || m->grid[i][j+1] == '7') &&
m->grid[i+1][j] == '0' && m->grid[i+1][j+1] == '0')
......@@ -293,7 +407,9 @@ void renderMap(map *m, int time) {
renderBould(i, j, offx, offy);
break;
// diamante
case('7'):
// avalia se o diamante deve cair ou nao
if ((m->grid[i][j+1] == '6' || m->grid[i][j+1] == 'w' ||
m->grid[i][j+1] == 'z' || m->grid[i][j+1] == '7') &&
m->grid[i-1][j] == '0' && m->grid[i-1][j+1] == '0')
......
/* ==========================================================
* Projeto destinado a disciplina de Oficina de Computacao
*
* Autores: Bruno Freitas Tissei e Ivo de Souza Bueno Junior
* Disciplina: Oficina de Computacao
* Entrega: 17/12/2015
* ========================================================== */
#ifndef _MAPS_H
#define _MAPS_H
......
......@@ -7,23 +7,34 @@
* ========================================================== */
#include "menu.h"
// cores do menu
int menuColors[3][3];
// variavel auxiliar para a leitura do sprite menu
char input[WIDTH];
// deslocamento da matriz para imprimir o menu no centro da tela
int offmenuy, offmenux;
// linhas e colunas da matriz menu
int row, col;
char mps[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
// nomes dos mapas
char maps[7] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
// mapa atualmente selecionado
int currmap = 0;
// variavel que armazena o mapa a ser selecionado
int buffer;
// le o sprite do mapa e armazena na memoria
// *menu = o menu
void readFileMenu(menu *menu) {
int i, j;
menu->sprite = fopen("./sprites/menu.txt", "r");
buffer = -1;
// le as cores do sprite do menu
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
fscanf(menu->sprite, "%d", &menuColors[i][j]);
// le o sprite do sprite do menu
for (i = 0; i < HEIGHT; i++) {
fscanf(menu->sprite, "%s", input);
for (j = 0; j < WIDTH; j++)
......@@ -33,26 +44,34 @@ void readFileMenu(menu *menu) {
setMenuColors();
}
// carrega as cores do menu a partir do sprite correspondente
void setMenuColors() {
// inicia as cores do menu a partir da matriz de cores
init_color(COLOR_WHITE, menuColors[0][0], menuColors[0][1], menuColors[0][2]);
init_color(COLOR_BLACK, menuColors[1][0], menuColors[1][1], menuColors[1][2]);
init_color(COLOR_BLUE, menuColors[2][0], menuColors[2][1], menuColors[2][2]);
// background
// fundo
init_pair(1, COLOR_BLACK, COLOR_BLACK);
// objects
// letras e simbolos
init_pair(2, COLOR_WHITE, COLOR_BLACK);
// background_smallbox
// fundo do texto "Boulder Dash"
init_pair(3, COLOR_BLUE, COLOR_BLUE);
// all white
// texto "Boulder Dash"
init_pair(4, COLOR_WHITE, COLOR_WHITE);
}
// atualiza o menu
// *menu = o menu
// action = entrada do teclado
// *loadMenu = carrega menu?
int updateMenu(menu *menu, int action, int *loadMenu) {
buffer = -1;
// carrega o menu
if (*loadMenu) {
menu->highscore = fopen("./data/highscore.txt", "r");
fscanf(menu->highscore, "%d", &menu->high);
......@@ -62,43 +81,49 @@ int updateMenu(menu *menu, int action, int *loadMenu) {
setMenuColors();
*loadMenu = false;
}
switch(action){
// avalia a entrada do teclado
switch(action) {
// direita
case 6:
currmap = (currmap + 1) % 7;
break;
// esquerda
case 4:
currmap = currmap == 0 ? 6 : currmap - 1;
break;
// enter
case 1:
buffer = currmap;
break;
default:
break;
}
// retorna o valor do buffer para carregar o mapa selecionado
return buffer;
}
// desenha o menu na tela
// *menu = o menu
void renderMenu(menu *menu){
int i, j;
int i, j, magnitude;
// calcula meio da tela caso o jogador mude o tamanho da janela durante o jogo
getmaxyx(stdscr, row, col);
offmenuy = (row / 2) - (12 * 3);
offmenux = (col / 2) - (20 * 6);
menu->grid[21][22] = mps[currmap];
menu->grid[21][20] = ((menu->high / 100000) % 10) + '0';
menu->grid[22][20] = ((menu->high / 10000) % 10) + '0';
menu->grid[23][20] = ((menu->high / 1000) % 10) + '0';
menu->grid[24][20] = ((menu->high / 100) % 10) + '0';
menu->grid[25][20] = ((menu->high / 10) % 10) + '0';
menu->grid[26][20] = (menu->high % 10) + '0';
menu->grid[21][21] = ((menu->last / 100000) % 10) + '0';
menu->grid[22][21] = ((menu->last / 10000) % 10) + '0';
menu->grid[23][21] = ((menu->last / 1000) % 10) + '0';
menu->grid[24][21] = ((menu->last / 100) % 10) + '0';
menu->grid[25][21] = ((menu->last / 10) % 10) + '0';
menu->grid[26][21] = (menu->last % 10) + '0';
// desenha o mapa selecionado
menu->grid[21][22] = maps[currmap];
// desenha a maior pontuacao
for (i = 21, magnitude = 100000; i <= 26; i++, magnitude /= 10)
menu->grid[i][20] = ((menu->high / magnitude) % 10) + '0';
// desenha a ultima pontuacao
for (i = 21, magnitude = 100000; i <= 26; i++, magnitude /= 10)
menu->grid[i][21] = ((menu->last / magnitude) % 10) + '0';
// percorre a matriz do sprite menu e desenha o simbolo correspondente
for (i = 0; i < WIDTH; i++)
for (j = 0; j < HEIGHT; j++)
renderLetter(menu->grid[i][j], i, j, offmenux, offmenuy);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment