Julien Durieux

Rémi Duhautoy

1^ère année groupe C

I .U.T. Amiens

Compte-Rendu

LANGAGE C

Super Hyper Mega

Extra Version Gold Deluxe


Année 2001 – 2002	Pour M. FOFI

..:: SommairE ::..

	I	Fiche Technique	Page
1	Fichiers	Les noms des fichiers utilisés.	3
2	Compilation	Toutes les explications pour réussir à compiler le fichier source.	3
3	Description	Qu’est-ce que Pacman ?	4
4	Auteurs	Le nom des auteurs et comment les contacter.	4

	II	Interface	Page
1	Menu	Quelques infos sur le fonctionnement du menu.	5
2	Jouer	Comment avoir et saisir un code.	5
3	Options	Quelles sont les options paramétrables ?	6
4	Touches	Les touches à utiliser pendant le jeu.	6
5	H.U.D.	Les infos données à l’écran.	6

	III	Code & Algo	Page
1	Main.cpp	Explications du code de main.cpp, le fichier principal.	7
2	Affiche.h	Explications du code du header affiche.h, qui affiche les scores.	9
3	Draw.h	Explications du code du header draw.h, qui affiche les dessins.	10
4	Menu.h	Explications du code du header menu.h, qui gère le menu.	11
5	Extra.h	Toutes les autres fonctions non classables.	12
A	Déplacer	Comment se déplace-t-on et comment fonctionne l’I.A. ?	13
B	Dessiner	Comment dessine-t-on Pacman et le monstre ?	15

	IV	Modifications	Page
1	Carte	Comment faire sa propre carte de jeu.	16
2	Niveaux	Comment changer l’ordre et le nombre de cartes dans une partie.	17
3	Options	Comment fonctionne le fichier options.	17
4	Tricher	Comment tricher.	17

I] FichE TechniquE

1	Fichiers
	Les fichiers contenant le code source du jeu : main.cpp : fichier source principal. affiche.h : header avec fonctions d'affichage des scores. draw.h : header avec fonctions de dessin. extra.h : header avec les autres fonctions non classables. menu.h : header avec les fonctions permettant de gérer le menu.
	Les fichiers externes permettant de jouer : nivo.map : tous les niveaux à lancer durant le jeu. nivoXX.map : niveau n°XX du jeu. options.map : options du jeu. readme.txt : fichier d'aide et d'information. score.map : high scores du jeu, avec nom et score.
	Les fichiers externes au programme : bold.chr : fichier de police de caractère DOS. litt.chr : fichier de police de caractère DOS. egavga.bgi : extension graphique EGA/VGA.

2	Compilation
	Le compilateur utilisé est Borland ® Turbo C++ 3.0. Le programme est fait en langage C. Les librairies graphiques du compilateur sont utilisées.
	Plusieurs options doivent être modifiée pour permettre la compilation du jeu : Mémoire Large : options/compiler/code generation/model->large Graphics.h ON : options/linker/librairies->Graphics Librairy ON Tas 256 ko : options/debugger/program heap size->256 ko Chemin : file/change dir…
	Les bugs connus qui arrivent aléatoirement mais relativement peu souvent : Touches : Pour faire avancer Pacman, il suffit d’une simple pression sur la touche pour donner la direction du Pacman. Si on reste trop souvent appuyé sur la touche, le jeu peut se bloquer, certainement à cause du buffer du clavier trop remplit. La fonction fflush(stdin) a été utilisée et le problème semble réglé. Mémoire : le jeu peut provoquer certaines erreurs de mémoire, même avec les options du compilateur à fond. Le problème semble réglé avec des allocations de mémoire plus strictes et des passage par adresse dans les procédures.

3	Description
	Pacman est un grand classique, d’ailleurs ce fut le premier héros du jeu vidéo, longtemps avant Mario, en 1980. Développé par NAMCO ®, il fut l'un des plus grand succès en arcade de tous les temps.
	Le but du joueur est de récolter toutes les petites boules blanches du niveau sans se faire dévorer par les vilains monstres pas beaux. Celui qui en dévore le plus entre dans le high scores ! Le tout se déroule dans de nombreux niveaux variés.
	Notre but (celui des programmeurs) est avant tout de créer un jeu évolutif, non répétitif, modulable, simple d’accès et beau graphiquement (avec les faibles possibilités offertes par l’environnement DOS). Evolutif et modulable dans le sens où le jeu est très personnalisable. On peut tricher, on peut créer ses propres cartes pour jouer, on peut personnaliser le jeu sans rien reprogrammer ou recompiler. Non répétitif car les décors sont sans cesse changé et que les maps sont toutes très différentes, allant du simple niveau carré au labyrinthe complexe. Simple d’accès puisque le menu est clair, les touches et les mouvements sont simples et que les objectifs sont compréhensibles par tous. Surtout qu’un PC puissant n’est pas forcément requis. Beau graphiquement car une bonne partie de la programmation s’est résumée à tester différents aspects pour Pacman, différentes sortes de textures pour les murs, différentes formes monstrueuses … pour les monstres. D’ailleurs le son n’est pas en reste et l’introduction du jeu en est la preuve.

Auteurs

Les deux programmeurs/designers du projet :

Julien "BeLZeL" DURIEUX (belzel@free.fr)

Rémi "The SetFillStyle" DUHAUTOY (re-mail@9online.fr)

Remerciements particulier :

A Samuel "Sergio Wesh Wesh" MONTEIRO pour la création de nombreux niveaux originaux.

II] InterfacE

Menu

Le menu est constitué de quatre boutons principaux :

Jouer

Ce menu est expliquer plus en détail après. Il permet tout simplement de commencer une partie.

Options

Vous pouvez personnaliser le jeu via le menu des options.

Aide

Vous pouvez lire la petite aide du jeu. Vous trouverez néanmoins plus d’infos dans le fichier texte readme.txt (ou ici).

Quitter

Ce bouton permet de quitter le jeu. Pour quitter le jeu durant une partie, appuyez sur Entrée.

Dans chaque sous menu présenté plus haut, vous avez le choix de confirmer (Ok) ou d’annuler (Annuler) vos modifications en cliquant sur le bouton correspondant. A noter aussi que lorsque vous placez le curseur de la souris sur un bouton, son contour change de couleur.

Jouer

Le menu Jouer permet au joueur de choisir entre deux possibilités pour commencer une partie :

Jouer seul

Une nouvelle partie se lance automatiquement. C’est le choix qu’il faut faire si vous lancez le jeu pour la première fois.

Entrez un code

Le joueur peut entrer un code de 8 caractères, lui permettant de retourner à n’importe quel niveau déjà fini.

Options

Vous choisissez votre sous menu avec les flèches haut/bas et vous changez les valeurs avec les flèches gauche/droit.

Son [ ON / OFF ]

Vous pouvez choisir de laisser le son ou de le couper pour ne gêner personne.

Couleur Pacman

Vous pouvez choisir la couleur de votre Pacman. La couleur par défaut reste le jaune, mais tout autre couleur peut être utilisée, à part la couleur de BackGround.

Couleur Background

Vous pouvez choisir la couleur de l’arrière plan des cartes. Par défaut, la couleur est le rouge clair. Là, toutes les couleurs sont possibles, sauf le blanc.

Touches

Les touches utilisées pendant le jeu sont simples.

Dans le menu, vous devez utiliser la souris pour faire votre choix. Pour faire des changements ou changer de sous menu, vous devez utiliser les touches fléchées.

Durant le jeu, il faut utiliser les touches fléchées pour les directions (haut, bas, gauche, droite). La touche Entrée sert à quitter.

H.U.D.

Le High Scores affiche les meilleurs scores réalisés avec le jeu. Il y a, à gauche, le nom du joueur, suivi de son score. Le tout est classé par ordre du plus gros score.

Les Points sont comptabilisés par rapport au nombre de boules blanches mangées. A chaque fois, le nombre de points augmente d’une unité.

