{
____ _
| _ \(_)
| |_) |_ ___ _ ____ _____ _ __ _ _ ___ __ _
| _ <| |/ _ \ '_ \ \ / / _ \ '_ \| | | |/ _ \ / _` |
| |_) | | __/ | | \ V / __/ | | | |_| | __/ | (_| |
|____/|_|\___|_| |_|\_/ \___|_| |_|\__,_|\___| \__,_|
_____ _ _____ _____ ______ __ __ ____________
/ ____| | |_ _| __ \| ____| | \/ | /\ |___ / ____|
| (___ | | | | | | | | |__ | \ / | / \ / /| |__
\___ \| | | | | | | | __| | |\/| | / /\ \ / / | __|
____) | |____ _| |_| |__| | |____ | | | |/ ____ \ / /__| |____
|_____/|______|_____|_____/|______| |_| |_/_/ \_\/_____|______|
LE PLUS IMPORTANT DE TOUT : POUR AVOR UNE MEILLEURE COMPREHENSION DE CE
PROGRAMME...... JOUEZ-Y EN PREMIER!!!!!!!!!!!!!
Bienvenue a mon programme. C'est un programme d'un jeu nomme SLIDE MAZE
Pour savoir comment jouer, il suffit de debuter le programme et d'aller dans
la section 'COMMENT JOUER' du menu. Le programme est basee sur un tableau
12X12. Ce tableau sera utiliser comme une matrice et represente l'aire de
jeu. L'aire de jeu est de 10X10, il possede des bordures tout autour,
c'est pour cela qu'il sera necessaire d'utiliser une matrice 12X12 pour
creer l'aire de jeu. Pour dessiner les objets sur l'aire de jeu, il suffira
de creer des procedures qui possedent les variables X et Y du tableau
( i.e. Tableau[x,y] ) pour pouvoir dessiner ces objets aux endroits precis
voulu. Une fois que toutes les procedures de 'dessins' seront completer,
il sera tres facile de creer plusieurs niveau, car il suffit de changer
la valeur d'une des cases de la matrice pour qu'il dessine l'objet voulu
(i.e. si Tableau[2,2]:=1; alors un carree sera dessiner a la position x=2 et
y=2).
*************NOTE POUR LA COMPREHENSION DU RESTE DU PROGRAMME**************
LE PLUS IMPORTANT DE TOUT : POUR AVOR UNE MEILLEURE COMPREHENSION DE CE
PROGRAMME...... JOUER EN PREMIER!!!!!!!!!!!!!
LEVEL1[X,Y]:=1; CUBE/OBSTACLE
(VOIR PROCEDURE : CUBE)
LEVEL1[X,Y]:=2; PION BLANC QUI REPRESENTE LE JOUEUR (AUSSI APPELER PAC
DURANT LE PROGRAMME)
(VOIR PROCEDURE : PAC)
LEVEL1[X,Y]:=3; CIBLE/OBJECTF A ATTEINDRE DANS LES DIFFERENTS NIVEAUX
(VOIR PROCEDURE : WIN)
LEVEL1[X,Y]:=4; OBSTACLE FRANCHISSABLE DU HAUT VERS LE BAS, MAIS DANS
AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GODOWN)
LEVEL1[X,Y]:=5; OBSTACLE FRANCHISSABLE DE LA DROITE VERS LA GAUCHE, MAIS
DANS AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GOLEFT)
LEVEL1[X,Y]:=6; OBSTACLE FRANCHISSABLE DU BAS VERS LE HAUT, MAIS DANS
AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GOUP)
LEVEL1[X,Y]:=7; OBSTACLE FRANCHISSABLE DE LA GAUCHE VERS LA DROITE, MAIS
DANS AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GORIGHT)
#72 REPRESENTE LA FLECHE DU HAUT SUR LE CLAVIER D'ORDINATEUR
#80 REPRESENTE LA FLECHE DU BAS SUR LE CLAVIER D'ORDINATEUR
#75 REPRESENTE LA FLECHE DE GAUCHE SUR LE CLAVIER D'ORDINATEUR
#77 REPRESENTE LA FLECHE DE DROITE SUR LE CLAVIER D'ORDINATEUR
POINTAGE : Le pointage dans ce jeu fonctionne de la maniere suivante:
au debut d'un niveau le joueur a 1000 point pour le niveau.
Lorsqu'il appuie sur une des fleche du clavier et que la pion
peut se deplacer dans le sens voulu, il perdera 25 points des
milles points. Lorsque le niveau est reussi, le pointage du
niveau completer s'ajoutera au total des points du jeu.
Le jeu ayant 10 niveau il sera donc impossible de faire plus
que 10000 points au total.
DIFFERENCE ENTRE X,Y ET XPAC,YPAC ([X,Y] VS [XPAC,YPAC])
Pour dessiner mes differents niveau, je donne une valeur a une des cases
de ma matrice (ex: Level[2,2]:=1;). En utilisant des boucles FOR...DO, je
balaie l'aire de jeu pour dessiner des carrees partout il y a des '1' et
ainsi de suite avec tout les autres objets. A ce moment, Level[x,y]. Une
fois que la boucle est fini, la position x,y memoriser par le programme
sera a x=12 et y=12. Si je veux que mon Joueur puisse commencer a bouger
a la position ou je l'ai dessiner il faut que je donne la valeur XPAC
et YPAC a la position ou le joueur fut dessiner pour ne pas qu'il commence
a bouger a la position [12,12]. Une fois que le niveau est dessiner,
ce ne sera plus Level[x,y], mais Level[xpac,ypac]. Bref, [x,y] est utiliser
pour dessiner les niveaux. [xpac,ypac] defini la position du joueur sur
l'aire de jeu.
VOIR PROCEDURE DESSINELELEVEL POUR PLUS DE DETAILS
****POUR SAVOIR L'UTILITEE DE CHACUNE DES VARIABLES, S.V.P. SE REFERER*****
*****A LA SECTION OU SONT LES VARIABLES AU DEBUT , UNE*********************
*****DEFINITION DETAILLEE SERA PRESENTE**********************************
____________________________________________________________________________
____________________________________________________________________________
----------------------------------------------------------------------------}
Program GAME; uses crt,graph;
const larg=40; {40 est la largeur et la hauteur de chacun des carree de
l'aire de jeu de mon tableau 12X12. Cette constante me
sera utile pour dessiner les choses aux bons endroits
sans avoir a deviner la position en X et en Y.Il me suffira
de faire X(du tableau[x,y])*larg pour positioner un objet
horizontalement et Y(du tableau[x,y])*larg pour positioner
un objet verticalement.
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________}
var
{LONG INTEGER}
linehor,linever, {Utliser pour dessiner le quadrillee horizontal et vertical
de l'aire de jeu.}
Total, {Total= le total des points accumuler durant les differents
niveaux du jeu.}
Point, {Point = points du niveau actuel dans lequel le joueur est
en train de jouer. Le total des points sera l'accumulation
des points de chacun des niveaux.}
x,y, {Differentes coordonees de mon tableau 12X12
(i.e. Tableau[x,y])}
xpac,ypac, {Differentes coordonnees de mon tableau 12X12 qui definit
la position du joueur APRES que le niveau soit dessiner.}
{DIFFERENCE ENTRE X,Y ET XPAC,YPAC ([X,Y] VS [XPAC,YPAC])}
{Pour dessiner mes differents niveau, je donne une valeur a une des cases
de ma matrice (ex: Level[2,2]:=1;). En utilisant des boucles FOR...DO, je
balaie l'aire de jeu pour dessiner des carrees partout il y a des '1' et
ainsi de suite avec tout les autres objets. A ce moment, Level[x,y]. Une
fois que la boucle est fini, la position x,y memoriser par le programme
sera a x=12 et y=12. Si je veux que mon Joueur puisse commencer a bouger
a la position ou je l'ai dessiner il faut que je donne la valeur XPAC
et YPAC a la position ou le joueur fut dessiner pour ne pas qu'il commence
a bouger a la position [12,12]. Une fois que le niveau est dessiner,
ce ne sera plus Level[x,y], mais Level[xpac,ypac]. Bref, [x,y] est utiliser
pour dessiner les niveaux. [xpac,ypac] defini la position du joueur sur
l'aire de jeu.
VOIR PROCEDURE DESSINELELEVEL POUR PLUS DE DETAILS}
Level, {Utiliser pour selectionner un niveau ou pour determiner
dans quel niveau on est}
page, {Utiliser dans le menu d'instructions pour pouvoir
changer les pages}
babouin {Pour la sortie du programme durant le jeu}
:longint;
{STRING}
n, {Nom de l'usager}
totals, {Total des points{longint) convertit en STRING pour
qu'on puisse l'ecrire dans un 'outtextxy'.}
points, {Points du niveaux {longint) convertit en STRING pour
qu'on puisse l'ecrire dans un 'outtextxy'.}
levels, {'Levels' = 'Level' convertit en string pour pouvoir
l'inserer dans un outtextxy}
Text {Du texte...}
:string;
{INTEGER}
pilote,mode {utiliser pour initier les fonctions graphiques}
:integer;
{CHAR}
fleche, {Pour lire une touche qu a ete pesee sur le clavier}
instruction,
choix
:char;
{ARRAY}
Level1:array[1..12,1..12] of integer; {MATRICE 12X12 utiliser pour mon jeu}
{voir premier paragraphe pour voir
l'utiliter
___________________________________________________________________________
___________________________________________________________________________
___________________________________________________________________________}
Procedure beginning;
{Procedure d'ouverture dans laquelle qui souhaite la bienvenue a
l'usager.
Les procedures graphiques sont deja initier.}
begin
cleardevice;
outtextxy((getmaxx-textwidth('Bonjour')) div 2, (getmaxy-textheight('Bonjour'))div 2,'Bonjour');
outtextxy((getmaxx-textwidth(n)) div 2, 250,n);
delay(2000);
setbkcolor(black);
end;
Procedure gameover;
begin
str(Total,totals);
Bar(120,150,520,290);
Text:=' votre pointage final est de';
outtextxy((getmaxx-textwidth('Vous pouvez rejouer au menu!'))div 2,210,'Vous pouvez rejouer au menu!' );
outtextxy((getmaxx-textwidth(n+text))div 2,220, n+text);
outtextxy((getmaxx-textwidth(totals)) div 2, (getmaxy-textheight(totals))div 2, totals);
delay(2500);
end;
Procedure Grille;
{Procedure qui dessine la grille de jeu mais sans les obstacles et
les pions. }
begin
setbkcolor(black);
setcolor(white);
Outtextxy(10,460,' R = RESET LEVEL X = MENU');
For linehor:=1 to 11 do {dessin des lignes horizontales}
line(120,linehor*larg,520,linehor*larg);
for linever:= 1 to 11 do {dessin des lignes verticales}
line(linever*larg+80,40,linever*larg+80,440);
end;
Procedure cube;
{Lorsque Level1[x,y]:=1; Un cube sera dessiner.}
begin
setfillstyle(1,1);
bar(x*larg+40,y*larg-40,x*larg+80,y*larg); {Permet de dessiner le cube aux
bons endroits.}
end;
Procedure PAC;
{Lorsque Level1[x,y]:=2; alors le pion sera dessinee.
Ici, [xpac,ypac] est utiliser, car cette procedure sera utiliser
APRES que le niveau soit dessiner.}
begin
setfillstyle(1,15);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),18,18);
end;
Procedure win;
{Lorsque Level1[x,y]:=3; alors la cible (procedure win;) sera dessiner.}
begin
{Alternance entre des cercles rouges et blanc de differentes grandeurs pour
faire le dessin d'une cible d'archer.
On utilise FILLELLIPSE et non CIRCLE pour avoir des cercle plein et non
seulement des le contour d'un cercle.}
setfillstyle(1,15);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),18,18);
setfillstyle(1,red);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),15,15);
setfillstyle(1,white);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),12,12);
setfillstyle(1,red);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),9,9);
setfillstyle(1,white);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),6,6);
setfillstyle(1,red);
fillellipse((x+1)*larg+(larg div 2),(y-1)*larg+(larg div 2),3,3);
end;
procedure winafterrollover;
{Puisqu'on peux seulement passer un niveau en ARRETANT sur la cible,
lorsqu'on passe dessus, le procedure NOPAC (qui efface le dessin de PAC sur
l'ecran) l'effacerait. Alors il faut redessiner la cible une fois que le
pion (PAC) passe dessus.
[XPAC,YPAC] est utilisee parce que ceci est une procedure qui sera utlisee
APRES que le niveau soit dessiner.}
begin
{Alternance entre des cercles rouges et blanc de differentes grandeurs pour
faire le dessin d'une cible d'archer.
On utilise FILLELLIPSE et non CIRCLE pour avoir des cercle plein et non
seulement des le contour d'un cercle.}
setfillstyle(1,15);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),18,18);
setfillstyle(1,red);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),15,15);
setfillstyle(1,white);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),12,12);
setfillstyle(1,red);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),9,9);
setfillstyle(1,white);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),6,6);
setfillstyle(1,red);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),3,3);
end;
Procedure godown;
{Lorsque Level1[x,y]:=4; la procedure godown sera dessinee.
Cette procedure fera le dessin d'un carree orange avec deux fleches
qu pointeront vers le bas. Cet 'obstacle' peut etre franchi lorsque
pac se deplace du haut vers le bas, mais dans aucun autre sens.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [x,y] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
bar(x*larg+40,y*larg-40,x*larg+80,y*larg);
line(x*larg+40,y*larg-40,x*larg+60,y*larg-20);
line(x*larg+60,y*larg-20,x*larg+80,y*larg-40);
line(x*larg+40,y*larg-20,x*larg+60,y*larg);
line(x*larg+60,y*larg,x*larg+80,y*larg-20);
end;
Procedure godownrollover;
{Lorsque pac (pion) passe par-dessus l'obstacle 'godown' (Level1[x,y]:=4;)
La procedure nopac(voir procedure 'nopac') dessinera un cercle noir par
apres pour effacer le pac qui sera sur 'godown'. Pour ne pas que le
dessin de l'obstacle 'godown' aie un cercle noir dessus, il faudra redessiner
l'obstacle. Cette procedure est identique a 'godown', mais on utilise
[XPAC,YPAC], car elle sera utilisee APRES que le niveau soit dessiner.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [xpac,ypac] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
bar(xpac*larg+40,ypac*larg-40,xpac*larg+80,ypac*larg);
setcolor(white);
line(xpac*larg+40,ypac*larg-40,xpac*larg+60,ypac*larg-20);
line(xpac*larg+60,ypac*larg-20,xpac*larg+80,ypac*larg-40);
line(xpac*larg+40,ypac*larg-20,xpac*larg+60,ypac*larg);
line(xpac*larg+60,ypac*larg,xpac*larg+80,ypac*larg-20);
end;
Procedure goup;
{Lorsque Level1[x,y]:=6; la procedure 'goup' sera dessinee.
Cette procedure fera le dessin d'un carree orange avec deux fleches
qui pointeront vers le haut. Cet 'obstacle' peut etre franchi lorsque
pac se deplace du bas vers le haut, mais dans aucun autre sens.}
begin
setfillstyle(1,6);
bar(x*larg+40,y*larg-40,x*larg+80,y*larg); {Dessin du carree orange}
line(x*larg+40,y*larg-20,x*larg+60,y*larg-40); {et des lignes qui representent}
line(x*larg+60,y*larg-40,x*larg+80,y*larg-20); {les fleches.}
line(x*larg+40,y*larg,x*larg+60,y*larg-20); {On utilise la constante 'larg'}
line(x*larg+60,y*larg-20,x*larg+80,y*larg); {et les variables [x,y] pour}
end; {que le dessin se fasse a l'endroit
desirer dans la matrice 12X12.}
Procedure gouprollover;
{Lorsque pac (pion) passe par-dessus l'obstacle 'goup' (Level1[x,y]:=6;)
LA procedure nopac(voir procedure 'nopac') dessinera un cercle noir par
apres pour effacer le pac qui sera dessiner sur 'goup'. Pour ne pas que le
dessin de l'obstacle 'goup' aie un cercle noir dessus, il faudra redessiner
l'obstacle.Cette procedure est identique a 'goup', mais on utilise
[XPAC,YPAC], car elle sera utilisee APRES que le niveau soit dessiner.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [xpac,ypac] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
bar(xpac*larg+40,ypac*larg-40,xpac*larg+80,ypac*larg);
setcolor(white);
line(xpac*larg+40,ypac*larg-20,xpac*larg+60,ypac*larg-40);
line(xpac*larg+60,ypac*larg-40,xpac*larg+80,ypac*larg-20);
line(xpac*larg+40,ypac*larg,xpac*larg+60,ypac*larg-20);
line(xpac*larg+60,ypac*larg-20,xpac*larg+80,ypac*larg);
end;
Procedure goleft;
{Lorsque Level1[x,y]:=5; la procedure 'goleft' sera dessinee.
Cette procedure fera le dessin d'un carree orange avec deux fleches
qui pointeront vers la gauche. Cet 'obstacle' peut etre franchi lorsque
pac se deplace de la droite vers la gauche, mais dans aucun autre sens.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [x,y] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
bar(x*larg+40,y*larg-40,x*larg+80,y*larg);
line(x*larg+60,y*larg-20,x*larg+80,y*larg-40);
line(x*larg+60,y*larg-20,x*larg+80,y*larg);
line(x*larg+40,y*larg-20,x*larg+60,y*larg-40);
line(x*larg+40,y*larg-20,x*larg+60,y*larg);
end;
Procedure goleftrollover;
{Lorsque pac (pion) passe par-dessus l'obstacle 'goleft' (Level1[x,y]:=5;)
La procedure nopac(voir procedure 'nopac') dessinera un cercle noir par
apres pour effacer le pac qui sera dessiner sur 'goleft'. Pour ne pas que le
dessin de l'obstacle 'goleft' aie un cercle noir dessus, il faudra redessiner
l'obstacle.Cette procedure est identique a 'goleft', mais on utilise
[XPAC,YPAC], car elle sera utilisee APRES que le niveau soit dessiner.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [xpac,ypac] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
setcolor(white);
bar(xpac*larg+40,ypac*larg-40,xpac*larg+80,ypac*larg);
line(xpac*larg+60,ypac*larg-20,xpac*larg+80,ypac*larg-40);
line(xpac*larg+60,ypac*larg-20,xpac*larg+80,ypac*larg);
line(xpac*larg+40,ypac*larg-20,xpac*larg+60,ypac*larg-40);
line(xpac*larg+40,ypac*larg-20,xpac*larg+60,ypac*larg);
end;
Procedure goright;
{Lorsque Level1[x,y]:=7; la procedure 'goright' sera dessiner.
Cette procedure fera le dessin d'un carree orange avec deux fleches
qu pointeront vers la droite. Cet 'obstacle' peut etre franchi lorsque
pac se deplace de la gauche vers la droite, mais dans aucun autre sens.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [x,y] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
bar(x*larg+40,y*larg-40,x*larg+80,y*larg);
line(x*larg+40,y*larg-40,x*larg+60,y*larg-20);
line(x*larg+40,y*larg,x*larg+60,y*larg-20);
line(x*larg+60,y*larg-40,x*larg+80,y*larg-20);
line(x*larg+60,y*larg,x*larg+80,y*larg-20);
end;
Procedure gorightrollover;
{Lorsque pac (pion) passe par-dessus l'obstacle 'goright' (Level1[x,y]:=7;)
La procedure nopac(voir procedure 'nopac') dessinera un cercle noir par
apres pour effacer le pac qui sera dessiner sur 'goright'. Pour ne pas que le
dessin de l'obstacle 'goright' aie un cercle noir dessus, il faudra redessiner
l'obstacle.Cette procedure est identique a 'goright', mais on utilise
[XPAC,YPAC], car elle sera utilisee APRES que le niveau soit dessiner.}
begin
{Dessin du carree orange et des lignes qui representent les fleches.
On utilise la constante 'larg' et les variables [xpac,ypac] pour que le
dessin se fasse a l'endroit desirer dans la matrice 12X12.}
setfillstyle(1,6);
setcolor(white);
bar(xpac*larg+40,ypac*larg-40,xpac*larg+80,ypac*larg);
line(xpac*larg+40,ypac*larg-40,xpac*larg+60,ypac*larg-20);
line(xpac*larg+40,ypac*larg,xpac*larg+60,ypac*larg-20);
line(xpac*larg+60,ypac*larg-40,xpac*larg+80,ypac*larg-20);
line(xpac*larg+60,ypac*larg,xpac*larg+80,ypac*larg-20);
end;
Procedure nopac;
{A chaque fois qu'une fleche du clavier sera peser, pac se deplacera en ligne
droite dans la direction voulu jusqu'a ce qu'il rencontre un obstacle qu'il
ne peux pas franchir dans sa direction donnee. La procedure nopac permet
qu'a chaque fois que pac se deplace d'une case, celui qui etait present sur
la case anterieure s'efface pour qu'il y aie un seul pac de present sur
l'ecran en tout temps.}
begin
setcolor(0); {0=noir}
setfillstyle(1,0);
fillellipse((xpac+1)*larg+(larg div 2),(ypac-1)*larg+(larg div 2),18,18);
{Cette secton de 'if' est tres importante. Nopac sera dessiner sur la case
anterieure de pac a tout les coups que celui-ci se deplacera. PAR CONTRE, si
la case sur laquelle le NOPAC est dessiner possedat une valeur autre que 0,
l'obstacle qui est present sur cette case sera redessinee. Voici l'utilitee
des procedure 'XXXXXX-rollover' precedente.}
if Level1[xpac,ypac]=3 then winafterrollover;
if Level1[xpac,ypac]=4 then godownrollover;
if Level1[xpac,ypac]=5 then goleftrollover;
if Level1[xpac,ypac]=6 then gouprollover;
if Level1[xpac,ypac]=7 then gorightrollover;
end;
Procedure Pointage;
{Cette procedure se souvient et affiche le pointage du joueur. A chaque fois
qu'une des fleches du clavier sera peser, le pointage sera decrementee de
25 points(par contre cette decrementation se fait dans la
procedure 'BOUGER').}
begin
setfillstyle(1,black); {Permet d'effacer le pointage qui etait ecrit}
bar(320,0,640,39); {pour le remplacer par le nouveau. }
setcolor(white); {Pour ecrire le pointage en blanc}
str(total,Totals); {Transforme la valeur de Total en string}
outtextxy(450,10, Totals); {Ecrit le total des points accumule}
str(point,points); {Transforme la valeur de Point en string}
outtextxy(330,10, Points); {Ecrit le nombre de points du niveau}
Outtextxy(400,10,'TOTAL');
Outtextxy(200,10,'POINT DU LEVEL');
end;
procedure error;
{Si le joueur effectue une manoeurvre ou pac ne pourra pas bouger
alors la procedure error embarquera}
begin
{Fait un son d'erreur}
sound(262);delay(50);nosound;
end;
procedure Bouger;
{Procedure TRES importante du programme. C'est celle-ci qui lira les touches
pesees sur le clavier et qui fera bouger pac.
NOTE :
#72 REPRESENTE LA FLECHE DU HAUT SUR LE CLAVIER D'ORDINATEUR
#80 REPRESENTE LA FLECHE DU BAS SUR LE CLAVIER D'ORDINATEUR
#75 REPRESENTE LA FLECHE DE GAUCHE SUR LE CLAVIER D'ORDINATEUR
#77 REPRESENTE LA FLECHE DE DROITE SUR LE CLAVIER D'ORDINATEUR
Ici [XPAC,YPAC] est utilisee, car c'est une procedure qui sera utilisee
APRES que la grille soit dessinee.}
begin
fleche:=readkey; {fleche est un 'char'}
case fleche of
#72 : {Cette section peut sembler compliquee, mais en
l'analysant, elle est bien simple.}
if(Level1[xpac,ypac-1]<>1) {Si la case au-dessus de pac n'est pas un cube}
and (Level1[xpac,ypac-1]<>4){ou n'est pas un 'godown' (voir procedure godown)}
and(Level1[xpac,ypac-1]<>5) {ou n'est pas un 'goleft'(voir procedure goleft)}
and(Level1[xpac,ypac-1]<>7) {ou n'est pas un 'goright' (voir procedure goright)}
{Noter que si la case au-dessus de pac est un
'goup' (Level1[xpac,ypac]:=6, alors pac
sera capable de passer}
then {ALORS}
begin
repeat {repete}
delay(15); {un delaie de 15 millsecondes}
nopac; {Efface le pac en tracant un rond noir}
dec(ypac); {Decremente ypac qui represente la position VERTICALE
de pac}
Pac; {Dessine un nouveau pac une case au-dessus de la case
precedente}
until {JUSQU'A CE QUE}
(Level1[xpac,ypac-1]=1) {La case au dessus de pac soit un cube}
or(Level1[xpac,ypac-1]=4) {ou un 'godown'}
or(Level1[xpac,ypac-1]=5) {ou un 'goleft'}
or(Level1[xpac,ypac-1]=7);{ou un 'goright'}
if point>0 then dec(point,25); {Si le pointage pour le niveau n'est pas deja
a 0, alors decremente le pointage du niveau
actuel de 25 points.}
end
else error; {Si pac ne peut pas bouger, alors error (voir
procedure error pour plus de details)}
#75 :
{Meme principe qu'au-dessus,mais en utilisant les cases a gauche de pac.}
if (Level1[xpac-1,ypac]<>1) and (Level1[xpac-1,ypac]<>4)
and (Level1[xpac-1,ypac]<>6)and(Level1[xpac-1,ypac]<>7) then
begin
repeat delay(15);nopac; dec(xpac); Pac; until
(Level1[xpac-1,ypac]=1)or(Level1[xpac-1,ypac]=4)
or(Level1[xpac-1,ypac]=6)or(Level1[xpac-1,ypac]=7);
if point>0 then dec(point,25);
end
else error;
#80 :
{Meme prncipe qu'au-dessus, mais en utilisant analysant les cases en-dessous
de pac.}
if (Level1[xpac,ypac+1]<>1) and(Level1[xpac,ypac+1]<>5)
and (Level1[xpac,ypac+1]<>6)and(Level1[xpac,ypac+1]<>7) then
begin
repeat delay(15);nopac; inc(ypac);Pac; until
(Level1[xpac,ypac+1]=1)or(Level1[xpac,ypac+1]=5)
or(Level1[xpac,ypac+1]=6)or(Level1[xpac,ypac+1]=7);
if point>0 then dec(point,25);
end
else error;
#77 :
{Meme prncipe qu'au-dessus, mais en utilisant analysant les cases a droite
de pac.}
if (Level1[xpac+1,ypac]<>1) and (Level1[xpac+1,ypac]<>4)
and (Level1[xpac+1,ypac]<>5) and (Level1[xpac+1,ypac]<>6) then
begin
repeat delay(15);nopac; inc(xpac); Pac; until
(Level1[xpac+1,ypac]=1)or(Level1[xpac+1,ypac]=4)
or(Level1[xpac+1,ypac]=5)or(Level1[xpac+1,ypac]=6);
if point>0 then dec(point,25);
end
else error;
end; {FIN DU CASE}
end; {FIN DE LA PROCEDURE}
Procedure yay;
{Procedure utilisee lorsqu'un niveau est completer.
Suite successive de 5 notes qui realise une musique joyeuse de reussite.}
begin
sound(349);delay(100);
sound(392);delay(100);
sound(440);delay(100);
sound(494);delay(100);
sound(523);delay(100);
nosound;
end;
Procedure ouverture;
{Procedure qui dessine l'ouverture du programme et qui presente le createur}
begin
outtextxy(260,260,'PESE ENTER');
readln;
cleardevice;
outtextxy(210,210,'Bienvenue au jeu SLIDE MAZE');
outtextxy(150,250,'Creer par SEAN BOLDUC aka DiscoSonOfABitch');
delay(500);
Level1[1,6]:=7;Level1[12,6]:=5;
for x:=1 to 12 do for y:=1 to 12 do
begin if Level1[x,y]=7 then goright; if Level1[x,y]=5 then goleft; end;
delay(200);
Level1[2,6]:=7;Level1[11,6]:=5;
for x:=1 to 12 do for y:=1 to 12 do
begin if Level1[x,y]=7 then goright; if Level1[x,y]=5 then goleft; end;
delay(200);
Level1[3,6]:=7;Level1[10,6]:=5;
for x:=1 to 12 do for y:=1 to 12 do
begin if Level1[x,y]=7 then goright; if Level1[x,y]=5 then goleft; end;
Level1[1,3]:=1;
Level1[2,3]:=2;
Level1[3,3]:=3;
Level1[5,3]:=4;
Level1[7,3]:=5;
Level1[9,3]:=6;
Level1[11,3]:=7;
for x:= 1 to 12 do
if level1[x,3]=1 then cube
else if Level1[x,3]=3 then win
else if Level1[x,3]=4 then godown
else if Level1[x,3]=5 then goleft
else if Level1[x,3]=6 then goup
else if Level1[x,3]=7 then goright
else if Level1[x,3]=2 then pac;
delay(100);
Outtextxy(250,330,'PESE ENTER');
readln;
end;
Procedure Start;
{Procedure qui sera presente au debut de chaque niveau.
Elle souhaite la bienvenue a l'utilisateur au niveau.}
begin
Text:='Level ';
str(Level,Levels); {Transforme la valeur du niveau (i.e. de 1 a 10)
en string pour qu'il puisse etre utilsiee dans un outtext}
Outtextxy((getmaxx-textwidth('Bienvenue au ')) div 2,220,' Bienvenue au ');
Outtextxy((getmaxx-textwidth(Text+levels)) div 2, (getmaxy-textheight(Text+levels))div 2,Text+levels);
Outtextxy((getmaxx-textwidth(n)) div 2,250,n);
end;
Procedure dessinelelevel;
{Procedure qui dessine le niveau. Elle sera utilisee au debut de chaque
niveau pour que le niveau apparaissent a l'ecran.
NOTE : Cette procedure dessine seulement les objets/obstacles du niveau.
La grille de jeu est dessiner par la procedure 'Grille'.}
begin
Point:=1000; {Puisque cette procedure est utilisee au debut de
chaque procedure de niveau. Je remet a 1000 le
pointage de niveau ici pour ne pas avoir a le repeter
10 fois.}
setfillstyle(1,black);
bar(320,0,640,39); {efface le pointage du dernier niveau}
textcolor(white);
outtextxy(450,10,Totals); {Reecrit le nouveau pointage Total et du
celui du niveau (1000 points).}
outtextxy(330,10,Points);
for x:= 1 to 12 do {Balaie la matrice 12X12 horizontalement}
for y:= 1 to 12 do {Balaie la matrice 12X12 verticalement}
if level1[x,y]=1 then cube {VOIR PROCEDURE CUBE}
else if Level1[x,y]=3 then win {VOIR PROCEDURE WIN}
else if Level1[x,y]=4 then godown {VOIR PROCEDURE GODOWN}
else if Level1[x,y]=5 then goleft {VOIR PROCEDURE GOLEFT}
else if Level1[x,y]=6 then goup {VOIR PROCEDURE GOUP}
else if Level1[x,y]=7 then goright{VOIR PROCEDURE GORIGHT}
else if Level1[x,y]=2 then
begin xpac:=x; ypac:=y; Pac; end; {Mets la position en X et en Y de pac
comme [XPAC,YPAC] (voir note en haut
de programme pour voir difference entre
[XPAC,YPAC] et [X,Y]), pus dessine pac}
for x:= 1 to 12 do {Trace une bordure au-dessus et en dessous de l'aire
de jeu pour ne pas que pac puisse sortir}
{Cette bordure sera invisible}
for x:= 1 to 12 do
begin
Level1[x,1]:=1;
Level1[x,12]:=1;
end;
for y:= 1 to 12 do {Trace une bordure a gauche et a droite de l'aire
de jeu pour ne pas que pac puisse sortir}
{Cette bordure sera invisible}
begin
Level1[1,y]:=1;
Level1[12,y]:=1;
end;
end;
Procedure Level1e;
{Premier niveau du jeu.
NOTE:
LEVEL1[X,Y]:=1; CUBE/OBSTACLE
(VOIR PROCEDURE : CUBE)
LEVEL1[X,Y]:=2; PION BLANC QUI REPRESENTE LE JOUEUR (AUSSI APPELER PAC
DURANT LE PROGRAMME)
(VOIR PROCEDURE : PAC)
LEVEL1[X,Y]:=3; CIBLE/OBJECTF A ATTEINDRE DANS LES DIFFERENTS NIVEAUX
(VOIR PROCEDURE : WIN)
LEVEL1[X,Y]:=4; OBSTACLE FRANCHISSABLE DU HAUT VERS LE BAS, MAIS DANS
AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GODOWN)
LEVEL1[X,Y]:=5; OBSTACLE FRANCHISSABLE DE LA DROITE VERS LA GAUCHE, MAIS
DANS AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GOLEFT)
LEVEL1[X,Y]:=6; OBSTACLE FRANCHISSABLE DU BAS VERS LE HAUT, MAIS DANS
AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GOUP)
LEVEL1[X,Y]:=7; OBSTACLE FRANCHISSABLE DE LA GAUCHE VERS LA DROITE, MAIS
DANS AUCUNES AUTRES DIRECTIONS
(VOIR PROCEDURE : GORIGHT)}
begin
Level:=1; {Donne la valeur '1' au niveau, elel sera utiliser dans
la procedure 'START'}
cleardevice; {Efface l'ecran.}
start; {Souhaite la bienvenue au joueur.}
delay(1000);
cleardevice; {Reefface l'ecran.}
grille; {Dessine le grille de jeu.}
for x:=1 to 12 do {Remet toutes les cases du niveau a la valeur de '0'}
for y:= 1 to 12 do
Level1[x,y]:=0;
for y:= 2 to 11 do {Donne des valeurs aux cases de la matrice 12X12.}
begin {Donne des valeurs aux cases de la matrice 12X12.}
Level1[5,y]:=1; {Donne des valeurs aux cases de la matrice 12X12.}
Level1[7,y]:=1; {Donne des valeurs aux cases de la matrice 12X12.}
end; {Donne des valeurs aux cases de la matrice 12X12.}
Level1[6,2]:=2; {Donne des valeurs aux cases de la matrice 12X12.}
Level1[6,11]:=3; {Donne des valeurs aux cases de la matrice 12X12.}
dessinelelevel; {Dessine le niveau (VOIR PROCEDURE DESSINELELEVEL)}
pointage; {Reecrit le pointage}
end;
Procedure Level2e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=2;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[2,2]:=2;
Level1[2,11]:=3;
for x:=2 to 10 do begin Level1[x,3]:=1; Level1[x,10]:=1; end;
for y:= 4 to 9 do Level1[10,y]:=1;
dessinelelevel;pointage;
end;
Procedure Level3e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=3;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[3,9]:=2;
Level1[11,6]:=3;
Level1[3,3]:=1;Level1[7,4]:=1;Level1[9,2]:=1;Level1[8,7]:=1;
dessinelelevel;pointage;
end;
Procedure Level4e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=4;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[4,9]:=2;
Level1[5,9]:=3;
Level1[2,8]:=1;Level1[3,4]:=1;Level1[4,3]:=1;Level1[6,2]:=1;Level1[8,4]:=1;Level1[7,9]:=1;
Level1[5,10]:=1;
dessinelelevel;pointage;
end;
Procedure Level5e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=5;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[2,11]:=2;
Level1[3,11]:=3;
Level1[2,10]:=1;Level1[4,7]:=1;Level1[5,11]:=1;Level1[6,3]:=1;Level1[7,7]:=1;
Level1[9,6]:=1;Level1[8,11]:=1;Level1[10,5]:=1;Level1[11,8]:=1;Level1[11,2]:=1;Level1[11,8]:=1;
dessinelelevel;pointage;
end;
Procedure Level6e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=6;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[6,6]:=2;
Level1[9,10]:=3;
Level1[2,6]:=1;Level1[3,2]:=1;Level1[3,9]:=1;Level1[4,4]:=1;Level1[6,2]:=1;
Level1[7,6]:=1;Level1[8,2]:=1;Level1[8,10]:=1;Level1[9,7]:=1;Level1[9,11]:=1;
Level1[10,9]:=1;Level1[11,3]:=1;Level1[11,6]:=1; Level1[6,9]:=1;LEvel1[2,7]:=1;
Level1[11,9]:=1;
dessinelelevel;pointage;
end;
Procedure Level7e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=7;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[2,2]:=2;
Level1[9,10]:=3;
Level1[6,6]:=4;
Level1[2,5]:=1;Level1[6,9]:=1;Level1[7,2]:=1;Level1[7,4]:=1;Level1[7,11]:=1;
Level1[8,5]:=1;Level1[9,8]:=1;Level1[10,10]:=1;
dessinelelevel;pointage;
end;
Procedure Level8e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=8;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[6,6]:=2;
Level1[7,5]:=3;
Level1[6,7]:=4;
Level1[5,6]:=5;Level1[9,5]:=5;
Level1[6,5]:=6;Level1[11,6]:=6;
Level1[7,6]:=7;
Level1[2,2]:=1;Level1[3,2]:=1;Level1[4,2]:=1;Level1[5,2]:=1;Level1[6,2]:=1;
Level1[2,11]:=1;Level1[6,3]:=1;Level1[6,9]:=1;Level1[7,2]:=1;
Level1[8,2]:=1;Level1[9,6]:=1;Level1[10,8]:=1;Level1[11,4]:=1;
dessinelelevel;pointage;
end;
Procedure Level9e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=9;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[7,6]:=2;
Level1[6,4]:=3;
for x:= 4 to 9 do
Level1[x,5]:=7;
Level1[4,6]:=5;Level1[5,6]:=5;Level1[6,6]:=5;
Level1[8,6]:=5;Level1[9,6]:=5;Level1[6,10]:=5;
Level1[8,9]:=4;
Level1[2,6]:=6;
Level1[2,8]:=1;Level1[2,10]:=1;Level1[3,6]:=1;Level1[5,4]:=1;
Level1[6,2]:=1;Level1[7,7]:=1;Level1[10,6]:=1;Level1[11,6]:=1;
dessinelelevel;pointage;
end;
Procedure Level10e;
{VOIR PROCEDURE LEVEL1E POUR PLUS DE DETAILS}
begin
Level:=10;
cleardevice;start;delay(1000);cleardevice;grille;
for x:=1 to 12 do
for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[2,11]:=2; Level1[9,7]:=3;
for y:= 2 to 5 do Level1[2,y]:=7; for y:=2 to 6 do Level1[3,y]:=7;
for y:= 3 to 7 do Level1[5,y]:=1; Level1[5,8]:=7;
Level1[3,7]:=4;Level1[3,8]:=4;Level1[3,9]:=4;Level1[4,7]:=4;
Level1[3,11]:=4;Level1[5,2]:=4;Level1[5,9]:=4;Level1[5,10]:=4;Level1[5,10]:=4;
Level1[6,9]:=7;Level1[7,6]:=4;Level1[7,7]:=4;Level1[7,8]:=4;Level1[6,5]:=6;
Level1[6,3]:=7;Level1[5,11]:=5;
for y:=2 to 10 do Level1[8,y]:=1;Level1[8,11]:=7;
Level1[9,8]:=7;Level1[10,8]:=7;Level1[11,8]:=6;Level1[11,9]:=7;
Level1[10,9]:=7; Level1[11,11]:=6;
dessinelelevel;pointage;
end;
Procedure ending;
{Procedure qui souhaite au revoir a l'Usager a la sortie du programme.}
begin
for x:= 0 to 12 do for y:=0 to 12 do
Level1[x,y]:=0;
cleardevice;
Level1[4,3]:=2;
Level1[8,3]:=1; {Dessin d'objet}
Level1[7,8]:=1;
dessinelelevel; {Dessine le level}
delay(500);
repeat delay(15);nopac; inc(xpac); Pac; until
(Level1[xpac+1,ypac]=1)or(Level1[xpac+1,ypac]=4) {Bouge vers la droite}
or(Level1[xpac+1,ypac]=5)or(Level1[xpac+1,ypac]=6);
delay(200);
repeat delay(15);nopac; inc(ypac);Pac; until {Bouge vers le bas}
(Level1[xpac,ypac+1]=1)or(Level1[xpac,ypac+1]=5)
or(Level1[xpac,ypac+1]=6)or(Level1[xpac,ypac+1]=7);
delay(200);
repeat delay(15);nopac; dec(xpac); Pac; until (xpac=-10);
setcolor(white);
Outtextxy(240,220,'Au revoir '+n);
delay(3000);
end;
Procedure JEUSELECT;
{Procedure qui permet au joueur de jouer a un seul niveau
Elle est accessible par le menu principale.
C'est le meme prncipe que la procedure JEU, mais qui va seulement
jouer a un seul niveau.
VOIR PROCEDURE LEVELSELECT POUR PLUS DE DETAILS}
begin
Babouin:=0;
case Level of
1: begin
Level1e; {VOIR PROCEDURE JEU POUR PLUS DE DETAILS}
repeat bouger; pointage; if upcase(fleche)='R' then Level1e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
gameover;
end;
2: begin
Level2e;
repeat bouger;pointage;if upcase(fleche)='R' then Level2e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
gameover;
end;
3: begin
Level3e;
repeat bouger;pointage; if upcase(fleche)='R' then Level3e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
gameover;
end;
4: begin
Level4e;
repeat bouger;pointage; if upcase(fleche)='R' then Level4e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
gameover;
end;
5: begin
Level5e;
repeat bouger;pointage; if upcase(fleche)='R' then Level5e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
gameover;
end;
6: begin
Level6e;
repeat bouger;pointage; if upcase(fleche)='R' then Level6e;
if upcase(fleche)='X' then babouin:=2;
until(Level1[xpac,ypac]=3) or (Babouin=2) ; yay;Total:=total+point;
gameover;
end;
7: begin
Level7e;
repeat bouger;pointage; if upcase(fleche)='R' then Level7e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); Yay;Total:=total+point;
gameover;
end;
8: begin
Level8e;
repeat bouger; pointage; if upcase(fleche)='R' then Level8e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
gameover;
end;
9: if Babouin<> 2 then
begin
Level9e;
repeat bouger; pointage; if upcase(fleche)='R' then Level9e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
gameover;
end;
10:begin
Level10e;
repeat bouger; pointage; if upcase(fleche)='R' then Level10e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
gameover;
end;
end;
end;
Procedure Levelselect;
{Menu pour choisir le niveau que le joueur voudrait jouer.
En utilisant un readkey des chiffres 0 a 9, l'usager peut choisir de
jouer des niveau 1 a 10. Lorsqu'il choisi un niveau (en utilisant les chiffres
0 a 9 du clavier) le programme ira dans la procedure JEUSELECT qui
envoiera le joueur au bon niveau.}
begin
Total:=0;
Level:=0; {Remet la valeur de Level a 0}
cleardevice; {Efface l'ecran}
outtextxy(10,450,'Peser sur "X" pour quitter le jeu');
Outtextxy(10,465,'Peser sur n"importe quelle autre touche pour revenir au menu principale');
Outtextxy(275,100,'Selectionnez'); {Offre des choix au joueur}
setfillstyle(1,white);
Outtextxy(280,150,'1. Level 1');
Outtextxy(280,170,'2. Level 2');
Outtextxy(280,190,'3. Level 3');
Outtextxy(280,210,'4. Level 4');
Outtextxy(280,230,'5. Level 5');
Outtextxy(280,250,'6. Level 6');
Outtextxy(280,270,'7. Level 7');
Outtextxy(280,290,'8. Level 8');
Outtextxy(280,310,'9. Level 9');
Outtextxy(280,330,'0. Level 10');
fleche:=upcase(readkey); {Lit la touche pesee par l'usager}
case fleche of {D'apres la touche pesee, on donne une valeur
a la variable Level.}
'1':Level:=1;
'2':Level:=2;
'3':Level:=3;
'4':Level:=4;
'5':Level:=5;
'6':Level:=6;
'7':Level:=7;
'8':Level:=8;
'9':Level:=9;
'0':Level:=10;
end;
JEUselect; {D'apres la valeur de Level, JEUSELECT dirigera le joueur
au bon niveau.}
end;
procedure Instruction1;
{Premiere des 3 pages des instructions.
Presente les regles du jeu.}
begin
Page:=1; {Sera utilisee pour pourvoir changer de page dans la procedure menu}
cleardevice;
text:=chr(27); {chr(27) est le dessin d'une fleche}
outtextxy(10,460,text+ ' PAGE PRECEDENTE');
text:=chr(26); {chr(27) est le dessin d'une fleche}
outtextxy(500,460,'PAGE SUIVANTE '+text );
outtextxy(250,445, 'X = EXIT INSTRUCTIONS ');
outtextxy(250,460, 'TU PEUX LE FAIRE '+n);
Outtextxy(20,20,'1');
outtextxy(90,10,'Bienvenue aux instructions du jeu Slide Maze');
outtextxy(90,25,'Le but du jeu est simple, il suffit d"utiliser les 4 fleches');
outtextxy(90,40,'du clavier pour deplacer la boule dans la direction desiree');
outtextxy(90,55,'Pour passer un niveau, il faut que la boule blanche s"arrete');
outtextxy(90,70,'sur la cible. Si la boule blanche passe SUR la cible mais n"est');
outtextxy(90,85,'pas arretee, alors rien ne se passera.');
Outtextxy(90,150,'POINTAGE : Le pointage dans ce jeu fonctionne de la maniere');
Outtextxy(90,165,'suivante:au debut d"un niveau le joueur a 1000 points pour');
Outtextxy(90,180,'le niveau. Lorsqu"il appuie sur une des fleches du clavier');
Outtextxy(90,195,'et que le pion peut se deplacer dans le sens voulu, il');
Outtextxy(90,210,'perdera 25 points des mille points. Lorsque le niveau est');
Outtextxy(90,225,'reussi, le pointage du niveau complete s"ajoutera au total');
Outtextxy(90,240,'des points du jeu.Le jeu ayant 10 niveaux il sera donc');
Outtextxy(90,255,'impossible de faire plus que 10000 points au total.');
end;
procedure Instruction2;
{Deuxieme des 3 pages des instructions.
Presente les objets du jeu.}
begin
Page:=2; {Sera utilisee pour pourvoir changer de page dans la procedure menu}
cleardevice;
text:=chr(27);
outtextxy(10,460,text+ ' PAGE PRECEDENTE');
text:=chr(26);
outtextxy(500,460,'PAGE SUIVANTE '+text );
outtextxy(250,445, 'X = EXIT INSTRUCTIONS ');
outtextxy(250,460, 'TU PEUX LE FAIRE '+n);
outtextxy(100,100,'OBJETS DU JEU');
Outtextxy(20,20,'2');
{Cette prochaine section utilise le meme prncipe que dans la procedure
DESSINELELEVEL pour dessiner les objets du jeu. Voir procedure DESSINELELEVEL
pour voir en details le fontionnement.}
for x:= 1 to 12 do
for y:=1 to 12 do
Level1[x,y]:=0;
level1[3,5]:=2; level1[3,7]:=3; level1[3,9]:=1; for x:= 1 to 12 do
for y:= 1 to 12 do begin if Level1[x,y]=1 then cube
else if Level1[x,y]=2 then begin setfillstyle(1,white);fillellipse(180,180,19,19) end
else if Level1[x,y]=3 then win;end;
outtextxy(210,160,'VOUS : en utilisant les quatre fleches du');
outtextxy(210,170,' clavier il est possible de deplacer ce pion en');
outtextxy(210,180,'ligne droite a travers laire de jeu');
outtextxy(210,240,'Ceci est l"objectif a atteindre');
outtextxy(210,250,'Il faut que le pion blanc S"ARRETE sur celui-ci.');
outtextxy(210,260,'Si le pion blanc fait seulement passer dessus ');
outtextxy(210,270,'le niveau ne sera pas completee');
outtextxy(210,320,'Obstacle au pion blanc.');
outtextxy(210,330,'Le pion blanc s"arretera lorsqu"il frappera ce bloc');
outtextxy(210,340,'peu importe dans quel sens il se dirigeait.');
end;
procedure Instruction3;
{Premiere des 3 pages des instructions.
Presente les obstacles du jeu.}
begin
page:=3; {Sera utilisee pour pourvoir changer de page dans la procedure menu}
cleardevice;
text:=chr(27);
outtextxy(10,460,text+ ' PAGE PRECEDENTE');
text:=chr(26);
outtextxy(500,460,'PAGE SUIVANTE '+text );
outtextxy(250,445, 'X = EXIT INSTRUCTIONS ');
outtextxy(250,460, 'TU PEUX LE FAIRE '+n);
outtextxy(100,50,'OBSTACLES PARTICULIERS');
Outtextxy(20,20,'3');
{Cette prochaine section utilise le meme prncipe que dans la procedure
DESSINELELEVEL pour dessiner les objets du jeu. Voir procedure DESSINELELEVEL
pour voir en details le fontionnement.}
for x:= 1 to 12 do for y:= 1 to 12 do
Level1[x,y]:=0;
Level1[1,3]:=6;Level1[1,5]:=7;Level1[1,7]:=5;Level1[1,9]:=4;
for x:= 1 to 12 do for y:= 1 to 12 do
begin if Level1[x,y]=4 then godown else if Level1[x,y]=5 then goleft else
if Level1[x,y]=6 then goup else if Level1[x,y]=7 then goright; end;
Outtextxy(125,80,'Obstacle qui est seulement franchissable dans');
Outtextxy(125,90,'le sens des fleches.');
Outtextxy(125,100,'Si le pion blanc arrive dans n"importe quel autre sens, il ne');
Outtextxy(125,110,'pourra pas passer.');
Outtextxy(125,160,'Obstacle qui est seulement franchissable dans');
Outtextxy(125,170,'le sens des fleches.');
Outtextxy(125,180,'Si le pion blanc arrive dans n"importe quel autre sens, il ne');
Outtextxy(125,190,'pourra pas passer.');
Outtextxy(125,240,'Obstacle qui est seulement franchissable dans');
Outtextxy(125,250,'le sens des fleches.');
Outtextxy(125,260,'Si le pion blanc arrive dans n"importe quel autre sens, il ne');
Outtextxy(125,270,'pourra pas passer.');
Outtextxy(125,320,'Obstacle qui est seulement franchissable dans');
Outtextxy(125,330,'le sens des fleches.');
Outtextxy(125,340,'Si le pion blanc arrive dans n"importe quel autre sens, il ne');
Outtextxy(125,350,'pourra pas passer.');
end;
Procedure Menu;
{MENU PRINCIPALE DU JEU. Redirige le joueur vers le jeu, les instructions
ou un niveau en particulier.}
Procedure JEU;
{Procedure JEU. Contrairement a Jeuselect, cette procedure part du niveau 1
et va jusqu'au niveau 10. Apres avoir dessiner un niveau, L'utilisateur sera
libre de bouger dans la direction qu'il veux jusqu'a ce qu'il atteigne
la cible. Si l'utilisateur veux quitter le jeu pour revenir au menu il
peut peser sur X. S'il veux reinitialiser le niveau il n'a qu'a peser sur R.}
begin
Total:=0;
Babouin:=0;
if Babouin<> 2 then
begin
Level1e;
repeat bouger; pointage; if upcase(fleche)='R' then Level1e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2);
yay; {Son de reussite}
Total:=Total+point; {Augmente le total de points}
end;
if Babouin<> 2 then
begin
Level2e;
repeat bouger;pointage;if upcase(fleche)='R' then Level2e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level3e;
repeat bouger;pointage; if upcase(fleche)='R' then Level3e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level4e;
repeat bouger;pointage; if upcase(fleche)='R' then Level4e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level5e;
repeat bouger;pointage; if upcase(fleche)='R' then Level5e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level6e;
repeat bouger;pointage; if upcase(fleche)='R' then Level6e;
if upcase(fleche)='X' then babouin:=2;
until(Level1[xpac,ypac]=3) or (Babouin=2) ; yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level7e;
repeat bouger;pointage; if upcase(fleche)='R' then Level7e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); Yay;Total:=total+point;
end;
if Babouin<> 2 then
begin
Level8e;
repeat bouger; pointage; if upcase(fleche)='R' then Level8e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
end;
if Babouin<> 2 then
begin
Level9e;
repeat bouger; pointage; if upcase(fleche)='R' then Level9e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
end;
if Babouin<> 2 then
begin
Level10e;
repeat bouger; pointage; if upcase(fleche)='R' then Level10e;
if upcase(fleche)='X' then babouin:=2;
until (Level1[xpac,ypac]=3) or (Babouin=2); yay;Total:=Total+point;
end;
gameover;
end;
begin
repeat
cleardevice;
Outtextxy(250,200,'1. Lets play'); {Presente les options au joueur}
Outtextxy(250,215,'2. Comment jouer');
Outtextxy(250,230,'3. Choisir un niveau');
Outtextxy(250,245,'X. EXIT GAME');
setfillstyle(1,white);
fillellipse(200,120,20,20);
fillellipse(400,120,20,20); {Dessin des 4 cercles}
fillellipse(200,320,20,20);
fillellipse(400,320,20,20);
choix:=upcase(readkey);
case choix of {D'apres son choix, redirige le
programme dans la bonne procedure.}
'1': Jeu; {VOIR PROCEDURE JEU}
'2':
begin cleardevice;instruction1;
repeat
instruction:=upcase(readkey); {L'usager peut utiliser les fleches}
{du clavier pour feuilleter les }
case instruction of {pages des instructions}
{Chaque page possede une valeur (1 a 3) en pesant sur les fleches
du clavier, on pourra faire changer la valeur de la variable page}
#75: begin if page=1 then page:=3{}
else Page:=(page-1);end;
#77: begin if page=3 then page:=1
else Page:=(page+1);end;
end;
{Ensuite, on redessine la bonne page par rapport a la valeur que page
va avoir apres que la fleche du clavier soit pesee}
case page of
1: instruction1;
2:instruction2;
3:instruction3;
end;
until instruction='X';
end;
'3': Levelselect; {VOIR PROCEDURE LEVEL SELECT.}
end;
until choix='X'
end;
begin
{DEBUT DU PROGRAMME PRINCIPALE}
clrscr;
textcolor(white);
gotoxy(30,20);
writeln('Quel est ton nom?'); {Demande le nom a l'usager}
gotoxy(35,21);
readln(n); {Lit le nom de l'usager}
pilote:=detect; {Initie les fonctions graphiques}
initgraph(pilote,mode,'m:/bgi');
ouverture;
beginning; {Voir procedure BEGINNING}
Menu;
ending;
end.