Section courante

A propos

Section administrative du site

Conception du jeu

Si vous voulez écrire du code d'un jeu, la chose la plus importante que vous puissiez faire est de commencer par ne pas écrire de code. Il est très important de réfléchir d'abord à ce que vous faites et à la façon dont vous allez le faire fonctionner. Les jeux sont basés sur quelques concepts primaire et extrapoler par la suite.

Sachant que le jeu Pac-Man est un labyrinthe, la tendance nature, c'est immédiatement réfléchir une représentation d'un labyrinthe. Nous allons avoir besoin d'une structure de mémoire pour l'affichage à l'écran. Un tableau conviendra parfaitement a avoir un cette représentation. Nous aurons alors une procédure, nommé DisplayNewBoard affichant l'écran contenu dans le tableau «Screen» pour avoir une représentation de ce labyrinthe.

Nous devons également concevoir des graphiques pour chacune des cellules de ce labyrinthes ou tableau en mémoire. Étant données que le jeu doit fonctionner dans un écran de texte ou un terminal, nous n'avons pas vraiment le choix, nous allons devoir utiliser des caractères de texte correspondant le mieux à la présentation du jeu. Le Free Pascal n'est pas fameux avec sa police de caractères texte, il ne supporte correctement que les codes ASCII 32 à 127. Il est franchement beaucoup plus médiocre que le Quick Pascal, Turbo Pascal ou le HighSpeed Pascal et les nombreux compilateurs Pascal dans années 1980. Voici la liste des cellules du tableau :

Valeur Description
0 Noir, aucune image
1 Pastille ou point
2 Pilule de puissance
3 Mur horizontal
4 Mur vertical
5 Coin inférieur gauche du mur
6 Coin inférieur droit du mur
7 Coin supérieur gauche du mur
8 Coin supérieur droit du mur
9 Extrémité gauche du mur
10 Extrémité droite du mur
11 Extrémité supérieure du mur
12 Extrémité inférieure du mur
13 Jonction murale en T Droite
14 Jonction murale en T Gauche
15 Jonction murale en T vers le bas
16 Jonction du mur en T vers le haut
17 La porte de la maison des fantômes

On aura également les cellules suivantes sous-entendu :

Variable Description
PlayerX, PlayerY, PlayerDirection Pac-Man vue de gauche
PlayerX, PlayerY, PlayerDirection Pac-Man vue de droite
PlayerX, PlayerY, PlayerDirection Pac-Man vue vers le haut
PlayerX, PlayerY, PlayerDirection Pac-Man vue vers le bas
Ghosts Fantôme (Nous tricherons et utiliserons le même)

Données initiale

Lorsque le Pac-Man se déplace et qu'il y a une pastille, il remplace la cellule mémoire et met un zéro. Ainsi, il est possible grâce à cette technique de savoir exactement où les pastilles sont présentes même si fantôme passe dessus et qu'il est effacer par accident. L'ennui, c'est que lorsqu'on modifie le tableau, il n'est plus utilisable pour le niveau suivant. Ainsi, pour résoudre le problème, nous devons copier le tableau origine à chaque InitialScreen dans la variable Screen à chaque changement de niveau. De plus à chaque fois que Pac-Man perd une vie ou qu'il change de niveau, il faut initialiser certaines données initiales sauf bien sur le pointage, le nombre de pilule mangé et le niveau.

Faire jouer Pac-Man et les fantômes

Cette partie est la plus complexe, nous devons perpétuellement faire bouger le personnage Pac-Man et les fantômes. Mais en même temps, nous devons vérifier les mouvements demander par le joueur sur le clavier (cette fonction KeyPressed si une touche est enfoncé et ReadKey permet de lire une touche sur le clavier). Pour arriver au résultat voulu, nous devons impérativement avoir un traitement de déplacement des fantômes et continuer de déplacer le personnage Pac-Man en chaque déplacement. Sauf, que si vous cela à chaque fois, plus la machine sera rapide, plus le Pac-Man et les fantômes se déplaceront rapidement et ils ont le temps d'attraper votre Pac-Man avant même que vous n'ayez bougé ! Pour résoudre se problème, on doit obligatoirement faire attendre le programme 1/4 de secondes (soit 250 millièmes de secondes indiquer par la procédure Delay(250)). Aussi, par le fait même, étant donné qu'on attend pas après l'utilisateur pour déplacer le personnage Pac-Man, est fait juste prendre en note la direction vers lequel le joueur souhaite déplacer le personnage Pac-Man et provoquer le déplacement dans la boucle KeyPressed.

