Buscando el código fuente del programa TC maze, ¡¡¡urgente!!!!
Demostración de MazePath POR Turbo C 2.0
Copyright(c) RoverUnion.
Nombre de archivo: Maze.c
Autor Dongchengyu.
Ver 1.10
*/
#include lt;stdio.hgt;
#include lt;stdlib. hgt;
#include lt;malloc.hgt;
#define Arriba0x48
#define Abajo 0x50
#define Izquierda 0x4b
#define Derecha 0x4d
#define Ingresa 0x0d
#define F2 0x3c<
#define F3 0x3d
#define STACK_INIT_SIZE 200
#define STACKINCREMENT 10
typedef int booleano;
typedef int estado.
estructura typedef
{
int x
int y
}
PosType
typedef; estructura
{
int ord;
PosType asiento
int di
}
SElemType;
estructura typedef
{
int td;
int pie
int marca;
}<
Tipo de laberinto;
estructura typedef
{
SElemType *base;
SElemType *top;
int tamaño de pila;
}
Pila
int Laberinto[20][ 30];
MazeType laberinto[20][30];
PosType StartPlace;
PosType EndPlace
int count; /p>
int m, n;
Booleano b_start = FALSE, b_end = FALSE;
void CreatMaze(void);
Estado SaveMaze ( char * nombre de archivo);
Estado LoadMaze(char * nombre de archivo);
void Error(char *mensaje
Estado InitStack(Stack *s);
Estado DestroyStack(Pila *s);
Estado ClearStack(Pila *s);
>Boolean StackEmpty(Stack *s);
int StackLength(Stack *s);
Status Push(Stack *s, SElemType e);
SElemType Pop(Stack *s, SElemType e);
Estado GetTop(Stack *s, SElemType *e);
Estado StackTraverse(Stack *s, Estado (* visita)( SElemType *se));
Pase booleano(PosType curpos);
void MarkPrint(PosType asiento);
void FootPrint(PosType curpos); >
PosType NextPos(PosType asiento, int di);
Estado MazePath(PosType inicio, PosType final);
void CreatMaze(void)
/**/ /* Forma un laberinto.
*/
{
void Error(char *mensaje);
Estado SaveMaze(char *nombre de archivo);
Estado LoadMaze( char *nombre de archivo);
i, j
int x, y
char c
char savename[12] , loadname[12];
Bandera booleana = FALSE, load = FALSE
clrscr()
printf("Menú:\n\n";
printf("1.Cargar archivo Laberinto: (*.dd)\n\n");
printf("2.Ingresar Laberinto:\n\n") ;
printf("Ingrese su elección: ")
do
{
c = getch();
cambiar (c)
{
caso '1': putch('1');
caso '2': putch ('2'); descanso
caso Esc: dormir(1); salida
predeterminado: descanso
}
}
while (c != '1' amp; amp; c != '2');
if (c == '1')
{
printf("/n\nNombreCarga: ");
scanf("s", nombrecarga
if (LoadMaze); (nombre de carga))
{
dormir(1); cargar = VERDADERO
}
más { gotoxy(1, 9) ); printf("¡Error de carga!"); }
}
if (!load)
{
printf(" \nIngrese el tamaño del laberinto:\n");
printf("\nIngrese la longitud:\n");
scanf("d", amp;m);
p>
printf("\nAncho de entrada:\n");
scanf("d", amp;n);
scanf(" d", amp; n);
if (! cargar) {
if (! amp; n);
if (m lt; 4 || n lt; 4) Error("Entrada"); p> if (m gt; 30 || n gt; 20) Error("Laberinto demasiado grande");
for (i = 0; i lt; 30; i)
for (j = 0; j lt; 20; j )
Laberinto[j][i] = 2;
StartPlace.p> clrscr();<
/p>
printf("\n");
for (i = 1; i lt; = n; i)
{
for (j = 1; j lt; = m; j )
{
printf(" #");
Laberinto[i - 1][ j - 1] = 0;
}
printf("\n");
gotoxy(65, 5);
printf("'#': Muro");
gotoxy(65, 7); ("Inicio: Inicio");
gotoxy(65, 9);
printf("Fin: Fin");
printf("Eliminar muro: Del");
gotoxy(65, 13
printf("Ingresar al muro: Enter");
gotoxy(65, 15);
printf("Guardar laberinto: F2");
gotoxy(65, 17); p> printf("Completo: F9");
gotoxy(65, 19
printf("Salir: Esc"); 4, 3);
x = 4; y = 3;
hacer
{
c = getch();
cambiar (c)
{
caso Arriba: if (y gt; 3) { y--; gotoxy(x, y }
romper;
caso Abajo: if (y lt; n) { y; gotoxy(x, y }
romper; > case Abajo: if (y lt; n) { y; gotoxy(x, y }
break.
romper;
caso Izquierda: if (x gt; 4) { x -= 2; gotoxy(x, y }
romper; /p>
case Derecha: if (x lt; 2*m - 2) { x = 2; gotoxy(x, y }
break
case; Del: if (y - 2 == StartPlace.y amp; x / 2 - 1 == StartPlace.b_start = FALSE;
if (y - 2 == EndPlace.y amp; x / 2 - 1 == EndPlace.x) b_end = FALSE;
putch(' '); Laberinto[y - 2][x / 2 - 1] = 1; >
break;
case Ingrese: if (y - 2 == StartPlace.y amp; amp ; x / 2 - 1 == StartPlace.x) break;
if (y - 2 == EndPlace.y amp; amp; x / 2 - 1 == EndPlace.
break;
putch('#'); Laberinto[y- 2][x/2-1]=0; gotoxy(x,y);
break;
case Inicio: if (Laberinto[y - 2] [x / 2 - 1] amp; p>
StartPlace.x = x / 2 - 1;
endPlace.x = 0;
descanso
si (y - 2 = = EndPlace.y amp; x / 2 - 1 == EndPlace.
putch('S');
gotoxy(x, y) ;
b_start = TRUE;
}
break;
case End: if (Laberinto[y - 2][x / 2 - 1] amp;amp; !b_end)
{
EndPlace.x = x / 2 - 1
EndPlace.y = y - 2; >
putch('E');
gotoxy(x, y);
b_end = VERDADERO
}
caso Esc: gotoxy(2, 22); printf("salir"); salir(1);
caso F9: if ( b_start amp; b_end) bandera = VERDADERO;
case F2.gotoxy(2, 22);
ename: ");
scanf("s", guardar nombre);
gotoxy(2, 22);
if (SaveMaze(guardar nombre)) printf ("Guardar ¡OK!");
else printf("¡Guardar falló! ");
dormir(1);
gotoxy(2, 22) ;
printf(" ");
gotoxy(x, y);
romper
predeterminado: romper
p>
}
}
mientras (!flag
for (i = 0; i lt; 30; i )
for (j = 0; j lt; 20; j )
{
laberinto[j][i]. ][i];
laberinto[j][i].mark = 0;
laberinto[j][i].foot = 0; }
}
Estado LoadMaze(char *file)
/**/ /* El laberinto ha sido cargado */
{
<. p> ARCHIVO *fp;char *búfer;
char
int i = 0, j, k;
Len booleano = FALSE, wid = FALSE;
Len booleano = FALSE;
if ((char *file)
Para Cargue el laberinto que necesita para cargar el archivo.
p>
if ((fp = fopen(file, "r")) == NULL)
return ERROR;
buffer = (char *) malloc(600 * sizeof(char));
ch = fgetc(fp);
while (ch != EOF)
{
buffer[i] = ch;
i
ch = fgetc(fp); 30; n = 20;
para (i = 0; i lt; 600; i )
{
j = i / 30; k = i 30; p> p>
if (buffer[i] == '2' amp; !len){ m = i = TRUE }
if (k == 0 amp; amp; buffer[i] == '2' amp;amp;!wid){ n = j; wid = TRUE }
cambiar (buffer[i])
{
p>
caso '0': Laberinto[j][k] = 0;
caso '1': Laberinto[j][k] = 1; ;
caso '2': Laberinto[j][k] = 2;
caso '3': Laberinto[j][k] = 1; >
PlaceInicio.x = k;
PlaceInicio.y = j;
b_start = VERDADERO
romper; caso '4': Laberinto[j][k] = 1;
EndPlace.x = k
EndPlace.y = j; VERDADERO;
romper;
predeterminado: romper
}
}
fclose( fp);
p>clrscr();
para (i = 0; i lt; 30; i )
para (j = 0; j lt; 20; j )
{
laberinto[j][i].td = Laberinto[j][i]; [i].foot = 0 ;
laberinto[j][i].mark = 0;
if (Laberinto[j][i] == 0)
{
gotoxy(2*i 2, j 2)
putch('#'); p> }
gotoxy(2*StartPlace.x 2, StartPlace.y 2
putch('S');
gotoxy(2*); EndPlace.x 2, EndPlace. y 2);
putch('E').
return OK;
}
Estado Guardar
eMaze(char *filename)
/**/ /* El laberinto ha sido guardado. */
{
ARCHIVO *fp;
char * buffer;
int i, j, k
fp = fopen(filename, "wb");
buffer = (char *)malloc(600 * sizeof(char));
for (i = 0; i lt; 600; i )
{
j = i / 30; k = i 30
interruptor (Laberinto[j][k])
{
caso 0:
caso 2: buffer[i] = '2'; break
predeterminado: Error( "Escribir"); romper;
}
if (k == StartPlace.x amp; amp; j == StartPlace.y) buffer[i] = '3';
if (k == EndPlace.x amp; amp; j == EndPlace.y) buffer[i] = '3'; FootPrint(curpos);
e.ord = curstep; e.seat = curpos; e.di = 1;
gotoxy((curpos.y 1)*2, curpos. x 2);
putch('@ ');
retardo(8000); /**/ /* posponer tiempo.*/
Push( s, e);
if (curpos.x == end.x amp; amp; curpos.y == end.y) /**/ /* Proceder recursivamente. */
{
DestroyStack(s);
devuelve VERDADERO
}
curpos = NextPos (curpos, 1); /**/ /* Prueba la siguiente posición. */
curstep;
}
else
{
if (!StackEmpty(s))
{
e = Pop(s, e); /**/ /* Elimina e de s. */
while (e. di == 4 amp; amp; !StackEmpty(s)) /**/ /* Se han comprobado cuatro direcciones
y s no está vacío. */
{
MarkPrint(e.seat);
gotoxy((e.seat.y 1)*2, e.seat.x 2 );
putch('@');
retraso(8000); /**/ /* Posponer tiempo.
*/
gotoxy((e.seat.y 1)*2, e.seat.x 2);
putch(' ');
e = Pop(s, e); /**/ /* Eliminar e de s */
curstep--;
}
if (e .di lt; 4) /**/ /* La posición actual no está marcada. */
{
e.di;
Push(s, e); /**/ /* Insertar e en s. */
}
}
}
while (!StackEmpty(s));
DestroyStack; (s);
return FALSE;
}/**/ /* /* Ruta del laberinto*/
/* Inserta e en s. di /**/ /* Prueba la siguiente ruta del laberinto*/
void main()
{
PosType start, end;
CreatMaze();
start.x = StartPlace.y;
start.y = StartPlace.x;
end.x = EndPlace .y;
end.y = EndPlace.x;
if (MazePath(inicio, fin))
{
gotoxy (2, 22);
printf("Ruta encontrada\n");
}
else
{
gotoxy(2, 22);
printf("Ruta no encontrada/n");
}
getch(); p>
> clrscr();
}
Encuéntrelo en línea, cómo usarlo, compruébelo usted mismo