Les Vies sont allouées au départ du jeu. Elles sont au nombre de cinq par défaut. Dès que vous vous faites manger par un monstre, vous perdez une vie. Si vous n’avez plus de vie et que vous mourrez, le jeu est terminé.

Les Bonus ne sont pas implémentés dans cette version.

Le Temps n’est pas un facteur important. Il n’y a pas de limite de temps pour finir un niveau. Il est juste là à titre indicatif.

Le Niveau est le nom actuel du niveau.

III] CodE & AlgO

1	Main.cpp
	Les headers du compilateur utilisés : #include <graphics.h> // Header graphique #include <conio.h> // Header pour la console #include <stdio.h> // Header d'entrée/sortie #include <dos.h> // Header pour les fonctions dos #include <stdlib.h> // Header pour les lib. standard #include <math.h> // Header pour les maths #include <string.h> // Header pour les chaines #include <bios.h> // Header pour les touches
	Les constantes utilisées : #define EXIT { fclose(fichier); exit(0); } // permet de quitter plus rapidement un fichier #define T_CASE 20 // taille d'une case (en pixel) #define T_CASE_2 10 // taille d'une demi-case Les constantes utilisées pour les maps : #define M_SOL 0 // sol sans boule #define M_SOLB 1 // sol avec boule #define M_PACMAN 2 // point de départ du pacman #define M_MONSTRE 3 // point de départ des monstres #define M_BONUS 4 // emplacement des bonus #define M_CLE 5 // emplacement d'une clé #define M_PORTE 6 // emplacement d'une porte #define M_MUR 7 // emplacement des murs
	Les structures utilisées : La structure du jeu : struct struct_jeu { int nivo; // niveau en cours int score; // score du joueur int sec; // secondes et ... int min; // minutes de jeu char nom[10]; // nom du joueur int son; // son (1:activé) int nb_nivo; // nombre de niveaux int bkground; // couleur de background int min_score; // score mini au highscore struct struct_nivo { char nom_map[15]; // nom d'une map } path[50]; // nombre de maps chargées struct struct_score // chargement des maps { char nom[15]; // nom du joueur au highscore int points; // avec ses points } hscore[5]; // chargement des high scores } jeu; // structure de la partie La structure des boutons du menu : typedef struct { int x1, x2; // coin hg du bouton int y1, y2; // coin bd du bouton int etat; // etat (mouseover, clic) char text[25]; // nom du bouton } struct_boutons; La structure des maps : typedef struct { int val[20][20]; // matrice de la carte (x et y) int width; // largeur (en case) int height; // hauteur (en case) int coinx; // haut gauche (x) int coiny; // haut gauche (y) char nom[20]; // nom de la map long int code; // code barre de la map int boules; // compte le nombre de boules int load; // map chargée (0:non / 1:oui) int nb_monstres; // nombre de monstres } struct_map; // nom de la structure La structure du pacman : typedef struct { int touch1; // première touche appuyée int touch2; // seconde touche appuyée float startx; // position de départ (x) float starty; // position de départ (y) float x; // position réel de Pacman (x) float y; // position réel de Pacman (y) float oldx; // position précédente (x) float oldy; // position précédente (y) int bouge; // 0 : no move / 1 : bouge long int score; // score effectué int angle; // angle formé par la bouche int ouvre; // ouvre (ou non) la bouche int vie; // le nombre de vie de Pacman int color; // couleur du pacman int mort; // pacman mangé } struct_pacman; // nom de la structure La structure du monstre : typedef struct { int touch1; // déplacement principal int touch2; // déplacement secondaire float startx; // position de départ (x) float starty; // position de départ (y) float x; // position réel du monstre (x) float y; // position réel du monstre (y) float oldx; // position précédente (x) float oldy; // position précédente (y) int bouge; // 0 : no move / 1 : bouge } struct_monstre; // nom de la structure
	Le fichier main.cpp ne contient que la fonction main(). Cette fonction fait tourner à elle seule tout le programme. Pour plus de simplicité, de visibilité et de clarté, la fonction principale rappelle plusieurs fonctions secondaires. Le déroulement du programme : è Déclaration de toutes les variables locales. è Lancement de l’intro. è Lancement du menu (avec la souris). è Lancement de la partie. o Tant que la touche est différente de 13 (touche entrée) o Déplacement du monstre. o Déplacement du pacman. o Gestion des scores et de l’affichage, avec nombreux tests.

Affiche.h

Ce header sert essentiellement à afficher du texte, sous forme graphique.

Le contenu du header :

#include "affiche.h"

// void affiche_score(long int score, int refresh)

// void affiche_vie(int vie, int refresh)

// void affiche_bonus(int bonus, int refresh)

// void affiche_temps(struct time &t, struct time &told, struct time &deb, struct_jeu &jeu)

// void affiche_nivo(char *msg, int refresh)

// void affiche_HighScore(int pos)

affiche_score(long int score, int refresh)

Cette procédure affiche le score sur 8 chiffres (%08d) et ne l’affiche que lorsque refresh est à 1, pour éviter tout effet de scintillement. Si refresh est à 0, on efface le texte en le mettant en noir.

affiche_vie(int vie, int refresh)

Dans le même principe que la procédure précédente, elle affiche le nombre de vie restante.

affiche_bonus(int bonus, int refresh)

Dans le même principe, cette procédure affiche le bonus utilisé. Le problème, c’est qu’aucun bonus n’a pu être ajouté.

affiche_temps(struct time *t, struct time *told, struct time *deb, struct_jeu *jeu)

Cette procédure affiche le temps qui s’écoule. T est le temps actuel, Told est le temps de la dernière modification, Deb est le temps qu’il était au début de la partie. On affiche les secondes que si les secondes de T et Told sont identiques, sinon on affiche un texte noir. Idem pour les minutes. On met le temps écoulé dans la structure jeu.

affiche_nivo(char *msg, int refresh)

Cette procédure affiche le nom du niveau pointé par char, seulement si refresh vaut 1.

affiche_HighScore(int pos)

Cette procédure affiche le High Score. La position d’affichage de celui différera grâce à la variable pos. Pour le mettre à gauche (pendant la partie), pos vaut 0. Pour l’afficher au milieu (à la fin de la partie), pos vaut 270.

Draw.h

Ce header sert principalement à dessiner des formes, que ce soit les murs, le Pacman, les monstres ou les boules.

Le contenu du header :

#include "draw.h"

// void draw_mur(int x, int y, struct_map *map)

// void draw_boule(int x, int y, struct_map *map)

// void draw_megaboule(int x, int y, struct_map *map)

// void draw_pacman(struct_pacman &pacman, struct_map &map)

// void draw_monstre(struct_monstre &monstre, struct_map &map)

// void draw_map(struct_pacman &pacman, struct_monstre &monstre, struct_map &map)

// int LoadMAP(char *map_name, struct_map *map, long int code)

// int LoadMAPS(char *map_name)

draw_mur(int x, int y, struct_map *map)

Cette procédure affiche un mur carré selon sa position (X, Y). Le type du mur dépend du numéro du niveau. Il existe 4 types de murs différents.

draw_boule(int x, int y, struct_map *map)

Cette procédure affiche une petite boule blanche à la position (X, Y) passée en paramètre.

draw_megaboule(int x, int y, struct_map *map)

Cette procédure affiche une boule rouge qui aurait du servir à donner l’invincibilité au Pacman, pour qu’il puisse manger les monstres.

draw_pacman(struct_pacman &pacman, struct_map &map)

Cette procédure affiche tout simplement le Pacman, dans les quatres directions possibles. Si aucune direction n’est choisie, Pacman se met en boule.

draw_monstre(struct_monstre &monstre, struct_map &map)

Cette procédure affiche un monstre tout rouge. Tous les monstres sont de la même couleur et ne change pas de tête selon la direction.

draw_map(struct_pacman &pacman, struct_monstre &monstre, struct_map &map)

Cette procédure est la procédure principale de dessin et qui va lancer toutes les procédures secondaires précédentes. C’est ici que la structure map va être testée. Selon le résultat trouvé, on demandera l’affichage d’un mur, d’un Pacman, d’un monstre, d’une boule.

LoadMAP(char *map_name, struct_map *map, long int code)

Cette procédure charge un niveau. Elle va lire le fichier passé en argument, caractère par caractère et selon le caractère trouvé, on affichera un chiffre dans la structure map. Le code, par manque de temps, aurait du être crypté, mais faute de mieux, il sert tout de même à éviter certaines tricheries.

LoadMAPS(char *map_name)

Cette procédure charge tous les codes de toutes les maps qui seront jouées durant le jeu. Il permet principalement de vérifier l’authenticité des maps mais aussi de rendre possible le fait de pouvoir entrer un code pour arriver à un niveau spécifique qu’on a déjà terminé.

Menu.h

Ce header affiche et gère le menu qui se lance au début du jeu. Ici, rien de bien compliqué à part l’utilisation de la souris (avec l’interruption 33h en assembleur Intel) et l’affichage d’un cube tremblant.

Le contenu du header :

#include "menu.h"

// void init_cadre()

// void cube(float *c, float *s)

// int menu_principal()

// int menu_jouer()

// int menu_options(struct_pacman &pacman)

// int menu_aide()

init_cadre()

Cette procédure dessine un rectangle bleu dans le menu, point par point.

cube(float *c, float *s)

Cette procédure dessine et fait pivoter un cube en 3D grace à une équation mathématique. Les angles sont passées en argument. Ce n’est pas une équation que j’ai inventé mais une conversion d’un programme en Qbasic. L’implémenté dans le menu, avec sa propre fonction, ne fut pas une partie de plaisir. J’ai du utiliser deux Static Int pour garder les angles en mémoire sans les passer par argument.

Les autres fonctions du header n’ont pas besoin d’être décrites, elles sont trivialement compréhensibles.

Extra.h

Ce header est un mixage de toutes les fonctions non classables. Le plus dur et l’un des premiers défis du projet, fut de créer l’intro du jeu. Après quelques problèmes de mémoire, l’intro est une réussite.

Le contenu du header :

#include "extra.h"

// void WriteScore(char *nivo_name, char j_nom[10], int &points)

// int LoadScore(char *nivo_name)

// int getkey()

// void random_touch(int &touch1, int &touch2)

// void joue_son(int Hertz, int Dispo, int Delais)

// void intro()

// void init_graph()

WriteScore(char *nivo_name, char j_nom[10], int &points)

Cette procédure enregistre le high scores dans un fichier. En réalité, il recopie le high scores chargé en début de partie et insère le nom et les points du nouveau joueur.

LoadScore(char *nivo_name)

Cette procédure charge le fichier des high scores.

getkey()

Cette procédure permet d’utiliser toutes les touches du clavier sans avoir de conflits. Elle est la seule à ne pas avoir été créée de toute pièce.

random_touch(int &touch1, int &touch2)

Cette procédure permet de déplacer le monstre de façon aléatoire.

joue_son(int Hertz, int Dispo, int Delais)

Cette procédure joue un son unique, seulement si l’option est activée. Ensuite, on réalise un délais qui attend la note suivante.

intro()

Cette procédure lance l’intro du jeu, avec la fusée et le texte « La Team Rockets presents ».

init_graph()

Cette procédure initialise l’affichage du jeu et des pilotes graphiques MS-DOS.

A	Déplacer
	Le Pacman se devait d’avoir un déplacement fluide et pratique. Après quelques tatonnements, les premiers problèmes sont arrivés. Si on déplace Pacman de case en case, on perd l’effet de fluidité (même si on gagne considérablement en facilité de programmation). Il a alors fallu modifier une partie du code pour permettre au Pacman de se déplacer d’un quart de case à la fois. Ensuite, les collisions du Pacman avec les murs, les monstres et les boules blanches ont été difficile à faire mais finalement, en multipliant les tests, on arrive à un excellent résultat. Pour le côté pratique, deux touches de directions, une principale et une secondaire, sont attribuées au joueur pour déplacer le Pacman.
	fflush(stdin); // on vide le buffer du clavier // si on appuie sur une touche et que Pacman ne bouge pas if ((kbhit()) && (pacman.touch1==0)) { pacman.bouge=1; // on fait bouger Pacman pacman.touch1=getkey(); // on lit la touche } // on dessine Pacman sans le déplacer draw_pacman(pacman, 0, &map); // s’il bouge if ((pacman.bouge == 1) && (pacman.touch1 != 13)) { // s’il rappuie sur une touche, on fait une mise à jour if (kbhit()) { if (pacman.touch2==0) pacman.touch2=pacman.touch1; pacman.touch1=getkey(); } // on déplace Pacman avec sa direction principale draw_pacman(pacman, 1, &map); // s’il bouge, on met le secondaire à 0 if ((pacman.bouge == 1)&&(pacman.touch2 != 0)) pacman.touch2=0; // sinon, on le déplace avec sa direction secondaire if ((pacman.bouge == 0) && (pacman.touch2 != 0)) { pacman.bouge=1; draw_pacman(pacman, 2, &map); } // s’il est définitivement bloqué if (pacman.bouge==0) pacman.touch1=0; }
	L’intelligence du monstre est très artificielle. Le plus dur est aussi de gérer plusieurs monstres à la fois sans trop de problème de mémoire ou de temps. Le déplacement d’un monstre est à l’image de celui du Pacman, c’est-à-dire que le monstre possède une direction principale et une direction secondaire. Cela lui permet de pouvoir se balader correctement dans un labyrinthe sans rester coller contre les bords. Voulant faire une IA pas trop basique, le monstre se déplace vers le Pacman si celui-ci est assez éloigné. Parce que si on garde cet algo quelque soit la position du monstre et du Pacman, le jeu est beaucoup trop dur. Si le monstre se rapproche du Pacman, ces déplacements deviennent aléatoires.
	// boucle pour déplacer tous les monstres de la maps for (int nb_m=0; nb_m<map.nb_monstres; nb_m++) { // si la distance est supérieure à 12 cases (c’est assez loin) if (sqrt(pow(pacman.x-monstre[nb_m].x,2) + pow(pacman.y-monstre[nb_m].y,2))>12) { // on regarde la position du monstre et du pacman if (monstre[nb_m].x<pacman.x) monstre[nb_m].touch1=3; if (monstre[nb_m].x>pacman.x) monstre[nb_m].touch1=2; if (monstre[nb_m].y<pacman.y) monstre[nb_m].touch2=4; if (monstre[nb_m].y>pacman.y) monstre[nb_m].touch2=1; } // sinon, si le Pacman est proche du monstre else { // s’il ne bouge plus, on fait un random des touches if (monstre[nb_m].bouge == 0) { monstre[nb_m].touch1=0; random_touch(monstre[nb_m].touch1, monstre[nb_m].touch2); } } // s’il ne bouge plus, on l’affiche tout de même if (monstre[nb_m].bouge == 0) { monstre[nb_m].bouge=1; draw_monstre(&monstre[nb_m], 0, &map); } // s’il bouge toujours else { // le monstre utilise son déplacement secondaire draw_monstre(&monstre[nb_m], 2, &map); // s’il ne bouge plus, on utilise le principal if (monstre[nb_m].bouge==0) { monstre[nb_m].bouge=1; draw_monstre(&monstre[nb_m], 1, &map); } // sinon le déplacement secondaire devient principal else { monstre[nb_m].touch1=monstre[nb_m].touch2; random_touch(monstre[nb_m].touch1, monstre[nb_m].touch2); } } }

Dessiner

Le Pacman devait ressembler à l’original, c’est-à-dire qu’il devait être une grosse boule jaune. Après avoir commencer avec un vulgaire carré, la forme ronde du Pacman est arrivée (merci la fonction Circle).

Mais c’est là que les problèmes commencent, parce que Pacman doit changer de tête en fonction de ses déplacements. Plusieurs options étaient envisagées. On pouvait utiliser la fonction circle, la fonction arc et la fonction pieslice. On pouvait aussi tracer le Pacman uniquement avec des lignes, qui formeraient une boule au final. On a opté pour celle qui utilisait le minimum de fois la fonction floodfill car parfois on obtient des bugs graphiques spectaculaires. La fonction pieslice fut choisie puisque qu’elle n’utilise pas du tout la fonction floodfill, même si ce choix fait scintiller légèrement le Pacman.

On avait aussi le choix de mettre l’image de Pacman dans une matrice au lieu de le redessiner à chaque fois. Cette option fut envisagée mais vu qu’on voulait que Pacman ouvre sa bouche et qu’on avait des problèmes permanent de mémoire, on a opté pour le redessiner à chaque fois.

Pour faire encore plus fun, nous avons fait le détail qui tue, l’œil du Pacman.

Le monstre doit ressembler à quelque chose de méchant. C’est pourquoi nous avons décider d’utiliser la fonction fillpoly qui permet de faire son dessin point par point puis de la colorier par la suite. Mettre les points au bon endroit fut la principale difficulté. Cette technique est utiliser pour faire le bas du monstre. Le haut est un cercle.

IV] ModificationS

