Labirinto em C(usando Modularização)

Na Facudade fiz um projeto de um labirinto em C usuando Tipo Abstrado de Dados.

#####################################################

#include <stdio.h>
#include <stdlib.h>
#include “tadlabirinto.h”
/*Modulo principal*/
int main(int argc, char *argv[])
{
int i;
matriz m;
pilha p;
posicao pos,npos,e,linha,coluna,v,coordenada;
/*Função carrega a matriz de um arquivo txt*/
carregamatriz(&m);
/*Esse passo do prgrama empilha ou desempilha de acordo com acondição*/
while((pos.x<m.p.x-1)&&(pos.y<m.p.y-1))
{
m.labirinto[pos.x][pos.y]=2;//coloca dois na posição já caminhada
imprime(m);
sleep(500);
system(“cls”);
npos=verifica(&m,&e);
if (npos.x!=-1)
{
empilha (&p,pos);
pos=npos;
}
else
{
pos=desempilha(&p);
npos=verifica(&m,&pos);
if (npos.x!=-1)
{
empilha (&p,npos);
pos=npos;
}
}
}
printf(“||||GAME OVER:ACHOU A SAIDA||||\n\n\a”);
while(!pilhavazia(p))
{

v=desempilha(&p);
printf(“As coordenadas:%d%d\n\n”,v.x,v.y);
}

system(“PAUSE”);
}

######################################################

######################################################
#include <stdio.h>
#include <stdlib.h>
#include “tadpilha.h”
/*INICIALIZA A PILHA COM -1*/
void inicializapilha(pilha *p)
{
p->topo=-1;
}
/*PILHA VAZIA*/
int pilhavazia(pilha p)
{
if(p.topo==-1)
{
return(true);
}
else
{
return(false);
}
}
/*PILHA CHEIA*/
int pilhacheia(pilha p)
{
if(p.topo==MAX)
{
return(true);
}
else
{
return(false);
}
}
/*EMPILHA*/
void empilha(pilha *p,posicao e)
{
if((pilhacheia(*p)==false))
{
p->topo++;
p->itens[p->topo]=e;
}
else
{
printf(“PILHA CHEIA\n”);
}
}

/*DESEMPILHA*/
posicao desempilha(pilha *p)
{
posicao aux;
if(pilhavazia(*p)==false)
{
aux=p->itens[p->topo];
p->topo–;
}
else
{
printf(“PILHA VAZIA\n”);
}
return aux;
}
/*Mostra as posições desempilhada*/
void mostrapilha(pilha p,posicao e)
{

if(pilhavazia(p)==false)
{
printf(“As posicoes empilha:%d%d\n”,p.itens[p.topo]);
}
else
printf(“Pilha VAZIA\n”);
}

######################################################

######################################################
#define MAX 100
#define true 1
#define false 0
/*Estrutura do tipo posição*/
typedef struct
{
int x;
int y;
}posicao;
/*Estrutura do tipo pilha*/
typedef struct
{
int topo;
posicao itens[MAX];
}pilha;
/*Cabe�ario das fun��es*/
void inicializapilha(pilha *);
int pilhavazia(pilha );
int pilhacheia(pilha);
void empilha(pilha *,posicao);
posicao desempilha(pilha *);
void mostrapilha(pilha, posicao );

######################################################

######################################################
#include <stdio.h>
#include <stdlib.h>
#include “tadlabirinto.h”
/*Função que carrega a matriz*/
void carregamatriz(matriz *m){
int linhas,colunas,l,c;
int caracter;
FILE *arquivo;//ponteiro para o arquivo
if((arquivo = fopen(“labirinto.txt”,”r”)) == NULL)
{
printf(“Erro ao abrir arquivo labirinto.txt!!!\n”);
exit(1);
}
else
{
fscanf(arquivo,”%d”,&linhas);
fscanf(arquivo,”%d”,&colunas);
m->p.x=linhas;
m->p.y=colunas;
for(l=0;l<linhas;l++)
{
for(c=0;c<colunas;c++)
{
fscanf(arquivo,”%d”,&caracter);
m->labirinto[l][c]=caracter;
}
}
}
fclose(arquivo);
}
/*Imprime a matriz[N][N] contida no arquivo*/
void imprime(matriz m){
int l,c;
for(l=0;l<m.p.x;l++)
{
for(c=0;c<m.p.y;c++)
{
if (m.labirinto[l][c] == 2) {
printf(“©”);
continue;
}
if (m.labirinto[l][c] == 1){
printf(” “);
}
if (m.labirinto[l][c] == 0){
printf(“±”);

}
}
printf(“\n”);
}
}
/*Função que verifica as posicões na matriz*/
posicao verifica(matriz *m, posicao *coordenada)
{
int lin=coordenada->x,col=coordenada->y;
pilha p;
if(m->labirinto[lin][col]==1)
{
coordenada->x=lin;
coordenada->y=col;
return *coordenada;
}
if(m->labirinto[lin][col+1]==1)
{
coordenada->x=lin;
coordenada->y=col+1;
return *coordenada;
}
if(m->labirinto[lin+1][col+1]==1)
{
coordenada->x=lin+1;
coordenada->y=col+1;
return *coordenada;
}
if(m->labirinto[lin+1][col]==1)
{
coordenada->x=lin+1;
coordenada->y=col;
return *coordenada;
}
if(m->labirinto[lin+1][col-1]==1)
{
coordenada->x=lin+1;
coordenada->y=col-1;
system(“cls”);
return *coordenada;
}
if(m->labirinto[lin][col-1]==1)
{
coordenada->x=lin;
coordenada->y=col-1;
return *coordenada;
}
if(m->labirinto[lin-1][col-1]==1)
{
coordenada->x=lin-1;
coordenada->y=col-1;
return *coordenada;
}
if(m->labirinto[lin-1][col]==1)
{
coordenada->x=lin-1;
coordenada->y=col;
return *coordenada;
}
if(m->labirinto[lin-1][col+1]==1)
{
coordenada->x=lin-1;
coordenada->y=col+1;
return *coordenada;
}
else
{
coordenada->x=-1;
coordenada->y=-1;
return *coordenada;

}
}

######################################################

######################################################
#define MAX 100
#include “tadpilha.h”
/*Estrutura do tipo matriz*/
typedef struct
{
posicao p;
int labirinto[MAX][MAX];
}matriz;
/*Cabeïçario das funções*/
void carregamatriz(matriz *);
void imprime(matriz );
posicao verifica(matriz *,posicao *);

######################################################

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: