matriz *multiplicaEscalar(matriz *m,float k)
{
matriz *resultado;
int i,j;
resultado=alocaMatriz(m->linhas,m->colunas);
if(resultado==NULL)
{
return NULL;
}
resultado->linhas=m->linhas;
resultado->colunas=m->colunas;
if(k==0)
return resultado;
for(i=0;i<(resultado->linhas);i++)
{
for(j=0;j<(resultado->colunas);j++)
{
resultado->valores[i][j]=m->valores[i][j]*k;
}
}
return resultado;
}
matriz *multiplicaMatriz(matriz* m1, matriz* m2)
{
matriz *result;
int i,j,k;
result = alocaMatriz(m1->linhas, m2->colunas);
if(m1->colunas != m2->linhas)
{
result->linhas=0;
result->colunas=0;
return result;
}
for(i=0;i<m1->linhas;i++)
{
for(j=0;j<m2->colunas;j++)
{
result->valores[i][j] = 0;
for(k=0;k<m1->colunas;k++)
result->valores[i][j] = result->valores[i][j] + m1->valores[i][k] * m2->valores[k][j];
}
}
result->linhas = m1->linhas;
result->colunas = m2->colunas;
return result;
}
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;
}
int main(int argc, char const *argv[]) {
int linha, coluna, i, j;
int **n0, **n1;
char controle = 'a';
char output[10] = "saida.txt";
FILE *entrada;
entrada = fopen("dados.txt", "r");
if (entrada == NULL) {
printf("Erro de abertura do arquivo.\n");
return -1;
}
fscanf(entrada, "%d %d", &linha, &coluna);
alocaMatriz(&n0, linha, coluna);
alocaMatriz(&n1, linha, coluna);
for (i = 0; i < linha; i++) {
for (j = 0; j < coluna; j++) {
fscanf(entrada, "%d", &n0[i][j]);
}
}
fclose(entrada);
while (toupper(controle) != 'N') {
system("clear");
imprimeMatriz(n0, linha, coluna);
printf("Você gostaria de continuar executando a evolução das "
"gerações?\nDigite 's' se gostaria e 'n' se não gostaria.\n");
scanf(" %c", &controle);
if (toupper(controle) == 'S') {
novaGeracao(n0, n1, linha, coluna);
copiaMatriz(n0, n1, linha, coluna);
}
}
imprimeConway(output, linha, coluna, n0);
liberaMatriz(n0, linha);
liberaMatriz(n1, linha);
return 0;
}
/**
* Função responsável por ler o tabuleiro de entrada segundo
* o formato definido na especificação do EP. Em caso de entrada
* malformatada o programa encerra imediatamente. Se a entrada é
* válida retorna um ponteiro para o estado inicial do jogo
* (Tabuleiro intacto) senão retorna NULL.
*/
estado* leJogoEntrada(jogo *oJogo){
int i, j, k, conteudo;
estado *inicial = alocaEstado(0);
if(scanf("%d %d", &(oJogo->l), &(oJogo->c)) != 2 ||
oJogo->l <= 0 || oJogo->c <= 0)
return NULL;
oJogo->obj = alocaMatriz(oJogo->l, oJogo->c);
inicial->tabuleiro = alocaMatriz(oJogo->l, oJogo->c);
for (k = 0; k < oJogo->l * oJogo->c; k++) {
if(scanf("%d %d %d", &i, &j, &conteudo) != 3)
return NULL;
inicial->tabuleiro[i][j] = conteudo;
oJogo->obj[i][j] = conteudo == 0 ? 0 : -conteudo;
oJogo->maxMov += conteudo;
}
return inicial;
}
matriz *transpor(matriz *m)
{
matriz *transposta;
int i,j;
transposta=alocaMatriz(m->linhas,m->colunas);
if(transposta==NULL)
{
return NULL;
}
transposta->linhas=m->linhas;
transposta->colunas=m->colunas;
for(i=0;i<(transposta->linhas);i++)
{
for(j=0;j<(transposta->colunas);j++)
transposta->valores[i][j]=m->valores[j][i];
}
return transposta;
}
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");
}
}
matriz *recebeTeclado()
{
int i,j,lin,col;
matriz *m;
printf("Numero de linhas: ");
scanf("%d",&lin);
printf("Numero de colunas: ");
scanf("%d",&col);
m=alocaMatriz(lin,col);
m->linhas=lin;
m->colunas=col;
for(i=0;i<m->linhas;i++)
{
for(j=0;j<m->colunas;j++)
scanf("%f",&m->valores[i][j]);
}
return m;
}
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;
}
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;
}