Carte

Voici toutes les étapes pour réaliser votre propre carte Pacman.

Commencez tout d’abord par créer un fichier texte dans le même répertoire que le fichier pacman.exe. Ensuite, vous renommerez ce fichier en mettant un nom de 8 lettres maximum, et ne mettant l’extension .map.

Ouvrez votre fichier avec le bloc-notes de Windows et structurez votre fichier comme suit :

1 ère ligne indiquez le nom de votre carte (8 caractères sans espace).

2 ème ligne code de 8 chiffres.

3 ème ligne largeur de votre carte.

4 ème ligne hauteur de votre carte.

Ensuite, créez votre niveau en utilisant les caractères suivants :

* murs (étoile)

· boule (Alt + 0183)

O point de départ monstres

X point de départ Pacman

x bonus

Attention : respectez la hauteur et la largeur de votre carte lorsque vous la dessinez avec les caractères. Faites attention aux éventuels espaces en fin de ligne.

Pour jouer sur votre carte : éditez le fichier nivo.map avec le bloc-notes de Windows. Ajoutez ensuite le nom de votre fichier avec l’extension .map, à l’endroit désiré.

Exemple de la première carte (nivo01.map) avec le résultat à l’écran :

Facile

66678900

*****

* · *

* *

* X *

* *

