int main() {
int** minha_matriz = cria_matriz(3, 4);
// | 0 1 2 3
// ___|______________________
// 0 | 12 45 56 5
// 1 | 0 0 -1 17
// 2 | 3 10 0 1
minha_matriz[0][0] = 12;
minha_matriz[0][1] = 45;
minha_matriz[0][2] = 56;
minha_matriz[0][3] = 5;
minha_matriz[1][2] = -1;
minha_matriz[1][3] = 17;
minha_matriz[2][0] = 3;
minha_matriz[2][1] = 10;
minha_matriz[2][3] = 1;
int** matriz_dobro = soma_matrizes(minha_matriz, minha_matriz,
3, 4);
imprime_matriz(minha_matriz, 3, 4);
printf("\n");
imprime_matriz(matriz_dobro, 3, 4);
printf("\n");
return 1;
}
/*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));
}
int main( void )
{
matriz_t *m = matriz_criar( 3, 4 );
printf("\nmatriz criada com sucesso!\n");
m = matriz_incluir_valores("1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1", m);
printf("valores incluidos com sucesso!\n");
imprime_matriz(m);
printf("matriz impressa com sucesso!\n");
matriz_t *mt = matriz_obter_transposta(m);
printf("transposta obtida com sucesso!\n");
imprime_matriz(mt);
printf("matriz impressa com sucesso!\n");
matriz_destruir(m);
printf("matriz destruida com sucesso!\n");
exit( EXIT_SUCCESS );
}
int main(int argc, char **argv) {
// Verificando quantidade de arquivos na chamada de execução no terminal.
if (argc != 3) {
printf("ERROR!\nQuantidade de arquivos diferente do esperado.\n");
} else {
Mat *matrizA = NULL;
Mat *matrizB = NULL;
Mat *matrizC = NULL;
matrizA = busca_arquivo(matrizA, argv[1]);
matrizB = busca_arquivo(matrizB, argv[2]);
matrizC = soma_matriz(matrizA, matrizB);
desaloca_matriz(matrizA);
desaloca_matriz(matrizB);
imprime_matriz(matrizC);
desaloca_matriz(matrizC);
}
return 0;
}
//----------------------------------------------
// 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;
}
// impressao em tabela
// * mat = ponteiro para a primeira posicao da matriz
// n = numero de elementos totais na matriz
// m = tamanho de uma coluna
void imprime_matriz(int * mat, int n, int m){
if (n == 0)
return;
imprime_matriz(mat, --n, m);
if ((n % m) == 0)
putchar('\n');
printf("%d ", *(mat+n));
}
int main(void) {
menu();
inicializa_matriz();
imprime_matriz();
printf("\n");
return 0;
}
int main(int argc, char * argv[]){
int ** matriz;
int n, m, i, j, k;
if (argc < 2)
{
printf("Usage: %s [N] [M] [num1] [num2] ... [num(N*M)]\n", \
argv[0]);
return(EXIT_SUCCESS);
}
n = atoi(argv[1]);
m = atoi(argv[2]);
if (argc != (n*m + 3))
{
printf("Usage: %s [N] [M] [num1] [num2] ... [num(N*M)]\n", \
argv[0]);
return(EXIT_SUCCESS);
}
matriz = (int ** )malloc(sizeof(int *) * n + ((sizeof(int) * m)*n));
int *data = (int*) (matriz + n);
printf("Matriz lida: \n");
for (i=0; i<n; i++){
matriz[i] = data + i * n;
}
k = 0;
for (i=0; i<m; i++){
for (j=0; j<n; j++){
matriz[i][j]= atoi(argv[k+3]);
k++;
}
}
putchar('\n');
for (i=0; i<m; i++){
for (j=0; j<n; j++){
printf("%d ", matriz[i][j]);
}
putchar('\n');
}
imprime_matriz(&matriz[0][0], n*m, n);
putchar('\n');
printf("Soma da matriz: %d \n", soma_matriz(*matriz, n*m));
putchar('\n');
printf("Maior da matriz: %d \n", maior_matriz(*matriz, n*m));
putchar('\n');
printf("Menor da matriz: %d \n", menor_matriz(*matriz, n*m));
putchar('\n');
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;
}
int EXECUTA_COMPILADOR(char texto[]){
int tamanho, resultado, cont_mensagem=0, comando_valido=0;
char mensagem[TAM][TAM], comando[TAM][TAM];
executavel programa[TAM];
//1. Análise Léxica
resultado = analise_lexica(texto, comando, mensagem[0]);
//imprime_string(texto);
if(resultado == -1){
tamanho = retorna_tamanho_matriz(mensagem);
imprime_matriz(mensagem, tamanho);
}
else{
tamanho = retorna_tamanho_matriz(comando);
imprime_matriz(comando, tamanho);
//printf("%s\n",comando[0]);
//2. Análise Sintática
resultado = analise_sintatica(comando, mensagem, &cont_mensagem);
if(resultado == 0){
printf("\nComando válido! Parabéns meu!!!\n");
comando_valido = 1;
}
else{
printf("\nErro de Compilação!\n");
tamanho = retorna_tamanho_matriz(mensagem);
imprime_matriz(mensagem, tamanho);
comando_valido = 0;
}
}
//3. Análise Semântica
if(comando_valido)
analise_semantica(comando, programa);
return 0;
}
int main(void){
int n;
printf("Digite o tamanho da matriz: ");
scanf("%d",&n);
int **m = cria_matriz(n);
le_matriz(m,n);
imprime_matriz(m,n);
exercicio_a(m,n,3);
exercicio_b(m,n);
exercicio_c(m,n,3);
exercicio_c(m,n,1);
exercicio_d(m,n);
return 0;
}
int main() {
int m[MAXLINHA][MAXCOLUNA], linhas, colunas, maiorValor;
int c_m[MAXLINHA][MAXCOLUNA], c_linhas, c_colunas, c_maiorValor;
char nome_arquivo[MAX_NAME], c_nome_arquivo[MAX_NAME], complemento[MAX_NAME], menu = '9';
int a, b, c, d, t = 0, index_char;
printf("Digite o nome do arquivo de entrada: ");
scanf("%s", nome_arquivo);
while (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 0) {
printf("Digite o nome do arquivo de entrada: ");
scanf("%s", nome_arquivo);
}
printf("Arquivo %s.pgm carregado com sucesso.\n", nome_arquivo);
imprime_menu();
while(menu != 's') {
if (menu == 'c') {
printf("Digite o nome do arquivo de entrada: ");
scanf("%s", nome_arquivo);
if (le_pgm(nome_arquivo, m, &linhas, &colunas, &maiorValor) == 1) {
t = 0;
printf("Arquivo %s.pgm carregado com sucesso.\n\n", nome_arquivo);
} else return 0;
} else if (menu == 'a') {
imprime_menu();
} else if (menu == 't') {
imprime_matriz(m, linhas, colunas);
} else if (menu == 'n') {
negativo(m, linhas, colunas);
complemento[t++] = 'n';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'r') {
rotacao(m, &linhas, &colunas);
complemento[t++] = 'r';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'v') {
rebatimentoVertical(m, linhas, colunas);
complemento[t++] = 'v';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'h') {
rebatimentoHorizontal(m, linhas, colunas);
complemento[t++] = 'h';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'x') {
printf("Informe x superior: ");
scanf("%d", &a);
printf("Informe y superior: ");
scanf("%d", &b);
printf("Informe x inferior: ");
scanf("%d", &c);
printf("Informe y inferior: ");
scanf("%d", &d);
if (a < 0 || b < 0 || c > (linhas - 1) || d > (colunas - 1) || a > c || b > d) {
printf("Limites invalidos\n\n");
} else {
corte(m, &linhas, &colunas, a, b, c, d);
complemento[t++] = 'x';
printf("Operacao realizada com sucesso.\n");
}
} else if (menu == 'e') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
filtroErosao(m, linhas, colunas, a);
complemento[t++] = 'e';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'd') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
filtroDilatacao(m, linhas, colunas, a);
complemento[t++] = 'd';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'm') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
filtroMediana(m, linhas, colunas, a);
complemento[t++] = 'm';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'z') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
filtroMedia(m, linhas, colunas, a);
complemento[t++] = 'z';
printf("Operacao realizada com sucesso.\n");
} else if (menu == '1') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
printf("Informe o valor de k: ");
scanf("%d", &b);
filtroBorda1(m, linhas, colunas, a, b);
complemento[t++] = '1';
printf("Operacao realizada com sucesso.\n");
} else if (menu == '2') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
printf("Informe o valor de k: ");
scanf("%d", &b);
filtroBorda2(m, linhas, colunas, a, b);
complemento[t++] = '2';
printf("Operacao realizada com sucesso.\n");
} else if (menu == '3') {
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
while(a < 3 || a > 50) {
printf("Tamanho invalido. A janela deve ser entre 3 e 50.\n");
printf("Digite o tamanho da janela: ");
scanf("%d", &a);
}
printf("Informe o valor de k: ");
scanf("%d", &b);
filtroBorda3(m, linhas, colunas, a, b);
complemento[t++] = '3';
printf("Operacao realizada com sucesso.\n");
} else if (menu == 'g') {
for(index_char = 0; nome_arquivo[index_char] != 0; index_char++) {
c_nome_arquivo[index_char] = nome_arquivo[index_char];
}
if (t > 0)
c_nome_arquivo[index_char++] = '-';
for(a = 0; a < t; a++)
c_nome_arquivo[index_char++] = complemento[a];
while(c_nome_arquivo[index_char] != 0)
c_nome_arquivo[index_char++] = 0;
grava_pgm(c_nome_arquivo, m, linhas, colunas, maiorValor);
printf("%s.pgm\nArquivo %s.pgm gravado com sucesso.\n", c_nome_arquivo, c_nome_arquivo);
} else if (menu == 'C') {
printf("Digite o nome do arquivo para comparacao: \n");
scanf("%s", c_nome_arquivo);
if (le_pgm(c_nome_arquivo, c_m, &c_linhas, &c_colunas, &c_maiorValor) == 1) {
if (c_linhas != linhas || c_colunas != colunas) {
printf("As matrizes tem dimensoes diferentes.\n");
} else {
/* Compara valor a valor e verifica se é igual ou diferente */
c = 1;
for(a = 0; a < linhas; a++) {
for(b = 0; b < colunas; b++) {
if (m[a][b] != c_m[a][b]) {
c = 0;
break;
}
}
if (c == 0) break;
}
if (c == 0) printf("As matrizes tem dimensoes diferentes.\n");
else printf("As matrizes sao iguais.\n");
}
} else {
printf("Falha ao carregar arquivo %s.pgm de comparacao.\n", c_nome_arquivo);
}
} else if (menu != '9') {
printf("Comando invalido\n");
}
printf("Digite um comando: ");
scanf(" %c", &menu);
}
return 0;
}
void adiciona_voo_aux(int test) {
int validade_1_id = 0, validade_2_id = 0, existe_1_id = 0, existe_2_id = 0, ocupacao_1_id = 0, ocupacao_2_id, k = 0, v = 0;
char i[4] = "\0", j[4] = "\0";
validade_1_id = le_id(i);
validade_2_id = le_id2(j);
if(validade_1_id == 0 && validade_2_id == 0){
existe_1_id = verifica_id(i);
existe_2_id = verifica_id(j);
if(existe_1_id == 0 && existe_2_id == 0){
ocupacao_1_id = ocupacao_aeroporto(i);
ocupacao_2_id = ocupacao_aeroporto(j);
for(k = 0; k < contador_aeroportos; k++){
for(v = 0; v < contador_aeroportos; v++){
if((strcmp(airport[k].id, i) == 0) && (strcmp(airport[v].id, j) == 0) ){
if(airport[k].state == 1 || airport[v].state == 1){
if(test == 3){
if((ocupacao_1_id + 2 <= airport[k].capacity) && (ocupacao_2_id + 2 <= airport[v].capacity)){
matriz[k][v] += 1;
matriz[v][k] += 1;
}
else{
erro_auxiliar(test,i,j);
}
break;
}
if(test == 2){
if((ocupacao_1_id + 1 <= airport[k].capacity) && (ocupacao_2_id + 1 <= airport[v].capacity)){
matriz[k][v] += 1;
}
else{
erro_auxiliar(test,i,j);
}
break;
}
if(test == 1){
if(matriz[k][v] > 0){
matriz[k][v] -= 1;
}
else{
erro_auxiliar(test,i,j);
}
break;
}
if(test == 0){
if((matriz[k][v] > 0) && (matriz[v][k])){
matriz[k][v] -= 1;
matriz[v][k] -= 1;
}
else{
erro_auxiliar(test,i,j);
}
break;
}
break;
}
else{
erro_auxiliar(test,i,j);
}
}/*este if nao falha, apenas está aqui para "salvar" os indices*/
}/*END OF FOR*/
}/*END OF FOR*/
}
}else{
erro_auxiliar(test,i,j);
}/*
}else{
erro_auxiliar(test,i,j);
} este else não faz parte das veriicaçoes obrigatorias*/
#if DEBUG
imprime_matriz();
#endif
}
//----------------------------------------------
// Nome: escreve_jogar
// Desc: Esta função pede ao usuário as posições de tudo que é necessário para a execução do jogo
//----------------------------------------------
void escreve_jogar(int **matriz)
{
// Esse vetor de (char *) foi criado para diminuir a quantidade de código (basicamente: if) da função. O vetor depende da dificuldade
char *texto_inicial[5] = {"A dificuldade 1 consiste em escolher:",
"A dificuldade 2 consiste em escolher:",
"A dificuldade 3 consiste em escolher:",
"A dificuldade 4 consiste em escolher:",
"A dificuldade 5 consiste em escolher:"};
// Esse vetor de (char *) foi criado para diminuir a quantidade de código (basicamente: if) da função. O vetor depende da dificuldade
char *bonus = {"> O Bonus"};
ALLEGRO_FONT *fonte_jogar = al_load_font("fonts/AGENCYB.TTF", 14, 0); // Carrega o arquivo de fonte
bool parar_obstaculos = false;
// A seguinte variável foi criada para facilitar a leitura do código do programa
int tamanho_matriz = dificuldade * 10;
//
// As seguintes variáveis foram criadas para converter as coordenadas do mouse e armazenar as nas células da matriz
//
int pos_x;
int pos_y;
int linha_inicial;
int coluna_inicial;
int linha_final;
int coluna_final;
int linha_alvo;
int coluna_alvo;
int linha_obstaculo;
int coluna_obstaculo;
int linha_bonus;
int coluna_bonus;
int custo_total;
int custo_aux;
int custo_aux2;
//
// Fim da declaração das variáveis
//
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), LARGURA_MAX / 2, 310, ALLEGRO_ALIGN_CENTRE, texto_inicial[dificuldade - 1]); // Escreve o texto central
//
// As seguintes funções escrevem no espaço determinado o que tem que ser escolhido pelo usuário
//
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 20, 340, NULL, "> A Posicao Inicial");
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 20, 375, NULL, "> A Posicao Final");
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 250, 340, NULL, "> Obstaculo (ENTER para cancelar)");
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 0), 250, 375, NULL, bonus);
//
// Fim das funções que escrevem as escolhas necessárias
//
al_flip_display(); // Atualiza a tela
// Caso a opção de existir labirinto seja verdadeira
if (labirinto == true)
{
matriz = carrega_labirinto(dificuldade); // Chama a função responsável por gerar, aleatoriamente, um labirinto perfeito
imprime_matriz(matriz, dificuldade); // Imprime o labirinto no espaço reservado
al_flip_display(); // Atualiza tela
}
//
// ----------------------------------------------------------------------------------------
// O seguinte do while é utilizado para que o usuário entre com a posição inicial do jogo
// ----------------------------------------------------------------------------------------
//
// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição inicial válida
do
{
pos_x = 0; // Zera a variável
pos_y = 0; // Zera a variável
al_draw_text(fonte_jogar, al_map_rgb(255, 0, 0), 20, 340, NULL, "> A Posicao Inicial"); // Pinta o texto para melhor visualização
al_flip_display(); // Atualiza a tela
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
{
if (ev.mouse.button & 1)
{
// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
pos_x = pos_x_mouse;
pos_y = pos_y_mouse;
if (pos_y <= 300)
{
coluna_inicial = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna
// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
if (dificuldade == 4)
linha_inicial = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha
else
linha_inicial = (pos_y * tamanho_matriz ) / 300; // Converte a coordenada do mouse em linha
// Determina a posição inicial e atualiza a matriz
if (matriz[linha_inicial][coluna_inicial] != PAREDE)
{
matriz[linha_inicial][coluna_inicial] = POS_INICIAL;
imprime_matriz(matriz, dificuldade);
}
}
}
}
} while ( (pos_y >= 300) || (pos_y == 0) || (matriz[linha_inicial][coluna_inicial] == PAREDE) );
//
// --------------------------------------------------------------------------------------
// O seguinte do while é utilizado para que o usuário entre com a posição final do jogo
// --------------------------------------------------------------------------------------
//
// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição final válida
do
{
pos_x = 0; // Zera variável
pos_y = 0; // Zera variável
al_draw_text(fonte_jogar, al_map_rgb(0, 0, 255), 20, 375, NULL, "> A Posicao Final"); // Pinta o texto para melhor visualização
al_flip_display(); // Atualiza tela
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
{
if (ev.mouse.button & 1)
{
// quando o usuário clicar com o borão esquerdo do mouse as coordenadas serão armazenadas em variáveis
pos_x = pos_x_mouse;
pos_y = pos_y_mouse;
if (pos_y <= 300)
{
coluna_final = (pos_x * tamanho_matriz ) / 600; // Converte a coordenada do mouse em coluna
// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
if (dificuldade == 4)
linha_final = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha
else
linha_final = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha
// Determina a posição final e atualiza a matriz
if ( ( (linha_final != linha_inicial) || (coluna_final != coluna_inicial) ) && (matriz[linha_final][coluna_final] != PAREDE) )
{
matriz[linha_final][coluna_final] = POS_FINAL;
imprime_matriz(matriz, dificuldade);
}
}
}
}
} while ( (pos_y >= 300) || (pos_y == 0) || ( (linha_final == linha_inicial) && (coluna_final == coluna_inicial) ) || (matriz[linha_final][coluna_final] == PAREDE) );
//
// ----------------------------------------------------------------------------------------
// O seguinte do while é utilizado para que o usuário entre com a posição do alvo do jogo
// ----------------------------------------------------------------------------------------
//
// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição válida
do
{
pos_x = 0; // Zera variável
pos_y = 0; // Zera variável
//*******al_draw_text(fonte_jogar, al_map_rgb(0, 0, 255), 20, 375, NULL, "> A Posicao Final"); // Pinta o texto para melhor visualização
al_flip_display(); // Atualiza tela
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
{
if (ev.mouse.button & 1)
{
// quando o usuário clicar com o borão esquerdo do mouse as coordenadas serão armazenadas em variáveis
pos_x = pos_x_mouse;
pos_y = pos_y_mouse;
if (pos_y <= 300)
{
coluna_alvo = (pos_x * tamanho_matriz ) / 600; // Converte a coordenada do mouse em coluna
// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
if (dificuldade == 4)
linha_alvo = (pos_y * tamanho_matriz ) / 280; // Converte a coordenada do mouse em linha
else
linha_alvo = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha
// Determina a posição do alvo e atualiza a matriz
if ( ( (linha_alvo != linha_inicial) || (coluna_alvo != coluna_inicial) ) || ( (linha_alvo != linha_final) || (coluna_alvo != coluna_final) ) && (matriz[linha_alvo][coluna_alvo] != PAREDE) )
{
matriz[linha_alvo][coluna_alvo] = ALVO;
imprime_matriz(matriz, dificuldade);
}
}
}
}
} while ( (pos_y >= 300) || (pos_y == 0) || ( (linha_alvo == linha_inicial) && (coluna_alvo == coluna_inicial) ) || ( (linha_alvo == linha_final) && (coluna_alvo == coluna_final) ) || (matriz[linha_alvo][coluna_alvo] == PAREDE) );
//
// ------------------------------------------------------------------------------------------
// O seguinte for é utilizado para que o usuário entre com a posição dos obstáculos do jogo
// ------------------------------------------------------------------------------------------
//
// O seguinte bloco de comando será executado até que o usuário digite ENTER (para cancelar a entrada de obstáculos)
do
{
pos_x = 0; // Zera variável
pos_y = 0; // Zera variável
al_draw_text(fonte_jogar, al_map_rgb(255, 165, 0), 250, 340, NULL, "> Obstaculo (ENTER para cancelar)"); // Pinta o texto para melhor visualização
al_flip_display(); // Atualiza tela
// O seguinte bloco de comando só será executado caso a opção obstaculo esteja habilitada
if (obstaculo == true)
{
// O seguinte bloco de comando é executado enquanto o usuário não digita uma posição válida para o obstáculo
do
{
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
// O seguinte bloco de comando será executado caso o usuário entre com a tecla ENTER
if (ev.type == ALLEGRO_EVENT_KEY_DOWN)
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_ENTER:
parar_obstaculos = true;
break;
}
// O seguinte break é necessário para que, ao apertar a tecla ENTER, o usuário não precise entrar com mais um obstáculo
break;
}
if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
{
if (ev.mouse.button & 1)
{
// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
pos_x = pos_x_mouse;
pos_y = pos_y_mouse;
}
if (pos_y <= 300)
{
coluna_obstaculo = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna
// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
if (dificuldade == 4)
linha_obstaculo = (pos_y * tamanho_matriz) / 280; // Converte a coordenada do mouse em linha
else
linha_obstaculo = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha
// Determina a posição dos obstáculos e atualiza a matriz
if ( ( ( (linha_obstaculo != linha_inicial) || (coluna_obstaculo != coluna_inicial) ) && ( (linha_obstaculo != linha_final) || (coluna_obstaculo != coluna_final) ) && ( (linha_obstaculo != linha_alvo) || (coluna_obstaculo != coluna_alvo) ) ) && (matriz[linha_obstaculo][coluna_obstaculo] != PAREDE) )
{
if (matriz[linha_obstaculo][coluna_obstaculo] != OBSTACULO)
matriz[linha_obstaculo][coluna_obstaculo] = OBSTACULO;
else if (matriz[linha_obstaculo][coluna_obstaculo] == OBSTACULO)
matriz[linha_obstaculo][coluna_obstaculo] = CAMPO_VAZIO;
imprime_matriz(matriz, dificuldade);
}
}
}
} while( (pos_y >= 300) || (pos_y == 0) || ( (linha_obstaculo == linha_inicial) && (coluna_obstaculo == coluna_inicial) ) || ( (linha_obstaculo == linha_final) && (coluna_obstaculo == coluna_final) ) || (matriz[linha_obstaculo][coluna_obstaculo] == PAREDE) );
}
// Sai do bloco de comandos caso a opção obstaculo esteja desabilitada
else
break;
} while (parar_obstaculos == false);
//
// -------------------------------------------------------------------------------------
// O seguinte for é utilizado para que o usuário entre com a posição dos bônus do jogo
// -------------------------------------------------------------------------------------
//
// O seguinte bloco de comando será executado até que o usuário entre com o número correto de bônus
do
{
pos_x = 0; // Zera variável
pos_y = 0; // Zera variável
al_draw_text(fonte_jogar, al_map_rgb(0, 186, 255), 250, 375, NULL, bonus); // Pinta o texto para melhor visualização
al_flip_display(); // Atualiza tela
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
if (ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Ativa quando o usuário clicar com algum botão do mouse
{
if (ev.mouse.button & 1)
{
// quando o usuário clicar com o botão esquerdo do mouse as coordenadas serão armazenadas em variáveis
pos_x = pos_x_mouse;
pos_y = pos_y_mouse;
}
if (pos_y <= 300)
{
coluna_bonus = (pos_x * tamanho_matriz) / 600; // Converte a coordenada do mouse em coluna
// Precisa ser verificado o nível de dificuldade 4, pois o tamanho correto seria 15x7.5 px, mas não é possível
if (dificuldade == 4)
linha_bonus = (pos_y * tamanho_matriz) / 280; // Converte a coordenada do mouse em linha
else
linha_bonus = (pos_y * tamanho_matriz) / 300; // Converte a coordenada do mouse em linha
// Determina a posição dos bônus e atualiza a matriz
if ( ( ( ( (linha_bonus != linha_inicial) || (coluna_bonus != coluna_inicial) ) && ( (linha_bonus != linha_final) || (coluna_bonus != coluna_final) ) && ( (linha_bonus != linha_alvo) || (coluna_bonus != coluna_alvo) ) ) && (matriz[linha_bonus][coluna_bonus] != PAREDE) ) )
{
matriz[linha_bonus][coluna_bonus] = BONUS;
imprime_matriz(matriz, dificuldade);
}
}
}
} while( (pos_y >= 300) || (pos_y == 0) || ( (linha_bonus == linha_inicial) && (coluna_bonus == coluna_inicial) ) || ( (linha_bonus == linha_final) && (coluna_bonus == coluna_final) ) || ( (linha_bonus == linha_alvo) && (coluna_bonus == coluna_alvo) ) || ( (matriz[linha_bonus][coluna_bonus] == PAREDE) ) );
// O próximo bloco de comandos será realizado até que a variável fechar seja igual a true
do
{
al_flip_display(); // Atualiza a tela
inicializa_evento(); // Função utilizada para melhorar o programa em termos de visualização de código
if(ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) // Quando o usuário apertar algum botão do mouse
{
if((ev.mouse.button & 1) && (pos_x_mouse >= 536) && (pos_x_mouse <= 595) && (pos_y_mouse >= 374) && (pos_y_mouse <= 393))
break; // Volta para o menu principal Caso seja selecionado o botão "VOLTAR"
else if((ev.mouse.button & 1) && (pos_x_mouse >= 536) && (pos_x_mouse <= 595) && (pos_y_mouse >= 306) && (pos_y_mouse <= 325))
{
custo_total = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_final, coluna_final, false); // Caso seja selecionado o botão "INICIAR"
custo_aux = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_bonus, coluna_bonus, false) + procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_final, coluna_final, false) - (BONUS * 10 * dificuldade);
custo_aux2 = procura_caminho(tamanho_matriz, matriz, linha_inicial, coluna_inicial, linha_bonus, coluna_bonus, false) + procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_alvo, coluna_alvo, false) + procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_final, coluna_final, false) - (BONUS * 10 * dificuldade);
}
if ( (custo_total <= custo_aux) && (custo_total <= custo_aux2) )
{
procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_inicial, coluna_inicial, true);
procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_alvo, coluna_alvo, true);
}
else if ( (custo_aux <= custo_total) && (custo_aux <= custo_aux2) )
{
procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_inicial, coluna_inicial, true);
procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_alvo, coluna_alvo, true);
procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_bonus, coluna_bonus, true);
}
else
{
procura_caminho(tamanho_matriz, matriz, linha_bonus, coluna_bonus, linha_inicial, coluna_inicial, true);
procura_caminho(tamanho_matriz, matriz, linha_alvo, coluna_alvo, linha_bonus, coluna_bonus, true);
procura_caminho(tamanho_matriz, matriz, linha_final, coluna_final, linha_alvo, coluna_alvo, true);
}
}
} while(!fechar);
al_destroy_font(fonte_jogar); // Finaliza a fonte
}
int main()
{
char acao;
num_matriz k, k1, k2, k3;
int m, n, i, j;
float x;
matriz a[num_nomes];
while (true)
{
scanf("%c", &acao);
printf("ação: %c", acao);
switch (acao)
{
case 'r':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
le_matriz(&a[k]);
break;
case 'z':
le_nome(&k); scanf("%d %d", &m, &n); prox_linha();
printf(" %c %d %d\n", min_nome+k, m, n);
inicializa(&a[k], m, n);
break;
case 'v':
le_nome(&k); scanf("%d %d", &i, &j); prox_linha();
printf(" %c %d %d\n", min_nome+k, i, j);
printf(" %c[%d,%d] = %8.2f\n", min_nome+k, i, j, valor(&(a[k]), i, j));
break;
case 'a':
le_nome(&k); scanf("%d %d %f", &i, &j, &x); prox_linha();
printf(" %c %2d %2d %8.2f\n", min_nome+k, i, j, x);
atribui(&a[k], i, j, x);
break;
case 's':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
soma(&a[k1], &a[k2], &a[k3]);
break;
case 'm':
le_nome(&k1); le_nome(&k2); le_nome(&k3); prox_linha();
printf(" %c %c %c\n", min_nome+k1, min_nome+k2, min_nome+k3);
multiplica(&a[k1], &a[k2], &a[k3]);
break;
case 't':
le_nome(&k1); le_nome(&k2); prox_linha();
printf(" %c %c\n", min_nome+k1, min_nome+k2);
transpoe(&a[k1], &a[k2]);
break;
case 'w':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
imprime_matriz(&a[k]);
break;
case 'x':
printf("\n");
bapply(bprint);
printf("fim da execução.\n");
exit(0);
break;
case '#':
{ int c;
do
{ c = getchar(); putchar(c); }
while ((c != '\n') && (c != EOF));
}
break;
case 'l':
le_nome(&k); prox_linha();
printf(" %c\n", min_nome+k);
libera(&a[k]);
break;
default:
{ erro("ação inválida"); }
} /* switch */
} /* while */
bapply(bprint);
return 0;
} /* main */
