matriz *cofator(matriz *m)
{
matriz *cof,*m1;
int i,j;
cof=alocaMatriz(m->linhas,m->colunas);
if(cof==NULL)
{
return NULL;
}
cof->linhas=m->linhas;
cof->colunas=m->colunas;
if((cof->linhas)==1 && (cof->colunas)==1)
return m;
for(i=0;i<(cof->linhas);i++)
{
for(j=0;j<(cof->colunas);j++)
{
m1=semicof(m,i,j);
if((i+j)%2==0)
cof->valores[i][j]=determinante(m1);
else
cof->valores[i][j]=-determinante(m1);
}
desalocaMatriz(m1);
}
return cof;
}
matriz *adjuntaMatriz(matriz *m)
{
matriz* adjunta, *result;
result = cofator(m);
adjunta = transpor(result);
desalocaMatriz(result);
return adjunta;
}
matriz *inversao(matriz *m)
{
matriz *inversa,*m1,*m2;
inversa=alocaMatriz(m->linhas,m->colunas);
inversa->linhas=m->linhas;
inversa->colunas=m->colunas;
if(((m->colunas)!= (m->linhas)) || (determinante(m)==0))
{
m->colunas=0;
m->linhas=0;
return m;
}
m1=cofator(m);
m2=transpor(m1);
inversa=(divideEscalar(m2,determinante(m)));
desalocaMatriz(m1);
desalocaMatriz(m2);
return inversa;
}
void imprimeArquivo(matriz *invK,FILE *fp2)
{
int i,j;
fprintf(fp2,"%d\n",invK->linhas);
fprintf(fp2,"%d\n",invK->colunas);
for(i=0;i<invK->linhas;i++)
{
for(j=0;j<invK->colunas;j++)
{
fprintf(fp2,"%g ",invK->valores[i][j]);
}
fprintf(fp2,"\n");
}
desalocaMatriz(invK);
}
float determinante(matriz *m)
{
int lin,sinal;
float det;
matriz* m1;
if((m->linhas)==1)
return (m->valores[0][0]);
sinal =-1;
det=0;
for(lin=0;lin<(m->linhas);lin++)
{
m1=semicof(m,lin,0);
sinal = sinal * -1;
det = det + (m->valores[lin][0] * determinante(m1) * sinal);
desalocaMatriz(m1);
}
return det;
}
void initPivotacao(){
char namefile[50];
printf("\n\tNome do arquivo : ");
scanf("%s",&namefile);
strcat(namefile,".txt");
if(fileExist(namefile)==1){
int tam = obtemTamanhoMatriz(namefile);
double **m = alocaMatriz(tam, tam + 1);
int *v = alocaVetorPosicaoColunas(tam);
inicializaMatrizDoArquivo(namefile, m);
//imprimeMatriz(m, tam, tam + 1);
pivotacao(m, tam,v);
resolveMatrizTS(m,tam,v);
//imprimeMatriz(m, tam, tam + 1);
desalocaMatriz(m,tam);
}else{
printf("\n\tERRO! Arquivo nao existe.\n");
}
}
/**
* Função responsável por desalocar todas estruturas de dados remanecentes do
* cálculo da resposta ao jogo dado.
*/
void encerraJogo(jogo oJogo){
while(!pilhaVazia(oJogo.candidatos))
desalocaEstado(desempilha(oJogo.candidatos), oJogo.l);
desalocaMatriz(oJogo.obj, oJogo.l);
free(oJogo.candidatos);
}
int main(int argc, char** argv) {
// verifica se um parametro foi passado, senao exibe a forma de uso
if (!argv[1]){
mostraUso();
return 0;
}
// Procedimento que carrega os dados do arquivo em uma matriz
int **matriz;
int linhas, colunas;
printf("Abrindo arquivo...\n");
matriz = (int **)carregaArquivo(argv[1], &linhas, &colunas);
if (!matriz){
printf("ERRO: nao foi possivel abrir o arquivo %s\n", argv[1]);
return 0;
}
// entrando no loop do menu
int opcao;
do{
// limpa a tela se o clear estiver disponível
system("clear");
printf("Selecione uma opcao ou 0 para encerrar\n" \
"[1] - Salvar\n" \
"[2] - Limiarizar\n" \
"[3] - Inverter\n" \
"[4] - Media 3x3\n" \
"[5] - Mediana 3x3\n" \
"[6] - Numero de brancos\n" \
"======> ");
scanf("%d", &opcao);
switch(opcao){
case 0:
break;
case 1:
printf("\nNome do novo arquivo (enter para sobrescrever): ");
char caminho[20];
// workaround do buffer sujo
getchar();
fgets(caminho, sizeof(caminho), stdin);
if (caminho)
salvaArquivo(caminho, matriz, linhas, colunas);
else
salvaArquivo(argv[1], matriz, linhas, colunas);
teclaEnter();
break;
case 2:
limiarizar(matriz, linhas, colunas);
mostraMatriz(matriz, linhas, colunas);
break;
case 3:
inverter(matriz, linhas, colunas);
mostraMatriz(matriz, linhas, colunas);
break;
case 4:
if (media3x3(matriz, linhas, colunas))
mostraMatriz(matriz, linhas, colunas);
break;
case 5:
if (mediana3x3(matriz, linhas, colunas))
mostraMatriz(matriz, linhas, colunas);
break;
case 6:
printf("\nNumero de brancos: %d\n", nroBrancos(matriz, linhas, colunas));
// espera input do teclado
teclaEnter();
break;
default:
printf("Opcao nao reconhecida");
teclaEnter();
break;
}
}while(opcao != 0);
// liberacao de memoria
desalocaMatriz(matriz, linhas);
return 0;
}
/*metodo principal, gerencia a janela*/
int main(int argc, char argv[]) {
/*janela principal*/
ALLEGRO_DISPLAY *janela = NULL;
/*fila de eventos*/
ALLEGRO_EVENT_QUEUE *filaEvento = NULL;
/*evento atual*/
ALLEGRO_EVENT evento;
ALLEGRO_BITMAP *botao_gravar = NULL, *botao_carregar = NULL, *botao_girar_horario = NULL, *botao_girar_antihorario = NULL;
/*ponteiro para um arquivo no dico*/
FILE *arquivo;
/*definicoes do arquivo*/
int altura = 0,//altura da imagem
largura = 0, //largura da imagem
maxCor = 0;//inteiro que representa tonalidade de cor maxima
char tipo[3];//tipo de PGM
/*estrutura para armazenar os bits do arquivo*/
unsigned char **data = NULL;
/*sinaliza fechamento da janela*/
bool fechaJanela = false;
/*sinaliza existencia de arquivo aberto*/
bool arquivoAberto = false;
/*inicializa bibliotecas*/
if(!(al_init() &&
al_install_mouse()&&
al_init_image_addon()&&
al_install_keyboard()&&
al_init_primitives_addon()&&
(filaEvento = al_create_event_queue()))){
printf("Erro ao inicializar biblioteca(s)!\n");
return 0;
}
// Alocamos o botão para fechar a aplicação
criaBotao(botoes[0], "carregar.bmp");
botao_carregar = al_load_bitmap("carregar.bmp");
if (!botao_carregar)
{
fprintf(stderr, "Falha ao criar botão de carregar a imagem.\n");
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_gravar = al_load_bitmap("salvar.bmp");
if (!botao_gravar)
{
fprintf(stderr, "Falha ao criar botão de salvar a imagem.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_girar_horario = al_load_bitmap("girar_horario.bmp");
if (!botao_girar_horario)
{
fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido horario.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_display(janela);
return -1;
}
// Alocamos o botão para fechar a aplicação
botao_girar_antihorario = al_load_bitmap("girar_anti.bmp");
if (!botao_girar_antihorario)
{
fprintf(stderr, "Falha ao criar botão de girar a imagem 90º sentido anti-horario.\n");
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_bitmap(botao_girar_horario);
al_destroy_display(janela);
return -1;
}
/*cria uma janela 640x480*/
janela = al_create_display(640, 50);
/*registra os eventos*/
al_register_event_source(filaEvento, al_get_display_event_source(janela));
al_register_event_source(filaEvento, al_get_mouse_event_source());
al_register_event_source(filaEvento, al_get_keyboard_event_source());
/*preenche a janela com a cor branca*/
al_clear_to_color(al_map_rgb(255, 255, 255));
/*atualiza tela*/
al_flip_display();
/*fluxo principal da janela*/
while(fechaJanela == false){
/*pega evento da fila*/
al_wait_for_event(filaEvento, &evento);
switch (evento.type) {
/*fecha a janela (termina aplicacao)*/
case ALLEGRO_EVENT_DISPLAY_CLOSE:
fechaJanela = true;
break;
/*carrega imagem em mostra na tela*/
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
if (evento.mouse.x >= 0 && evento.mouse.x <= 70 && evento.mouse.y <= 50 && evento.mouse.y >= 0) {
/*caso algum arquivo estiver aberto, limpa dados*/
if(arquivoAberto==true) {
desalocaMatriz(data, altura);
altura =0;
largura =0;
maxCor =0;
arquivoAberto = false;
}
if(arquivoAberto==false) {
/*carrega imagem na matriz*/
if(carregaImagem (janela, &altura,&largura, &maxCor, tipo, &data)==-1) {
printf("Erro ao desenhar imagem!\n");
break;
}
/*sinaliza como arquivo aberto*/
arquivoAberto = true;
/*desenha a imagem na janela*/
desenha(janela, data, altura, largura);
}
}
if (evento.mouse.x >= 71 && evento.mouse.x <= 140 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
if(arquivoAberto == true) {
if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
printf("Erro ao salvar imagem!\n");
break;
}
}
else {
printf("Nenhum arquivo aberto!\n");
}
}
if (evento.mouse.x >= 141 && evento.mouse.x <= 210 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true)
{
data = rotacao(data, &altura, &largura, 'D');
desenha(janela, data, altura, largura);
}
if (evento.mouse.x >= 211 && evento.mouse.x <= 280 && evento.mouse.y <= 50 && evento.mouse.y >= 0 && arquivoAberto== true){
data = rotacao(data, &altura, &largura, 'E');
desenha(janela, data, altura, largura);
}
break;
case ALLEGRO_EVENT_KEY_DOWN:
switch(evento.keyboard.keycode)
{
case ALLEGRO_KEY_ENTER:
if(arquivoAberto == true) {
if(gravaImagem(janela, tipo, altura, largura, maxCor, data)==-1) {
printf("Erro ao salvar imagem!\n");
break;
}
}
else {
printf("Nenhum arquivo aberto!\n");
}
break;
case ALLEGRO_KEY_SPACE:
data = rotacao(data, &altura, &largura, 'D');
desenha(janela, data, altura, largura);
break;
}
default:
break;
}
al_set_target_bitmap(botao_gravar);
al_set_target_bitmap(botao_carregar);
al_set_target_bitmap(botao_girar_horario);
al_set_target_bitmap(botao_girar_antihorario);
al_set_target_bitmap(al_get_backbuffer(janela));
al_draw_bitmap(botao_carregar, 0,0, 0);
al_draw_bitmap(botao_gravar, 71,0, 0);
al_draw_bitmap(botao_girar_horario, 141,0, 0);
al_draw_bitmap(botao_girar_antihorario, 211,0, 0);
/*atualiza tela*/
al_flip_display();
}
/*limpeza*/
if(data!=NULL && arquivoAberto == true){
desalocaMatriz(data, altura);
}
al_destroy_event_queue(filaEvento);
al_uninstall_mouse();
al_uninstall_keyboard();
al_destroy_bitmap(botao_carregar);
al_destroy_bitmap(botao_gravar);
al_destroy_bitmap(botao_girar_horario);
al_destroy_bitmap(botao_girar_antihorario);
al_destroy_display(janela);
return 0;
}
int main(int argc, char **argv)
{
int nLinhas, nColunas, i, j, aleatorio, aux;
int nDestroyers, nPatrulhas, nPortaAvioes;
jogador jogadores[NUM_JOGADORES];
coordenada coord_ataque;
printf("Entre com a dimensao do tabuleiro (quadrado): ");
scanf("%d", &nLinhas);
nColunas = nLinhas;
do
{
printf("\n------------------\n");
printf("Tamanho dos navios:\n");
printf("Destroyer = 4, Patrulha = 2, Porta-avioes = 5\n");
printf("------------------\n");
printf("Entre com o numero de destroyers, patrulhas e porta avioes (separados por espaco): ");
scanf("%d %d %d", &nDestroyers, &nPatrulhas, &nPortaAvioes);
aux = checaInput(nDestroyers, nPatrulhas, nPortaAvioes, nLinhas, nColunas);
if(aux == 0)
printf("\nAVISO: o tabuleiro nao suporta a quantidade de navios desejada! Entre com novos valores.\n");
}while(!aux);
srand(time(NULL));
// Inicializacao dos jogadores e posicionamento dos navios
for(i = 0; i < NUM_JOGADORES; ++i)
{
jogadores[i].nLinhas = nLinhas;
jogadores[i].nColunas = nColunas;
jogadores[i].nDestroyers = nDestroyers;
jogadores[i].nPatrulhas = nPatrulhas;
jogadores[i].nPortaAvioes = nPortaAvioes;
jogadores[i].totalNavios = nDestroyers + nPatrulhas + nPortaAvioes;
jogadores[i].nNaviosDestruidos = 0;
jogadores[i].ganhou = 0;
jogadores[i].id_jogador = i;
jogadores[i].destroyers = alocaDestroyers(jogadores[i].nDestroyers);
jogadores[i].patrulhas = alocaPatrulhas(jogadores[i].nPatrulhas);
jogadores[i].porta_avioes = alocaPortaAvioes(jogadores[i].nPortaAvioes);
jogadores[i].tabuleiro = alocaTabuleiro(jogadores[i].nLinhas, jogadores[i].nColunas);
if(jogadores[i].tabuleiro == NULL)
return -1;
jogadores[i].matrizControle = alocaMatriz(jogadores[i].nLinhas, jogadores[i].nColunas);
if(jogadores[i].matrizControle == NULL)
return -1;
// Posicionamento dos navios
if(i == 0)
{
do
{
printf("\nDeseja posicionar os navios de maneira aleatoria? (0 - NAO, 1 - SIM): ");
scanf("%d", &aleatorio);
if(aleatorio != 0 && aleatorio != 1)
printf("Opcao invalida!\n");
}while(aleatorio != 1 && aleatorio != 0);
}
else
aleatorio = 1; // o posicionamento dos navios da máquina é sempre feito de forma aleatória
// Coloca os navios de maneira aleatoria no tabuleiro
if(aleatorio)
{
printf("Posicionando destroyers do JOGADOR %d...\n", i);
for(j = 0; j < jogadores[i].nDestroyers; ++j)
{
do
{
jogadores[i].destroyers[j].coord_ini.x = rand() % jogadores[i].nLinhas;
jogadores[i].destroyers[j].coord_ini.y = rand() % jogadores[i].nColunas;
jogadores[i].destroyers[j].coord_fim.x = rand() % jogadores[i].nLinhas;
jogadores[i].destroyers[j].coord_fim.y = rand() % jogadores[i].nColunas;
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].destroyers[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
}
printf("Posicionando patrulhas do JOGADOR %d...\n", i);
for(j = 0; j < jogadores[i].nPatrulhas; ++j)
{
do
{
jogadores[i].patrulhas[j].coord_ini.x = rand() % jogadores[i].nLinhas;
jogadores[i].patrulhas[j].coord_ini.y = rand() % jogadores[i].nColunas;
jogadores[i].patrulhas[j].coord_fim.x = rand() % jogadores[i].nLinhas;
jogadores[i].patrulhas[j].coord_fim.y = rand() % jogadores[i].nColunas;
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].patrulhas[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
}
printf("Posicionando porta-avioes do JOGADOR %d...\n", i);
for(j = 0; j < jogadores[i].nPortaAvioes; ++j)
{
do
{
jogadores[i].porta_avioes[j].coord_ini.x = rand() % jogadores[i].nLinhas;
jogadores[i].porta_avioes[j].coord_ini.y = rand() % jogadores[i].nColunas;
jogadores[i].porta_avioes[j].coord_fim.x = rand() % jogadores[i].nLinhas;
jogadores[i].porta_avioes[j].coord_fim.y = rand() % jogadores[i].nColunas;
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].porta_avioes[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
}
}
else
{
printf("Posicionando destroyers do JOGADOR %d...\n", i);
for(j = 0; j < jogadores[i].nDestroyers; ++j)
{
do
{
printf("Entre com as coordenadas (X, Y) da proa (frente) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].destroyers[j].coord_ini.x, &jogadores[i].destroyers[j].coord_ini.y);
printf("Entre com as coordenadas (X, Y) da popa (traseira) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].destroyers[j].coord_fim.x, &jogadores[i].destroyers[j].coord_fim.y);
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].destroyers[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
if(i == 0)
{
system(CLEAR);
imprimeTabuleiro(jogadores[i].tabuleiro, jogadores[i].nLinhas, jogadores[i].nColunas);
}
}
printf("Posicionando patrulhas do JOGADOR %d...\n", i);;
for(j = 0; j < jogadores[i].nPatrulhas; ++j)
{
do
{
printf("Entre com as coordenadas (X, Y) da proa (frente) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].patrulhas[j].coord_ini.x, &jogadores[i].patrulhas[j].coord_ini.y);
printf("Entre com as coordenadas (X, Y) da popa (traseira) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].patrulhas[j].coord_fim.x, &jogadores[i].patrulhas[j].coord_fim.y);
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].patrulhas[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
if(i == 0)
{
system(CLEAR);
imprimeTabuleiro(jogadores[i].tabuleiro, jogadores[i].nLinhas, jogadores[i].nColunas);
}
}
printf("Posicionando porta-avioes do JOGADOR %d...\n", i);
for(j = 0; j < jogadores[i].nPortaAvioes; ++j)
{
do
{
printf("Entre com as coordenadas (X, Y) da proa (frente) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].porta_avioes[j].coord_ini.x, &jogadores[i].porta_avioes[j].coord_ini.y);
printf("Entre com as coordenadas (X, Y) da popa (traseira) do navio seperadas por espaco: ");
scanf("%d %d", &jogadores[i].porta_avioes[j].coord_fim.x, &jogadores[i].porta_avioes[j].coord_fim.y);
}while(posicionaNavio(jogadores[i].tabuleiro, jogadores[i].porta_avioes[j], jogadores[i].nLinhas, jogadores[i].nColunas) == -1);
if(i == 0)
{
system(CLEAR);
imprimeTabuleiro(jogadores[i].tabuleiro, jogadores[i].nLinhas, jogadores[i].nColunas);
}
}
}
}
i = 1;
int controle;
printf("\nO jogo vai comecar!\n");
do
{
++i;
do
{
if(i % NUM_JOGADORES == 0)
{
//system(CLEAR);
//coord_ataque.x = rand() % nLinhas;
//coord_ataque.y = rand() % nColunas;
printf("\n\nTabuleiro dos navios\n");
imprimeTabuleiro(jogadores[JOG_1].tabuleiro, jogadores[JOG_1].nLinhas, jogadores[JOG_1].nColunas);
printf("\n\nMatriz de controle\n");
imprimeMatriz(jogadores[JOG_1].matrizControle, jogadores[JOG_1].nLinhas, jogadores[JOG_1].nColunas);
printf("\n\n");
printf("Digite as coordendas (X, Y) separadas por espaco do seu ataque: ");
scanf("%d %d", &coord_ataque.x, &coord_ataque.y);
printf("\n");
}
else
{
coord_ataque.x = rand() % nLinhas;
coord_ataque.y = rand() % nColunas;
}
printf("Jogador %d:\n", (i % NUM_JOGADORES) + 1);
controle = joga(&jogadores[i % NUM_JOGADORES], &jogadores[(i + 1) % NUM_JOGADORES], coord_ataque);
printf("\n");
}while(controle == -1);
}
while(controle != 0);
if(jogadores[JOG_1].ganhou)
printf("Voce ganhou.\n");
else
printf("Voce perdeu.\n");
// Libera memoria
for(i = 0; i < NUM_JOGADORES; ++i)
{
desalocaDestroyers(jogadores[i].destroyers);
desalocaPatrulhas(jogadores[i].patrulhas);
desalocaPortaAvioes(jogadores[i].porta_avioes);
desalocaMatriz(jogadores[i].matrizControle, jogadores[i].nLinhas, jogadores[i].nColunas);
desalocaTabuleiro(jogadores[i].tabuleiro, jogadores[i].nLinhas, jogadores[i].nColunas);
}
return 0;
}