*****

Niveau

Comment personnaliser sa partie de Pacman, voici les explications :

Editez votre fichier nivo.map. Vous pouvez tout faire sur ce fichier. Le programme lit le fichier et lance les map une par une, jusqu’à ce qu’il arrive au point final du fichier.

Pour créer votre propre partie de Pacman, vous pouvez inverser des noms dans le fichier, vous pouvez en supprimer, vous pouvez en rajouter (s’ils existent). Une seule chose, laisser le point final.

Exemple d’un fichier de niveau (nivo.map) :

nivo01.map

nivo02.map

nivo03.map

nivo04.map

nivo05.map

Options

Les options peuvent être modifiées sans passer par le menu :

Pacman : couleur du pacman [0 – 15].

Vie : nombre de vie au départ du jeu.

Son : Activé (1) ou désactivé (0).

Nom : nom du joueur.

Background : couleur de l’arrière-plan [0 – 15].

Exemple d’un fichier d’option (options.map) :

pacman = 14

vie = 3

son = 1

nom = BeLZeL

background = 4

Tricher

Quelques possibilités de tricherie existent :

Vous pouvez modifier le fichier nivo.map.

Vous pouvez modifier le fichier score.map.

Vous pouvez regarder les codes secrets (de 8 chiffres) des maps en les ouvrant sous le bloc-notes.. Allez ensuite dans le menu Jouer/Entrer un code et retapez le code trouvé.

Vous pouvez vous rajouter un max de vie en modifiant le fichier options.map.