Labirinto em pascal

[Anderson_Costa]

Gostaria de saber se alguêm já fez esse jogo usando pilhas ?

Faça um programa em Pascal que simule um jogo de labirinto.

O jogador 1 deve indicar, através de um matriz de dimensão 4x5, as posições onde o jogador 2 pode transitar. As outras posições serão consideradas inacessíveis.

Para indicar que o caminho está livre, o programa deve preencher a posição da matriz com 0 e para as posições que não podem ser percorridas, deve ser preenchido com 1.

As posições 1x1 e 4x5 serão preenchidas previamente com 0. A posição 1x1 indica o início do caminho. O primeiro jogador deve indicar as outras posições livres até alcançar a posição 4x5 que indica o final do caminho.

O programa não deve permitir que o jogador 1 indique a próxima posição livre sem que ela seja vizinha da última posição. Também não é permitido que a próxima posição esteja em diagonal com a posição anterior. Por exemplo, se a última posição indicada foi a 2x2, as próximas posições só podem ser 2x1, 1x2, 2x3 e 3x2.

Depois do jogador 1 indicar o caminho livre, o jogador 2 deve tentar percorrer o caminho marcado. Ele deve iniciar sempre na posição 1x1 e informar a próxima posição que deseja alcançar. Essa posição deve ser obrigatoriamente vizinha a posição aonde ele se encontra. Se ele quiser se deslocar para uma posição inacessível (marcado com 1), o programa deve emitir uma mensagem de erro e retorná-lo para a posição anterior.

Ao alcançar a posição final (4x5) devem ser exibidas as posições corretas por onde o jogador passou.

Utilize uma estrutura de pilha para guardar o caminho percorrido.

Até agora fiz essa pequena linha de código ai em baixo :

>> UNIT LIBPILHA;

Interface

Const

L=5;

C=5;

parede=`1`;

livre=`0`;

Type

Pilha = Record

Ini,Fin : Integer;

Lab_L : Array [1..L] of Integer;

Lab_C : Array [1..C] of Integer;

End;

Function PilhaVazia(Lab : Pilha) : Boolean;

Function PilhaCheia (Lab : Pilha) : Boolean;

Procedure Empilha (Var Lab : Pilha; ELEM : Integer; Var RET : Boolean);

Procedure Desempilha (Var Lab : Pilha; Var ELEM : Integer);

Implementation

Function PilhaVazia(Lab : Pilha) : Boolean;

Begin

If Lab.Ini = 0 then

PilhaVazia := true

Else

PilhaVazia := false;

End;

Function PilhaCheia (Lab : Pilha) : Boolean;

Begin

If Lab.Fin = Max then

PilhaCheia := true

Else

PilhaCheia := false;

End;

Procedure Empilha (Var Lab : Pilha; ELEM : Integer; Var RET : Boolean);

Begin

If not PilhaCheia(Lab) then

Begin

Lab.Ini := Lab.Ini + 1;

Lab.Lab_L[Lab.Ini] := ELEM;

Lab.Lab_C[Lab.Ini] := ELEM;

RET := true;

End

Else

RET := false;

End;

Procedure Desempilha (Var Lab : Pilha; Var ELEM : Integer);

Begin

ELEM := Lab.Lab_L[Lab.Fin];

ELEM := Lab.Lab_C[Lab.Fin];

Lab.Fin := Lab.Fin - 1;

End;

Procedure visualiza (var Lab : Pilha; Var X,Y : Integer);

Begin

for X:=1 to L do

for Y:=1 to C do

begin

Write(lab[X,Y]);

end;

end;

End.

>> PROGRAM TRAB_AV1;

USES Crt, LIBPILHA;

VAR

LAB : LABIRINTO;

LOC : BOOLEAN;

CAMINHO,REF,X,Y : INTEGER;

OP : CHAR;

BEGIN

REPEAT

Clrscr;

Writeln('1 - MONTAR LABIRINTO');

Writeln('2 - JOGAR');

Writeln('3 - MOSTRAR LABIRINTO');

Writeln('4 - EXIBIR LABIRINTO INTEIRO');

Writeln('SAIR');

Write('Opcao :');

Readln(OP);

IF OP = 1 THEN

BEGIN

Writeln('MONTAR LABIRINTO');

Readln(LAB[X,Y]);

Writeln('Referencia : ');

Readln(REF);

CASE CAMINHO OF

1 : Empilha(J1, REF, LOC);

2 : Jogar(J2, REF, LOC);

END;

IF CAMINHO = 1 THEN

Writeln('CAMINHO REGISTRADO')

IF CAMINHO = 2 THEN

Writeln('COMECAR JOGO');

Readln;

END

ELSE

IF OP = 2 THEN

BEGIN

Write('Qual o caminho ?');

Readln(CAMINHO);

CASE CAMINHO OF

1 : WHILE NOT PilhaVazia(X,Y) DO

BEGIN

Desempilha(REF.[X,Y]);

Writeln(REF);

END;

2 : WHILE NOT PilhaCheia(X,Y) DO

BEGIN

Desempilha(REF[X,Y]);

Writeln(REF);

END;

END;

IF OP = 3 THEN

BEGIN

Write(REF.LAB[X,Y]);

END;

IF OP = 4

BEGIN

Writeln('VISUALIZAR LABIRINTO');

Write(LAB[X,Y]);

READLN;

END;

UNTIL OP < 4;

END.

Alguêm pode me ajudar ?

Agradeço qualquer resposta.