On veut également donner un semblant d'impression d'animation à notre personnage Pac-Man. Pour y arriver, un déplacement sur deux, on change l'image ou le caractère affiché, cette technique donne l'impression au joueur que le personnage à une démarche comme un être humain. Le principe est le même pour déplacer des personnages dans un écran graphique, on fait une rotation entre 2 ou plusieurs images pour donner l'impression que le personnage bouge jusqu'à 60 différentes par secondes dans les jeux les plus réalistes. Mais dans le cas d'un écran de texte, comme cette exemple de jeu, nous nous contentons de 2 seulement.

Surveillance des actions

Le jeux ne se content pas de déplacer des personnages, le but de Pac-Man est de manger toutes les pastilles avant que l'un des 4 fantômes ne l'attrape. Il faut donc compter le nombre de pastille manger par Pac-Man à chaque déplacement avec la variable CountPilule, vérifier si les 212 pilules ont été manger et si c'est le cas changer de niveau. Aussi, si Pac-Man se fait attraper par l'un des 4 fantômes, on doit enlever une vie et déplacer Pac-Man et les fantômes à sa position de départ en réinitialisant les données initiales (InitData).

Le jeu complet

Voici le code source Free Pascal du jeu Pac-Man complet :

  1. { @author: Sylvain Maltais (support@gladir.com)
  2. @created: 2021
  3. @website(https://www.gladir.com/7iles)
  4. @abstract(Target: Free Pascal)
  5. }
  6.  
  7. Program PacMan;
  8.  
  9. Uses CRT;
  10.  
  11. Const
  12.  {Code de touche clavier renvoyee par ReadKey}
  13.  kbNoKey=0;{Pas de touche}
  14.  kbEsc=$011B;{Escape}
  15.  kbUp=$4800;{Up}
  16.  kbLeft=$4B00;{Fleche de gauche (Left)}
  17.  kbKeypad5=$4CF0;{5 du bloc numerique}
  18.  kbRight=$4D00;{Fleche de droite (Right)}
  19.  kbDn=$5000;{Fleche du bas (Down)}
  20.  
  21. Type
  22.  ScreenArray=Array[0..23] of Array[0..30] of Byte;
  23.  
  24. Const
  25.  InitialScreen:ScreenArray = (
  26.   (00,00,07,03,03,03,03,03,03,03,03,03,03,03,03,16,03,03,03,03,03,03,03,03,03,03,03,03,08,00,00),
  27.   (00,00,04,01,01,01,01,01,01,01,01,01,01,01,01,04,01,01,01,01,01,01,01,01,01,01,01,01,04,00,00),
  28.   (00,00,04,01,07,03,03,08,01,07,03,03,03,08,01,04,01,07,03,03,03,08,01,07,03,03,08,01,04,00,00),
  29.   (00,00,04,02,05,03,03,06,01,05,03,03,03,06,01,12,01,05,03,03,03,06,01,05,03,03,06,02,04,00,00),
  30.   (00,00,04,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,04,00,00),
  31.   (00,00,04,01,09,03,03,10,01,11,01,09,03,03,03,16,03,03,03,10,01,11,01,09,03,03,10,01,04,00,00),
  32.   (00,00,04,01,01,01,01,01,01,04,01,01,01,01,01,04,01,01,01,01,01,04,01,01,01,01,01,01,04,00,00),
  33.   (00,00,05,03,03,03,03,08,01,14,03,03,03,10,00,12,00,09,03,03,03,13,01,07,03,03,03,03,06,00,00),
  34.   (00,00,00,00,00,00,00,04,01,04,00,00,00,00,00,00,00,00,00,00,00,04,01,04,00,00,00,00,00,00,00),
  35.   (00,00,00,00,00,00,00,04,01,04,00,07,03,03,10,17,09,03,03,08,00,04,01,04,00,00,00,00,00,00,00),
  36.   (09,03,03,03,03,03,03,06,01,12,00,04,00,00,00,00,00,00,00,04,00,12,01,05,03,03,03,03,03,03,10),
  37.   (00,00,00,00,00,00,00,00,01,00,00,04,00,00,00,00,00,00,00,04,00,00,01,00,00,00,00,00,00,00,00),
  38.   (09,03,03,03,03,03,03,08,01,11,00,04,00,00,00,00,00,00,00,04,00,11,01,07,03,03,03,03,03,03,10),
  39.   (00,00,00,00,00,00,00,04,01,04,00,05,03,03,03,03,03,03,03,06,00,04,01,04,00,00,00,00,00,00,00),
  40.   (00,00,00,00,00,00,00,04,01,04,00,00,00,00,00,00,00,00,00,00,00,04,01,04,00,00,00,00,00,00,00),
  41.   (00,00,07,03,03,03,03,06,01,12,00,09,03,03,03,16,03,03,03,10,00,12,01,05,03,03,03,03,08,00,00),
  42.   (00,00,04,01,01,01,01,01,01,01,01,01,01,01,01,04,01,01,01,01,01,01,01,01,01,01,01,01,04,00,00),
  43.   (00,00,04,01,09,03,03,08,01,09,03,03,03,10,01,12,01,09,03,03,03,10,01,07,03,03,10,01,04,00,00),
  44.   (00,00,04,02,01,01,01,04,01,01,01,01,01,01,01,00,01,01,01,01,01,01,01,04,01,01,01,02,04,00,00),
  45.   (00,00,14,03,03,10,01,12,01,11,01,09,03,03,03,16,03,03,03,10,01,11,01,12,01,09,03,03,13,00,00),
  46.   (00,00,04,01,01,01,01,01,01,04,01,01,01,01,01,04,01,01,01,01,01,04,01,01,01,01,01,01,04,00,00),
  47.   (00,00,04,01,09,03,03,03,03,15,03,03,03,10,01,12,01,09,03,03,03,15,03,03,03,03,10,01,04,00,00),
  48.   (00,00,04,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,01,04,00,00),
  49.   (00,00,05,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,03,06,00,00)
  50. );
  51.  
  52. Type
  53.  DirectionType=(pLeft,pRight,pUp,pDown);
  54.  
  55. Var
  56.  MouthOpen:Boolean;
  57.  Screen:ScreenArray;
  58.  ChaseTimer:Byte;
  59.  ChaseGhost:Byte;
  60.  CountPilule:Byte;
  61.  Level,Live,Score,HiScore:LongInt;
  62.  PlayerX,PlayerY:Byte;
  63.  PlayerDirection:DirectionType;
  64.  Ghosts:Array[0..3]of Record
  65.   X,Y:Byte;
  66.   Direction:DirectionType;
  67.   Status:(Scatter,Chase);
  68.   IsFrightened:Boolean;
  69.   IsHome:Boolean;
  70.   DotCount:Boolean;
  71.   Speed:Byte;
  72.  End;
  73.  
  74. Procedure InitData;
  75. Var
  76.  I:Byte;
  77. Begin
  78.  Score:=0;
  79.  PlayerX:=15;
  80.  PlayerY:=18;
  81.  PlayerDirection:=pLeft;
  82.  Ghosts[0].X:=15;Ghosts[0].Y:=12;Ghosts[0].DotCount:=False;
  83.  Ghosts[1].X:=10;Ghosts[1].Y:=14;Ghosts[1].DotCount:=True;
  84.  Ghosts[2].X:=10;Ghosts[2].Y:=16;Ghosts[2].DotCount:=True;
  85.  Ghosts[3].X:=10;Ghosts[3].Y:=9;Ghosts[3].DotCount:=True;
  86.  For I:=0 to 3 do Begin
  87.   Ghosts[I].Direction:=pLeft;
  88.   Ghosts[I].Status:=Scatter;
  89.   Ghosts[I].IsFrightened:=False;
  90.   Ghosts[I].IsHome:=True;
  91.  End;
  92. End;
  93.  
  94. Function Distance(X1,Y1,X2,Y2:Byte):Byte;
  95. Var
  96.  A,B:Byte;
  97. Begin
  98.  A:=Abs(X1-X2);
  99.  B:=Abs(Y1-Y2);
  100.  Distance:=Byte(Trunc(Sqrt(A*A+B*B)));
  101. End;
  102.  
  103. Function AvailableLeft(X,Y:Byte):Boolean;Begin
  104.  AvailableLeft:=Screen[Y,X-1]<=2;
  105. End;
  106.  
  107. Function AvailableRight(X,Y:Byte):Boolean;Begin
  108.  AvailableRight:=Screen[Y,X+1]<=2;
  109. End;
  110.  
  111. Function AvailableUp(X,Y:Byte):Boolean;Begin
  112.  AvailableUp:=Screen[Y-1,X]<=2;
  113. End;
  114.  
  115. Function AvailableDown(X,Y:Byte):Boolean;Begin
  116.  AvailableDown:=Screen[Y+1,X]<=2;
  117. End;
  118.  
  119. Procedure FindDirection(I:Byte);Begin
  120.  If PlayerX < Ghosts[I].X Then Begin
  121.   If AvailableLeft(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pLeft
  122.    Else
  123.   Begin
  124.    If PlayerY < Ghosts[I].Y Then Begin
  125.     If AvailableUp(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pUp Else
  126.     If AvailableDown(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pDown
  127.                                              Else Ghosts[I].Direction:=pRight
  128.    End;
  129.   End;
  130.  End
  131.   Else
  132.  If PlayerX > Ghosts[I].X Then Begin
  133.   If AvailableRight(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pRight
  134.    Else
  135.   Begin
  136.    If PlayerY < Ghosts[I].Y Then Begin
  137.     If AvailableUp(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pUp Else
  138.     If AvailableDown(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pDown
  139.                                              Else Ghosts[I].Direction:=pLeft;
  140.    End;
  141.   End;
  142.  End
  143.   Else
  144.  If PlayerY < Ghosts[I].Y Then Begin
  145.   If AvailableUp(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pUp
  146.    Else
  147.   Begin
  148.    If PlayerX < Ghosts[I].X Then Begin
  149.     If AvailableLeft(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pLeft Else
  150.     If AvailableRight(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pRight
  151.                                               Else Ghosts[I].Direction:=pDown;
  152.    End;
  153.   End;
  154.  End
  155.   Else
  156.  Begin
  157.   If AvailableDown(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pDown
  158.    Else
  159.   Begin
  160.    If PlayerX < Ghosts[I].X Then Begin
  161.     If AvailableLeft(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pLeft Else
  162.     If AvailableRight(Ghosts[I].X,Ghosts[I].Y)Then Ghosts[I].Direction:=pRight
  163.                                              Else Ghosts[I].Direction:=pUp;
  164.    End;
  165.   End;
  166.  End;
  167. End;
  168.  
  169. Procedure RemovePacMan;Begin
  170.  GotoXY(1+PlayerX,1+PlayerY);
  171.  Write(' ');
  172. End;
  173.  
  174. Procedure RemoveGhost(I:Byte);Begin
  175.  GotoXY(1+Ghosts[I].X,1+Ghosts[I].Y);
  176.  Case Screen[Ghosts[I].Y,Ghosts[I].X]of
  177.   1:Begin
  178.    TextColor(12);
  179.    Write('.');
  180.   End;
  181.   2:Begin
  182.    TextColor(13);
  183.    Write('O');
  184.   End;
  185.   Else Write(' ');
  186.  End;
  187. End;
  188.  
  189. Function CheckCell:Boolean;
  190. Var
  191.  I:Byte;
  192. Begin
  193.  CheckCell:=False;
  194.  Case Screen[PlayerY,PlayerX]of
  195.   1:Begin
  196.    Inc(Score,10);
  197.    Inc(CountPilule);
  198.    If CountPilule>=212Then CheckCell:=True;
  199.   End;
  200.   2:Begin
  201.    Inc(Score,50);
  202.    For I:=0 to 3do Ghosts[I].Status:=Chase;
  203.    ChaseTimer:=100;
  204.    ChaseGhost:=0;
  205.   End;
  206.  End;
  207.  Screen[PlayerY,PlayerX]:=0;
  208.  GotoXY(1,25);
  209.  TextColor(15);
  210.  Write('Niveau : ',Level,' Pointage : ',Score,' Vie : ',Live);
  211.  If ChaseTimer>0Then Write('Temps : ',ChaseTimer,' Attraper : ',ChaseGhost);
  212.  ClrEol;
  213. End;
  214.  
  215. Procedure DisplayNewBoard;
  216. Var
  217.  X,Y:Byte;
  218. Begin
  219.  TextBackground(0);
  220.  For Y:=0 to 23 do Begin
  221.   For X:=0 to 30 do Begin
  222.    GotoXY(X+1,Y+1);
  223.    Case Screen[Y,X]of
  224.     1:Begin
  225.      TextColor(12);
  226.      Write('.');
  227.     End;
  228.     2:Begin
  229.      TextColor(13);
  230.      Write('O');
  231.     End;
  232.     3:Begin
  233.      TextColor((8+Level)and $F);
  234.      Write('=');
  235.     End;
  236.     4:Begin
  237.      TextColor((8+Level)and $F);
  238.      Write('I');
  239.     End;
  240.     5..16:Begin
  241.      TextColor((8+Level)and $F);
  242.      Write('+');
  243.     End;
  244.     17:Begin
  245.      TextColor(15);
  246.      Write('-');
  247.     End;
  248.     Else Write(' ');
  249.    End;
  250.   End;
  251.  End;
  252. End;
  253.  
  254. Procedure Play;
  255. Var
  256.  K:Word;
  257.  I:Byte;
  258. Begin
  259.  GotoXY(1+PlayerX,1+PlayerY);
  260.  TextColor(14);
  261.  Write(')');
  262.  Repeat
  263.   Repeat
  264.    If ChaseTimer>0Then Dec(ChaseTimer);
  265.    Case PlayerDirection of
  266.     pUp:If AvailableUp(PlayerX,PlayerY)Then Begin
  267.      RemovePacman;
  268.      PlayerY:=PlayerY-1;
  269.      If CheckCell Then Begin
  270.       CountPilule:=0;
  271.       Write('NIVEAU COMPLETE !!');
  272.       Delay(2000);
  273.       Inc(Level);
  274.       Screen:=InitialScreen;
  275.       InitData;
  276.       DisplayNewBoard;
  277.      End;
  278.      GotoXY(1+PlayerX,1+PlayerY);
  279.      If ChaseTimer>0Then TextBackground(10)
  280.                     Else TextBackground(0);
  281.      TextColor(14);
  282.      MouthOpen:=Not MouthOpen;
  283.      If(MouthOpen)Then Write('U')
  284.                   Else Write('o');
  285.      TextBackground(0);
  286.     End;
  287.     pDown:If AvailableDown(PlayerX,PlayerY)Then Begin
  288.      RemovePacman;
  289.      PlayerY:=PlayerY+1;
  290.      If CheckCell Then Begin
  291.       CountPilule:=0;
  292.       Write('NIVEAU COMPLETE !!');
  293.       Delay(2000);
  294.       Inc(Level);
  295.       Screen:=InitialScreen;
  296.       InitData;
  297.       DisplayNewBoard;
  298.      End;
  299.      GotoXY(1+PlayerX,1+PlayerY);
  300.      If ChaseTimer>0Then TextBackground(10)
  301.                     Else TextBackground(0);
  302.      TextColor(14);
  303.      MouthOpen:=Not MouthOpen;
  304.      If(MouthOpen)Then Write('A')
  305.                   Else Write('o');
  306.      TextBackground(0);
  307.     End;
  308.     pLeft:If AvailableLeft(PlayerX,PlayerY)Then Begin
  309.      RemovePacman;
  310.      If PlayerX<2 Then PlayerX:=28
  311.                   Else PlayerX:=PlayerX-1;
  312.      If CheckCell Then Begin
  313.       CountPilule:=0;
  314.       Write('NIVEAU COMPLETE !!');
  315.       Delay(2000);
  316.       Inc(Level);
  317.       Screen:=InitialScreen;
  318.       InitData;
  319.       DisplayNewBoard;
  320.      End;
  321.      If ChaseTimer>0Then TextBackground(10)
  322.                     Else TextBackground(0);
  323.      GotoXY(1+PlayerX,1+PlayerY);
  324.      TextColor(14);
  325.      MouthOpen:=Not MouthOpen;
  326.      If(MouthOpen)Then Write(')')
  327.                   Else Write('o');
  328.      TextBackground(0);
  329.     End;
  330.     pRight:If AvailableRight(PlayerX,PlayerY)Then Begin
  331.      RemovePacman;
  332.      If PlayerX>28 Then PlayerX:=2
  333.                    Else PlayerX:=PlayerX+1;
  334.                         If ChaseTimer>0Then TextBackground(10)
  335.                     Else TextBackground(0);
  336.      If CheckCell Then Begin
  337.       CountPilule:=0;
  338.       Write('NIVEAU COMPLETE !!');
  339.       Delay(2000);
  340.       Inc(Level);
  341.       Screen:=InitialScreen;
  342.       InitData;
  343.       DisplayNewBoard;
  344.      End;
  345.      GotoXY(1+PlayerX,1+PlayerY);
  346.      TextColor(14);
  347.      MouthOpen:=Not MouthOpen;
  348.      If(MouthOpen)Then Write('(')
  349.                   Else Write('o');
  350.      TextBackground(0);
  351.     End;
  352.    End;
  353.    For I:=0 to 3 do Begin
  354.     Case Ghosts[I].Direction of
  355.      pLeft:If AvailableLeft(Ghosts[I].X,Ghosts[I].Y)Then Begin
  356.       RemoveGhost(I);
  357.       Ghosts[I].X:=Ghosts[I].X-1;
  358.       {CheckCellGhost;}
  359.       GotoXY(1+Ghosts[I].X,1+Ghosts[I].Y);
  360.       TextColor(10+I);
  361.       Write('f');
  362.      End
  363.       Else
  364.      FindDirection(I);
  365.      pRight:If AvailableRight(Ghosts[I].X,Ghosts[I].Y)Then Begin
  366.       RemoveGhost(I);
  367.       Ghosts[I].X:=Ghosts[I].X+1;
  368.       {CheckCellGhost;}
  369.       GotoXY(1+Ghosts[I].X,1+Ghosts[I].Y);
  370.       TextColor(10+I);
  371.       Write('f');
  372.      End
  373.       Else
  374.      FindDirection(I);
  375.      pUp:If AvailableUp(Ghosts[I].X,Ghosts[I].Y)Then Begin
  376.       RemoveGhost(I);
  377.       Ghosts[I].Y:=Ghosts[I].Y-1;
  378.       {CheckCellGhost;}
  379.       GotoXY(1+Ghosts[I].X,1+Ghosts[I].Y);
  380.       TextColor(10+I);
  381.       Write('f');
  382.      End
  383.       Else
  384.      FindDirection(I);
  385.      pDown:If AvailableDown(Ghosts[I].X,Ghosts[I].Y)Then Begin
  386.       RemoveGhost(I);
  387.       Ghosts[I].Y:=Ghosts[I].Y+1;
  388.       {CheckCellGhost;}
  389.       GotoXY(1+Ghosts[I].X,1+Ghosts[I].Y);
  390.       TextColor(10+I);
  391.       Write('f');
  392.      End
  393.       Else
  394.      FindDirection(I);
  395.     End;
  396.     If(Ghosts[I].X=PlayerX)and(Ghosts[I].Y=PlayerY)Then Begin
  397.      If ChaseTimer>0 Then Begin
  398.       Inc(ChaseGhost);
  399.       Inc(Score,200*ChaseGhost);
  400.       Ghosts[I].X:=18;
  401.       Ghosts[I].Y:=9;
  402.      End
  403.       Else
  404.      If Live=1Then Begin
  405.       Write('PARTIE TERMINER !');
  406.       Exit;
  407.      End
  408.       Else
  409.      Begin
  410.       Write('ATTRAPPER !');
  411.       Delay(2000);
  412.       Dec(Live);
  413.       InitData;
  414.       DisplayNewBoard;
  415.      End;
  416.     End;
  417.    End;
  418.    Delay(250);
  419.   Until Keypressed;
  420.   K:=Byte(ReadKey);
  421.   If K=0Then K:=K or (Byte(ReadKey)shl 8);
  422.   If Chr(Lo(K))='2'Then K:=kbDn;
  423.   If Chr(Lo(K))='4'Then K:=kbLeft;
  424.   If Chr(Lo(K))='6'Then K:=kbRight;
  425.   If Chr(Lo(K))='8'Then K:=kbUp;
  426.   Case K of
  427.    kbUp:If AvailableUp(PlayerX,PlayerY)Then PlayerDirection:=pUp;
  428.    kbDn:If AvailableDown(PlayerX,PlayerY)Then PlayerDirection:=pDown;
  429.    kbLeft:If AvailableLeft(PlayerX,PlayerY)Then PlayerDirection:=pLeft;
  430.    kbRight:If AvailableRight(PlayerX,PlayerY)Then PlayerDirection:=pRight;
  431.   End;
  432.  Until(K=kbEsc)or(Chr(Lo(K))in['q','Q']);
  433. End;
  434.  
  435. BEGIN
  436.  ClrScr;
  437.  Screen:=InitialScreen;
  438.  HiScore:=0;
  439.  Live:=4;
  440.  Level:=1;
  441.  CountPilule:=0;
  442.  InitData;
  443.  DisplayNewBoard;
  444.  Play;
  445. END.

Code source

Voici le code source du jeu sur GitHub :

Lien Langage de programmation Projet
https://github.com/gladir/7iles/blob/main/PACMAN.PAS Free Pascal 7iles


Dernière mise à jour : Dimanche, le 12 septembre 2021