/*multiplica duas matrizes e guarda o resultado em uma matriz resultante*/
void multiplica_matrizes(void)
{
Matriz matriz_A = {NULL,1,1}, matriz_B = {NULL,1,1}, matriz_Mult = {NULL,1,1};
ushort i,j,k;
uchar flag = TRUE;
while(flag)
{
ler_matriz(&matriz_A);/*le valores para linha e coluna e aloca memoria para a matriz*/
ler_matriz(&matriz_B);/*le valores para linha e coluna e aloca memoria para a matriz*/
if(matriz_A.col != matriz_B.row)/*verifica se a multiplicaccao e possivel*/
{
printf("\nErro o numero de linhas de colunas de A tem que ser igual ao numero de linhas de B\n");
libera_matriz(matriz_A.address, &(matriz_A.row));/*libera a memoria alocada anteriormente*/
libera_matriz(matriz_B.address, &(matriz_B.row));/*libera a memoria alocada anteriormente*/
}
else
flag = FALSE;
}
preenche_matriz(&matriz_A);/*preenche as entradas da matriz com valores via teclado*/
preenche_matriz(&matriz_B);/*preenche as entradas da matriz com valores via teclado*/
matriz_Mult.row = matriz_A.row;
matriz_Mult.col = matriz_B.col;
matriz_Mult.address = aloca_matriz(&(matriz_Mult.row),&(matriz_Mult.col));/*aloca memoria para a matriz_Mult*/
inicializa_matriz(&matriz_Mult);
for(i = 0; i < matriz_Mult.row; i++)
for(j = 0; j < matriz_Mult.col; j++)
for(k = 0; k < matriz_A.col; k++)/*k < matriz_B->row tambem esta correto*/
*(*(matriz_Mult.address + i) + j) += (*(*(matriz_A.address + i) + k)) * (*(*(matriz_B.address + k) + j));
imprime_matriz(&matriz_A);
imprime_matriz(&matriz_B);
imprime_matriz(&matriz_Mult);
libera_matriz(matriz_A.address,&(matriz_A.row));
libera_matriz(matriz_B.address,&(matriz_B.row));
libera_matriz(matriz_Mult.address,&(matriz_Mult.row));
}
//----------------------------------------------
// Nome: jogar
// Desc: Realiza os principais comandos do jogo
//----------------------------------------------
int jogar()
{
ALLEGRO_BITMAP *botao_ok = al_load_bitmap("images/ok button.jpg"); // Cria e carrega arquivo ok button.jpg
ALLEGRO_BITMAP *botao_start = al_load_bitmap("images/start button.jpg"); // Cria e carrega arquivo start button.jpg
int **matriz; // Para alocação dinâmica de matrizes deve-se criar um ponteiro para ponteiro
int tamanho_matriz = (dificuldade * 10); // Variável criada apenas para melhoria do código
al_clear_to_color(al_map_rgb(255, 255, 255)); // limpa a tela e a pinta toda de branco
al_draw_bitmap(botao_ok, LARGURA_MAX / 1.12, ALTURA_MAX / 1.07, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair
al_draw_bitmap(botao_start, LARGURA_MAX / 1.12, ALTURA_MAX / 1.31, NULL); // Desenha o botão voltar, necessário para poder continuar o programa sem precisar sair
matriz = aloca_matriz(tamanho_matriz); // Chama a função para Alocar a matriz
imprime_matriz(matriz, dificuldade); // Chama a função para desenhar a matriz na tela
escreve_jogar(matriz); // É esta a função que pede para o usuário entrar com os dados do jogo, assim como atualizar a matriz desenhada
libera_matriz(matriz, tamanho_matriz); // Chama a função para liberar a memória ocupada pela matriz
al_destroy_bitmap(botao_ok); // finaliza o BITMAP botao_ok para não ocupar espaço na memória
al_destroy_bitmap(botao_start); // finaliza o BITMAP botao_ok para não ocupar espaço na memória
return 0;
}
/* Execucao */
int main(){
Elemento **matriz; /* Matriz do jogo */
int n_linhas, n_colunas, jogada_i, jogada_j, tmp;
int elementos_revelados=0, total_minas=0, jogadas_validas=0;
char resultado='i', /* Jogador não ganhou nem perdeu */
aux;
scanf("%d %d", &n_colunas, &n_linhas);
matriz=aloca_matriz(n_linhas, n_colunas);
capta(matriz, n_linhas, n_colunas, &total_minas); /* Capta a matriz passada na entrada e conta o total de minas */
contar_bombas_vizinhas(matriz, n_linhas, n_colunas);
aux=getchar();
while(aux!=EOF){ /* Lemos as jogadas validas ate o fim do arquivo */
ungetc(aux, stdin);
scanf("%d %d", &jogada_i, &jogada_j);
tmp = executar_jogada(matriz, n_linhas, n_colunas, jogada_i-1, jogada_j-1);
if(tmp != -1){ /* Nao executa jogadas iguais */
jogadas_validas++;
elementos_revelados = elementos_revelados + tmp; /* Adiciona caracteres revelados na jogada */
if(tmp==0){ /* Jogador perdeu */
resultado='p';
elementos_revelados+=1;
break;
}
if(elementos_revelados+total_minas == n_linhas*n_colunas){ /* "n_linhas*n_colunas" = total de elementos */
resultado='v'; /* Jogador ganhou */
break;
}
}
do{
aux=getchar();
} while (aux=='\n');
}
printf("Minas: %d\n", total_minas);
printf("Jogadas: %d\n", jogadas_validas);
printf("Revelados: %d\n", elementos_revelados);
if(resultado=='v') printf("Resultado: =)\n");
if(resultado=='p') printf("Resultado: =(\n");
if(resultado=='i') printf("Resultado: ?\n");
imprime_matriz(matriz, n_linhas, n_colunas, resultado);
libera_matriz(matriz, n_linhas); /* Libera toda memoria alocada */
return 0;
}
void crea_operador(triangulo * tr, matriz * op)
{
double scale;
matriz C;
matriz InvC;
matriz Cb;
matriz Sxx;
matriz Sxy;
matriz Syy;
inicializa_matriz_c(&C,2);
inicializa_matriz_c(&Cb,2);
inicializa_matriz_c(&InvC,2);
inicializa_matriz_c(&Sxx,3);
inicializa_matriz_c(&Sxy,3);
inicializa_matriz_c(&Syy,3);
C.v[0][0]=tr->v[1][0]-tr->v[0][0];
C.v[0][1]=tr->v[2][0]-tr->v[1][0];
C.v[1][0]=tr->v[1][1]-tr->v[0][1];
C.v[1][1]=tr->v[2][1]-tr->v[1][1];
scale=1.0/(C.v[0][0]*C.v[1][1]-C.v[0][1]*C.v[1][0]);
printf("Matriz afin:\n");
muestra_matriz(&C);
printf("\n");
InvC.v[0][0]= C.v[1][1];
InvC.v[0][1]=-C.v[0][1];
InvC.v[1][0]=-C.v[1][0];
InvC.v[1][1]=C.v[0][0];
escala_matriz(&InvC,scale);
printf("Matriz Inversa:\n");
muestra_matriz(&InvC);
printf("\n");
Cb.v[0][0]=InvC.v[0][0]*InvC.v[0][0]+InvC.v[0][1]*InvC.v[0][1];
Cb.v[0][1]=InvC.v[0][0]*InvC.v[1][0]+InvC.v[0][1]*InvC.v[1][1];
Cb.v[1][0]=InvC.v[1][0]*InvC.v[0][0]+InvC.v[0][1]*InvC.v[1][1];
Cb.v[1][1]=InvC.v[1][0]*InvC.v[1][0]+InvC.v[1][1]*InvC.v[1][1];
muestra_matriz(&Cb);
Sxx.v[1][0]=-1.0;
Sxx.v[1][1]=2.0;
Sxx.v[1][2]=-1.0;
escala_matriz(&Sxx,Cb.v[0][0]);
muestra_matriz(&Sxx);
Sxy.v[0][0]=-1.0;
Sxy.v[0][1]= 1.0;
Sxy.v[1][0]= 1.0;
Sxy.v[1][1]=-2.0;
Sxy.v[1][2]= 1.0;
Sxy.v[2][1]= 1.0;
Sxy.v[2][2]=-1.0;
escala_matriz(&Sxy,0.5*(Cb.v[1][0]+Cb.v[0][1]));
muestra_matriz(&Sxy);
Syy.v[0][1]=-1.0;
Syy.v[1][1]= 2.0;
Syy.v[2][1]=-1.0;
escala_matriz(&Syy,Cb.v[1][1]);
muestra_matriz(&Syy);
suma_matrices(op,&Sxx);
suma_matrices(op,&Sxy);
suma_matrices(op,&Syy);
libera_matriz(&C);
libera_matriz(&Cb);
libera_matriz(&Sxx);
libera_matriz(&Sxy);
libera_matriz(&Syy);
}
void multigrid(malla * u, malla *f, matriz *op, double * max)
{
int i,j;
if(u->nivel==1)
{
/* Escalar el operador al nivel */
matriz op_n;
/* Inicializamos el operador */
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Construimos el sistema a resolver */
double A[3][3];
A[0][0]=op_n.v[1][1];
A[0][1]=op_n.v[2][1];
A[0][2]=op_n.v[2][2];
A[1][0]=op_n.v[0][1];
A[1][1]=op_n.v[1][1];
A[1][2]=op_n.v[1][2];
A[2][0]=op_n.v[0][0];
A[2][1]=op_n.v[1][0];
A[2][2]=op_n.v[1][1];
double B[3];
B[0] = f->v[2][1]-op_n.v[1][2]*u->v[2][2]
-op_n.v[0][1]*u->v[1][1]
-op_n.v[0][0]*u->v[1][0]
-op_n.v[1][0]*u->v[2][0];
B[1] = f->v[3][1]-op_n.v[0][0]*u->v[2][0]
-op_n.v[1][0]*u->v[3][0]
-op_n.v[2][1]*u->v[4][1];
B[2] = f->v[3][2]-op_n.v[0][1]*u->v[2][2]
-op_n.v[1][2]*u->v[3][3]
-op_n.v[2][2]*u->v[4][3]
-op_n.v[2][1]*u->v[4][2];
/* Hacemos eliminación gausiana */
A[1][1]=A[1][1]-A[0][1]*A[1][0]/A[0][0];
A[1][2]=A[1][2]-A[0][2]*A[1][0]/A[0][0];
B[1]=B[1]-B[0]*A[1][0]/A[0][0];
A[2][1]=A[2][1]-A[0][1]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[0][2]*A[2][0]/A[0][0];
B[2]=B[2]-B[0]*A[2][0]/A[0][0];
A[2][2]=A[2][2]-A[1][2]*A[2][1]/A[1][1];
B[2]=B[2]-B[1]*A[2][1]/A[1][1];
/* Resolvemos */
u->v[3][2]=B[2]/A[2][2];
u->v[3][1]=(B[1]-A[1][2]*u->v[3][2])/A[1][1];
u->v[2][1]=(B[0]-A[0][2]*u->v[3][2]-A[0][1]*u->v[3][1])/A[0][0];
}
else
{
/* Escalar el operador al nivel */
matriz op_n;
/* Definicion de las mallas */
malla d; /* Para almacenar el defecto */
malla d_; /* Para almacenar el defecto restringido */
malla v;
malla v_;
/* Inicializacióm mallas*/
inicializa_malla_c(&d,u->nivel);
inicializa_malla_c(&d_,u->nivel-1);
inicializa_malla_c(&v,u->nivel);
inicializa_malla_c(&v_,u->nivel-1);
inicializa_matriz(&op_n,3);
copia_matriz(op,&op_n);
printf("sf=pow(%d,2)",u->dimension-1);
escala_matriz(&op_n,pow((u->dimension-1),2));
/* Suavizado */
muestra_malla(u);
printf("After smooth %f\n ",op_n.v[1][1]);
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
muestra_malla(u);
/* Defecto */
defecto(u,f,&d,&op_n);
printf("After defect %f\n ",op_n.v[1][1]);
muestra_malla(&d);
/* Restringimos */
restringe(&d,&d_);
/* Rellamada a multigrid */
multigrid(&v_,&d_,op,max);
/* Interpolamos */
interpola(&v_,&v);
/* Sumamos */
suma_mallas(u,&v);
/* Postsuavizamos */
suaviza_r(u,f,&op_n);
suaviza_g(u,f,&op_n);
suaviza_b(u,f,&op_n);
/* En la malla mas alta, comprobamos cómo va la cosa */
if(u->nivel==2)
{
/* Calculamos el defecto */
defecto(u,f,&d,&op_n);
for(i=0;i<u->dimension;i++)
{
for(j=0;j<i;j++)
{
if(fabs(d.v[i][j])>max[0])
{
max[0]=fabs(d.v[i][j]);
}
}
}
}
/* Liberacion de recursos */
libera_matriz(&op_n);
libera_malla(&d);
libera_malla(&d_);
libera_malla(&v);
libera_malla(&v_);
}
}
