Club LinuX Nord-Pas de Calais

Le concours du reporter (3/3)

Gaétan RYCKEBOER — 2003-03-31T14:49:06Z

Tout jeu possÚde des rÚgles, le concours du Reporter n'y échappe pas, voici donc celles qui seront appliquées pour :

– établir le classement des pilotes logiciels de chaque participant sur un circuit de référence qui sera publié chaque mois sur le site de CLX jusqu'à clÎture du concours,

– établir le classement définitif à clÎture du concours lors d'épreuves éliminatoires disputées sur plusieurs circuits

– Attribuer les cadeaux réservés aux 50 premiers participants ayant respectés les rÚgles du jeu.

Règles de participation

Article 1

La participation au concours sous-entend l'acceptation du présent
règlement. Tout participant ne vérifiant pas l'un ou l'autre des articles de ce
règlement sera irrémédiablement éliminé et ne pourra prétendre à aucun cadeau
:-<.

Article 2

Le concours est gratuit et ouvert à toute personne physique ou morale
(association, club, école...). Dans le cas d'un groupement d'individus, une
personne physique doit être désignée comme représentant pour écrire ou recevoir
tout courrier ayant trait au concours. Un seul cadeau sera fourni par équipe
quel que soit le nombre de participant.

Article 3

Les dénommés Gaétan Ryckeboer (ASR), Frédéric Gautier (Fred) sont considérés comme arbitres. A ce titre, ils
ne peuvent pas participer aux épreuves du championnat, mais veilleront au bon
déroulement des courses dans le respect du règlement.

Article 4

Chaque participant doit adresser
– par courrier à : Gaétan Ryckeboer, 6 Allée Henri Bergson, 35200 Rennes,
– ou par e-mail à [clx-concours@clx.anet.fr].

avant le 31 Août 2003 (le cachet de la poste ou du serveur de mails clx.anet.fr
faisant foi), une enveloppe contenant :

– 1) Sur disquette 3 pouces et demi, formatée DOS ou Linux 1,44 Mo, ou sur CD-ROM :

a) Un programme exécutable ou interprété, dénommé "Pilote Logiciel",
respectant les conditions suivantes :
- Exécutable statique ou script utilisable sous Linux, OpenBSD, FreeBSD, ou
  MacOSX à l'exclusion de tout autre système d'exploitation ;
- Mémoire maximum exploitable pour son exécution : 10 Mo de mémoire.
- Le script ou exécutable ne peut excéder 5 Mo ;
- Le programme ne peut faire faire appel à d'autres librairies que les
  bibliothèques (ou librairies) standard installées sur tous les Un*x ;
- Le programme doit être interruptible par un simple appui sur une touche. Le
  temps maximum alloué pour la génération du fichier .F1 contenant les
  déplacements du bolide sur un circuit est limité à 2 min (sur la machine de
  référence, un P2-350 sous console Unix Debian 2.2). Lors des épreuves de
  qualifications, les arbitres devront pouvoir interrompre le logiciel si ce
  délai est dépassé. Un temps maximum de réaction de 10 secondes sera toléré
  entre l'instant ou une touche est pressée et la sortie effective du
  programme ;
- Le programme doit fonctionner "en l'état" et ne doit donc comporter aucun
  dispositif d'installation ou de configuration ;
- Le programme doit fonctionner uniquement en ligne de commande et ne pas
  faire appel à des menus ;
- Le programme doit accepter en unique paramètre de ligne de commande le nom,
  avec son extension, d'un fichier circuit à traiter, se trouvant dans le
  répertoire courant ;
- Le programme doit créer dans le répertoire courant, pour chaque circuit
  traité, un fichier de même nom que l'exécutable mais d'extension .F1
  respectant les règles d'évolution de la F1 et la
  syntaxe des fichiers résultat ;
- la création de fichiers temporaires est tolérée à raison d'un seul présent
  sur le disque à la fois ne dépassant pas une taille de 1 Mo. Tous les
  fichiers temporaires devront obligatoirement être détruit par le programme
  avant la fin de son exécution, et stockés dans /tmp.
b) Un fichier de description de circuit, d'extension .CIR, dénommé "Circuit"
par la suite, considéré comme conforme par le programme de validation
CREECIR.EXE fourni aux participants.

– 2) Une lettre manuscrite datée et signée ou un e-mail signé par GPG ou PGP
comprenant :

Le nom et les coordonnées (adresse) de la personne physique participant au
concours, ou du représentant physique dans le cas d'une participation
groupée ;
faisant attestation :
- que le participant est bien l'auteur du programme fourni ou dûment mandaté
  comme représentant d'un groupe d'auteurs le cas échéant ;
- que le programme est certifié fonctionner sans risque de porter atteinte à
  l'intégrité de tout système informatique sur lequel il sera amené à être
  exécuté ;
engageant l'auteur :
- à autoriser la diffusion gratuite de son pilote logiciel auprès des
  participants en faisant la demande pour vérification du résultat des
  épreuves éliminatoires venant en clôture du concours.
- à fournir et autoriser la parution du source de son pilote logiciel sur le
  site de CLX, protégé par une licence libre de son choix.

NB : Chaque participant reste propriétaire de tous les droits sur ses logiciels
et sources créés à l'occasion de ce concours.

Article 5

Lorsqu'un participant envoie, avant le délai final fixé au 20 Novembre 2003,
une nouvelle version de son pilote logiciel et/ou de son circuit, celui-ci (ou
ceux-ci) se substitue(nt) au précédent envoi. Seule donc la dernière version
reçue (le cachet de la Poste faisant foi) participera aux épreuves de
qualification venant clore le concours.

Article 6

Seuls pourront prétendre à un cadeau les 50 premiers participants (date du
dernier courrier faisant foi) :

– ayant respecté les règles énoncées ci-dessus ;
– et dont le pilote logiciel aura parcouru de bout en bout, dans les temps
impartis, 70% des circuits qui lui seront présentés lors des épreuves de
clôture du concours.

Article 7

L'envoi des cadeaux prendra effet à partir de la date de clôture du concours.

Article 8

A l'issue du concours, tout participant pourra vérifier les résultats des
courses en faisant la demande écrite à l'un des arbitres, soit en joignant une
enveloppe pré-affranchie ainsi qu'une disquette à Gaétan Ryckeboer pour que lui
soient transmis les circuits et pilotes logiciels concurrents, soit par simple
e-mail (voir adresses plus haut).

Article 9

Les épreuves de qualification et éliminatoires venant clore ce concours sont
détaillées au chapitre épreuves de qualification

Épreuves de qualification

L'ordinateur sur lequel se dérouleront les courses est muni d'un processeur AMD
P2 à 350 MHz.

Un programme arbitre, baptisé TESTF1, sert à établir les temps de chaque pilote
logiciel sur les circuits qu'il a traité, analyser le fichier résultat généré
par le pilote et vérifier que le chemin décrit vérifie bien les règles
d'évolution ainsi que la syntaxe du fichier résultat.

Le temps mis par un pilote pour parcourir un circuit donné, ainsi que la
vitesse moyenne, sont ceux indiqués par le programme arbitre TESTF1, considéré
comme chronomètre officiel du concours.

testf1.exe

L'outil utilisé pour vérifier la validité d'une course

Ce programme est fourni avec ce numéro afin de permettre à chacun d'évaluer et
tester son pilote avant envoi.

Classement provisoire avant clôture du concours :

Sur le site de CLX, nous ferons paraître les performances des pilotes logiciels
sur un circuit de référence, au fur et à mesure des envois.

Ce circuit est celui fourni à titre d'exemple : MONACO.CIR

monaco.cir

Le circuit de base (à renommer)

Ce classement sera établi grâce au chronomètre officiel TESTF1.EXE

Épreuves de qualification à la clôture du concours :

Tous les concurrents seront regroupés par "poules" comprenant entre 6 (minimum)
et 12 (maximum) participants. La formation des poules se fera conformément à la
procédure d'organisation des poules décrite en annexe.

Dans chaque "poule", le pilote logiciel de chacun des participants en faisant
partie devra générer un fichier .F1 pour chaque circuit fourni par ses
co-listiers et par lui-même.

Classement des pilotes par circuit de la poule :

Ces fichiers .F1 seront ensuite traités par le programme arbitre TESTF1 qui
générera pour chaque circuit un fichier .LOG permettant d'établir par circuit
un classement des pilotes dressé selon les deux critères décroissants :

– Rapidité de couverture du parcours - vitesse moyenne

Pour chaque circuit de la poule, il sera attribué un nombre de points aux
différents pilotes logiciel, en fonction de leur position dans le classement
précédemment obtenu :

position	points
1	10
2	6
3	4
4	3
5	2
6	1
7 à 12	0

En cas d'ex aequo sur un circuit, tous les pilotes classés à la même position
marquent les points de cette position. Les points des places suivantes qui
auraient dû être occupées ne sont pas attribués.

Exemple : 3 pilotes ex aequo à la deuxième place marquent tous 6 points, le
suivant marque 2 points (position 5).

Classement des pilotes dans la poule (tout circuits confondus) :

Lorsque toutes les courses d'une poule sont terminées, on procède, pour chaque
pilote, à l'addition des points obtenus sur chacun des circuits qu'il a
parcouru au sein de la poule. Ce cumul de points sert de classement de la
poule. (On procède de même pour toutes les poules de l'épreuve de qualification
en cours)

Exemple :

Position	Pilote	Points par Circuits	1	Toto	10+10+10+6+4+2=42
2	Titi	6+6+6+0+6+6 =30
3	Tutu	10+10+10+0+0+0=30
..	...	...
6	Tata	0+0+1+2+0+1 =04

En cas d'égalité de points entre plusieurs participants de la poule, les règles
de départage suivantes seront appliquées, classées par ordre de priorité :

– 1) On enlève le moins bon résultat supérieur à 0 des participants ex aequo et
on les reclasse. On répète l'opération précédente autant de fois que
nécessaire jusqu'à ce que l'un ait plus de point que l'autre.

Ce système d'arbitrage fait que, dans l'exemple ci dessus, il vaut mieux
marquer 30 points en terminant 5 fois deuxième (5*6=30) plutôt que de gagner 3
fois (3*10=30). En effet, dans ce cas, après avoir enlevé le moins bon
résultat, Titi se retrouve avec 24 points et Tutu avec 20 points.

Ce système d'arbitrage essaie de privilégier la régularité au détriment des
coups d'éclats.

– 2) Si malgré cela des participants restent ex aequo, il sera fait appel à la
question subsidiaire :

Le temps moyen de toutes les courses valides de la poule sera calculé (Par
course valide on entend une course pour laquelle le pilote n'a pas été
éliminé).

Le temps moyen est donc la somme de tous les temps obtenus sur toutes les
courses valides de la poule, divisée par le nombre de courses valides de la
poule.

Les participants seront classés en fonction de la proximité du temps estimé
qu'ils ont donné par courrier avant le début des courses et ce temps
calculé. Plus l'estimation préalable du participant est proche de la réalité,
meilleur sera son classement.

Sélection des pilotes pour les qualifications suivantes :

Ne sont retenus pour les épreuves de qualification suivantes que la moitié des
participants de chaque poule (arrondi au chiffre supérieur si le nombre de
participants est impair) en fonction du classement obtenu dans leurs poules
respectives.

Le total des points de chaque pilote est remis à 0 à l'issue de de cette
sélection et avant l'épreuve de qualification suivante.

On procédera ainsi à de nouvelles séances de qualification par poules en ne
gardant à chaque fois que la moitié des pilotes logiciels les plus performants
dans la leur. Et ce jusqu'à ce que le nombre de participants restant soit
inférieur ou égal à 12.

Poule finale :

Les rescapés des épreuves de qualification s'affronteront dans une poule finale
dont le classement se fera selon les mêmes règles que celles décrites ci-avant.

Sera déclaré vainqueur, le participant dont le pilote est classé premier de la
poule finale.

Pourquoi organiser des poules ?

Par Stéphane Pineau
Pourquoi organiser des poules et diviser ainsi les participants ?

Ben, parce que nous ignorons totalement le nombre de participants qui
répondront.(Beaucoup j'espère !)

Imaginez qu'il y ait 32 participants et que l'on fasse tourner les pilotes de
tous les candidats sur tous les circuits.. Il y aurait alors 32*32 courses, et
à raison de 5 minutes par course, cela prendrait 85 heures (sans pause !).

Pour 64 participants, on aurait 341 heures, soit plus de 14 jours...

Bref, comme on compte sur vous pour que ce concours soit un véritable succès,
il fallait bien trouver une solution !

D'où l'idée de répartir les participants en poules...

Comme si, par exemple, il y avait plusieurs championnats de Formule 1, un en
Europe, un en Afrique, un en Asie et un en Amérique.

On organise des championnats 'régionaux' et on sélectionne (qualifie) les
meilleures voitures de chaque région pour une finale.

Un championnat régional, c'est ce que l'on appelle une poule. Dans ce
championnat, chaque voiture tourne sur chacun des circuits.

Comme en Formule 1, pour chaque circuit, on attribue des points aux meilleurs
participants.

À l'issue du championnat, les meilleures voitures sont qualifiées, les autres
étant éliminées.

L'objet de ce chapitre est de vous décrire la méthode retenue pour diviser les
participants en poule.

Ce n'est pas très simple à comprendre, car on a veillé à ne pas trop éliminer
de candidats à chaque fois, quitte à être obligé de subdiviser encore plus si
nécessaire (championnat local, qualifiant pour un championnat régional,
lui-même qualifiant pour la poule finale...).

Les concurrents seront, en fonction du nombre de participants, divisés en
plusieurs poules. Le nombre de poules dépend du nombre de participants par la
formule :

nombre_de_poule= 1+ trunc(nombre_de_participants / 12)

trunc indique un arrondi à la valeur inférieure (exemple
trunc(3.9)=3). Ceci permet de définir des poules de 12 candidats maximum.
Ex. :
– 8 participants -> 1 poule
– 12 participants -> 2 poules (2 poules de 6 participants)
– 15 participants -> 2 poules (une poule de 7 et une de 8)
– 32 participants -> 3 poules (2 poules de 11 et une de 10)
– 36 participants -> 4 poules (4 poules de 9)
– etc..

Ensuite les participants sont répartis dans les poules en fonction de la date
postale de leur premier envoi. Le premier envoi reçu allant dans la première
poule, le second dans la deuxième et ainsi de suite. Dès que l'on dépasse le
nombre de poules, on recommence à la première poule.

Exemple : 32 participants : 3 poules

poule 1	poule 2	poule 3
1	2	3
4	5	6
7	8	9
10	11	12
13	14	15
16	17	18
19	20	21
22	23	24
25	26	27
28	29	30
31	32

On aura 2 poules de 11 participants et une de 10 participants.

La course sera organisée par poule et seront qualifiés au moins la moitié des
participants de la poule. Si le nombre de candidats dans la poule est pair,
c'est juste la moitié qui est qualifiée, si le nombre est impair, on arrondit
la moitié du nombre de participants au chiffre supérieur.

Dans notre exemple, on qualifiera 6 participants des 2 premières poules et 5
participants de la troisième. Le nombre de candidats restant en course après le
premier tour est donc de 17.

On reprend la procédure initiale, avec les seuls candidats qualifiés, et en les
plaçant dans les nouvelles poules suivant un balayage en 'zig-zag'.

Par exemple, si on appelle p1_1 à p1_6 les 6 qualifiés de la poule 1 du premier
tour, (et p2_x et p3_x respectivement ceux de la poule 2 et 3) la répartition
des 2 poules du deuxième tour se fera (toujours pour notre exemple initial à 32
participants) :

poule 1	rencontre	poule 2
p1_1	->	p1_2
p1_4	<-	p1_3
p1_5	->	p1_6
p2_2	<-	p2_1
p2_3	->	p2_4
p2_6	<-	p2_5
p3_1	->	p3_2
p3_4	<-	p3_3
p3_5

On répète l'opération de qualification et de mise en poule, jusqu'à ce qu'il
n'y ait plus qu'une seule poule, baptisée poule finale.

Le classement du concours est le classement de la poule finale.

Résumons par un exemple concret

Pour participer au concours, vous avez deux fichiers à fournir, en plus de la
lettre manuscrite :

– 1) Un fichier décrivant un circuit, d'extension .CIR. C'est, entre autres, sur
ce circuit que votre voiture et celles de vos concurrents devront évoluer.

Pour créer ce circuit, il vous est possible d'utiliser l'outil fourni dans
les annexes, baptisé
CREECIR.EXE.

Pour dessiner votre circuit, il suffit de taper :

CREECIR mon_circuit

où mon_circuit est le nom que vous donnez à votre circuit.

Votre circuit ne peut pas être quelconque, il doit vérifier certaines règles
pour être conforme au règlement.

Un bouton, marqué OK, permet de vérifier dans CREECIR, si un circuit est
conforme au règlement.

Pour tester le programme CREECIR, nous avons joint au Reporter un circuit test
de démonstration (MONACO.CIR).

Ce fichier est le dessin d'un circuit conforme au règlement.

Pour autant que votre PC soit en mode VGA et dispose sous DOS d'un driver de
souris, vous pouvez visualiser, modifier le circuit, ainsi que vérifier sa
conformité au règlement, à l'aide du logiciel CREECIR.EXE :

CREECIR monaco

Vous pouvez aussi visualiser, à l'aide d'un éditeur quelconque tel que EDIT, le
fichier .CIR généré. Il est au format ASCII et la piste est tout simplement
représentée par le caractère ' ' (espace).

Vous pouvez vous amuser à modifier le circuit MONACO.CIR afin de le rendre non
conforme et constater le verdict du programme de vérification.

– 2) Le deuxième fichier à fournir est votre programme de pilote, celui qui
décrira l'évolution de votre voiture sur un circuit donné.

Il reçoit, comme paramètre d'entrée, le nom du circuit sur lequel la voiture
doit boucler un tour. En sortie, il génère un fichier ASCII, décrivant
l'évolution de la voiture et qui respecte les règles physiques du comportement
de la voiture sur la piste.

La syntaxe d'appel est, par convention :

votre_programme nom_de_circuit.CIR

et son action est de créer un fichier votre_programme.F1 à partir du circuit
nom_du_circuit.CIR.

Pour vous évitez de tester le principe du concours en écrivant dès maintenant
un pilote automatique, dans les annexes du concours, vous trouverez
un tel programme.

Ce pilote automatique de démonstration n'est pas du tout performant (vous
pourrez faire nettement mieux) car notre but est juste de montrer ce que nous
attendons des participants.

Ce programme de pilote automatique de démonstration est baptisé DEMO_2CV.EXE,
et il génère, à partir d'un fichier circuit .CIR conforme un fichier résultat
(d'extension .F1) qui vérifie la syntaxe des fichiers résultats.

Pour utiliser le pilote de démonstration tapez :

DEMO_2CV monaco

et le programme génèrera un fichier résultat MONACO.F1. Bien entendu, le
fichier résultat est en ASCII et est donc parfaitement lisible avec un éditeur
de textes...

Enfin, pour contrôler le fichier résultat d'une voiture, et effectuer un
chronométrage officiel de la voiture, utilisez le programme arbitre fourni :
TESTF1.EXE.

Grâce à ce programme, les temps réalisés sont vérifiables par TOUS !

En plus de son rôle de 'chronomètre', TESTF1 vérifie que le résultat obtenu par
le programme pilote est correct, à savoir que la voiture respecte les règles
d'évolution et qu'aucune collision n'est constatée avec les bords de piste.

TESTF1 reçoit comme paramètre d'entrée le nom du fichier résultat (d'extension
F1) qu'il doit vérifier.

Pour visualiser la course qu'a effectuée le pilote automatique de démonstration
et connaître son chronométrage précis, il ne reste plus qu'à faire tourner le
programme arbitre, à savoir :

TESTF1 demo_2cv.F1

Le rÚglement ici présent est trÚs fortement inspiré du rÚglement original proposé par L.RiviÚre lors de la publication initiale du concours. Voici d'ailleurs le Post-Scriptum qu'il adressait aux concurrents et que nous reprennons à notre compte :

Tout ceci peut sembler long car j'ai (Luc RivÚre) voulu à la fois présenter ce qui fait partie du concours en lui-même et les outils 'pour aider les participants et éviter les problÚmes'.

Une GUI pour créer des circuits

Gaétan RYCKEBOER — 2003-02-21T12:35:16Z

Philippe Leroux nous propose un logiciel permettant de créer des circuits sous un*x.

Pour compiler il suffit de se placer dans le répertoire où a été
extraite l'archive, puis de taper make.
La variable d'environnement
QTDIR doit être définie, par exemple avec :

export QTDIR=/usr/lib/qt2

Attendre... Puis saisissez :

./installme

Le programme installme va créer dans la home directory (votre répertoire utilisateur) un répertoire PisteF1 et
copier dedans tous les fichiers utiles.
J'ai essayé de faire une aide accessible par la combinaison de touches CTRL+F1 sur une des 2
fenêtres principales la fenêtre de log ou via le menu.

Si PisteF1 est déplacé ou renommé, il faut définir la variable d'environnement
PISTEF1 :

export PISTEF1=$HOME/MaPisteF1

Le log (test.f1) de mon pilote est présent, pour montrer les extensions
que l'on peut utiliser et l'intérêt éventuel.

F1-release-01.tar.gz

F1-release-02.tar.gz

Merci à Philippe Leroux pour cette contribution.

Le concours du Reporter : Annexes

Gaétan RYCKEBOER — 2003-01-20T12:39:46Z

Voici quelques fichiers issus du Reporter n°7, qui vous permettront de commencer à réfléchir.

Quelques fichiers de LOG, un circuit et son équivalent en BMP :

monaco.bmp Un conversion Bitmap du circuit Monaco.cir	monaco.cir Le circuit de base (à renommer)
monaco.log Un fichier de log d'une course sur monaco (pour exemple). A renommer.	demo_2cv.f1 Le pilote demo_2cv a concouru sur le circuit monaco, voici ses logs de position

Notez-bien que certains de ces programmes (fonctionnant aujourd'hui sous DOS) seront disponibles sous Linux dans un avenir proche. Ils peuvent toutefois d'ores et déjà être exécutés avec DOSEmu (sous linux) ou FreeDos (un OS à part entière).

Attention, un petit bug de Turbo Pascal 7 empêche l'execution correcte des fichiers. Cybermad nous en a fait parvenir une version corrigée :

creecir.exe Un outil de création de ciruit (sous DOS) réalisé par Luc RiviÚre en Turbo-Pascal. (version patchée)	demo_2cv.exe Le pilote de démo du Reporter (réalisé par Luc RiviÚre)
testf1.exe L'outil utilisé pour vérifier la validité d'une course	verifcir.exe L'outil utilisé pour vérifier la conformité d'un circuit (version patchée)

Le patch, si vous avez déjà récupéré les fichiers avant le 27/03/01 :

Patch correctif

Si vous avez déjà téléchargé les fichiers, ce petit patch permettra de les exécuter sans problÚme sur un ordinateur récent (> PII). Voir aussi la page de Cybermad

Et en cours d'écriture, les outils en C pour tous les environnements où C a été porté.

bmp2cir.c

Un convertisseur simpliste de fichier BMP en fichier .cir

Bon courage.

Vous ne trouverez ici que les fichiers originaux fournis par le Reporter. Ils fonctionnent sous DOS (pour les exécutables), mais le concours est bel et bien sous Unix (Linux, *BSD, etc...)

Le concours du reporter (2/3)

Gaétan RYCKEBOER — 2003-01-16T12:58:52Z

Une fois compris le principe du concours, voici les rÚgles un peu plus détaillées, les contraintes à respecter, et la façon dont tout cela va se dérouler.

Syntaxe des fichiers résultat

Le fichier résultat (de même nom que le pilote logiciel et d'extension F1) est le fichier que doit écrire votre programme, contenant l'évolution de votre voiture sur la piste.

Le fichier doit être de type 'ASCII' formé de caractères regroupés en différentes lignes (séparées classiquement par les caractères "carriage return" et éventuellement "linefeed").

Par convention, la première ligne est une chaîne de caractères qui vous est propre, et permet d'identifier le pilote automatique qui a généré le fichier.

La deuxième ligne doit indiquer le nom du fichier CIR (donc le nom du circuit) qui a été utilisé pour donner ce résultat.

Les lignes suivantes (donc à partir de la troisième ligne) contiennent la liste des différentes positions de la voiture. La syntaxe imposée est d'abord la position en X (longueur de 0 à 149), puis la position en Y (hauteur de 0 à 99) séparés par une virgule ','.

Le premier point indiqué est obligatoirement celui de la position de départ (40,4).

Puisque la vitesse au départ est nulle, le point suivant est obligatoirement un voisin du point de départ, a priori de coordonnée X supérieure (41) à cause de la progression de la voiture dans le sens des aiguilles d'une montre..

Le dernier point indiqué est celui qui a permis de passer la ligne d'arrivée (position x supérieure ou égale à 40).

Voici un extrait de fichier résultat correct :

Pilote automatique de Ferraro, écrit par Jean Vazy
monaco.cir
40,4
41,4
(...)
38,6
42,5

Entre (41,4) et (38,6) se trouvent bien entendu la série des coordonnées qui permettent de boucler le circuit...

Structure du pilote automatique

Voyons ensemble l'ordinogramme de base des traitements que doit être en mesure d'accomplir votre pilote logiciel :

. +-----------------+ ¦ Pilote Logiciel ¦ +-----------------+ ¦ +--------------------------------------------------------+ ¦ Chargement dans un tableau d'un fichier .CIR ¦ ¦ contenant la description d'un circuit sous la forme ¦ ¦ d'une matrice de 100 lignes de 150 caractères, ou un ¦ ¦ caractère espace représente la piste et tout autre ¦ ¦ le décor. ¦ +--------------------------------------------------------+ ¦ +--------------------------------------------------------+ ¦ Ouverture du fichier destiné à contenir les ¦ ¦ déplacements du bolide sur la piste. Fichier du même ¦ ¦ nom que votre programme mais d'extension .F1. ¦ +--------------------------------------------------------+ ¦ +--------------------------------------------------------+ ¦ Positionnement dans le tableau sur la ligne de départ ¦ ¦ fixé par défaut en ordre 40,4 et écriture de cette ¦ ¦ position dans le fichier des déplacements .F1 ¦ +--------------------------------------------------------+ ¦ +--------------------------------------------------------+ ¦ Calcul de prochaine position du bolide sur la piste ¦ +>-¦ (donc dans le tableau) en respectant les règles de ¦ ¦ ¦ déplacement et sans collision. ¦ ¦ +--------------------------------------------------------+ ¦ ¦ ¦ +--------------------------------------------------------+ ¦ ¦ Ecriture de la nouvelle position dans le fichier des ¦ ¦ ¦ déplacements .F1 ¦ ¦ +--------------------------------------------------------+ ¦ ¦ ¦ +-----------------------------------+ ¦ N+----¦ Test si une touche est pressée * +----+O ¦ O¦ +-----------------------------------+ ¦U ¦ N¦ ¦I ¦ +-----------------------------+ ¦ ¦ ¦ Test si la ligne d'arrivée ¦ ¦ ¦ ¦ est franchie dans le bon ¦ ¦ ¦ ¦ sens (même position dans +----+O ¦ ¦ ¦ le tableau que la ligne de ¦ ¦U ¦ ¦ ¦ départ) ¦ ¦I ¦ ¦ +-----------------------------+ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +-----------------------------+ +-----------------------+ +<-¦ Non ? On continue ¦ ¦ Si oui fermeture du ¦ +-----------------------------+ ¦ fichier .F1 ¦ +-----------------------+ ¦ +-----------------------+ ¦ Sortie du programme ¦ +-----------------------+ -Ð- +--------------------------------------------------------+ ¦ Validation et chronométrage du fichier .F1 pour le ¦ ¦ circuit traité par le programme fourni TESTF1.EXE ¦ +--------------------------------------------------------+

Le temps alloué [1] pour créer un fichier .F1 des déplacements étant limité à 5 mn pour un circuit,le programme doit être interruptible par simple pression d'une touche, avec un temps de réaction ne dépassant pas 10 secondes.

Toutes les informations qui vous sont nécessaires pour la réalisation de ce programme sont détaillées dans les chapitres précédents (ie : règles de déplacement, formats des fichiers etc.)

Création et vérification des circuits

D'abord pour ceux qui bénéficient d'un DOS, d'un écran VGA avec un driver de souris installé : le programme CREECIR (sous DOS, fourni originellement par le Reporter) va vous faciliter la vie !

Le programme CREECIR a un double but : celui de vous aider à dessiner des circuits de façon simple et visuelle, et celui de vérifier la conformité des circuits avec le règlement.

Le programme nécessite un PC avec carte VGA, et une souris dont le driver est installé.

La syntaxe d'appel est :

CREECIR [fichier CIR]

Si le fichier CIR est indiqué, le programme va le charger et vous permettre de modifier ce circuit à souhait.

Si le fichier CIR est spécifié mais n'existe pas sur disque, le programme va le créer, en partant d'un circuit 'vierge', sauf la zone de départ imposée.

Si le fichier CIR n'est pas indiqué, le programme va créer un nouveau fichier de nom NOUVEAU.CIR, même s'il existe déjà un fichier de ce nom.

Le programme est juste un programme de dessin 'minimal'. On ne peut charger un circuit à l'intérieur du programme par exemple. Il faut quitter et relancer CREECIR. Pour la gestion de fichier, il faudra parfaire vos connaissances du DOS (COPY ou REN ;-)).

En réalité, tout, dans le programme, se fait à la souris. Oubliez donc le clavier !

Bien entendu, la sauvegarde de vos créations est possible dans le programme (quand même !).

En faisant tourner le programme vous constaterez plusieurs zones :

– 1) Sur la colonne de gauche, la palette de couleurs avec celle qui est sélectionnée entourée d'un fin trait blanc. Les couleurs sont celles de la palette de Windows, car c'est la convention utilisée pour les circuits.
– 2) Au centre, le dessin du circuit.. étonnant non ?
– 3) En bas à gauche, une série d'icones "outil", dont l'un est sélectionné (entouré d'un liseré rouge).

On distingue 7 outils de création graphique :

– le crayon qui permet de dessiner pixel par pixel ;
– le pinceau qui permet de dessiner par carré de 3*3 pixels (très pratique pour faire des circuits rapidement !) ;
– le trait qui permet de faire des lignes joignant 2 points (Bresenham) ;
– le rectangle qui permet de remplir rapidement une grande zone ;
– le pot de peinture, qui effectue un remplissage (fill) de toute une zone. Méfiez-vous car il n'y a pas de retour en arrière ! (sauvegardez souvent) ;
– un outil qui permet de sélectionner une zone graphique et de la copier dans un presse-papier ;
– l'outil inverse, qui permet de recoller la zone du presse-papier sur le dessin.

Puis on trouve 3 icônes d'outils généraux :

– celui représenté par le symbole OK, permet de vérifier la conformité du circuit au règlement ;
– celui indiquant une disquette permet la sauvegarde de votre oeuvre ;
– celui marqué EXIT permet de sortir du programme (eauvegardez avant, il n'y a pas encore de garde fou).

Un essai valant mieux qu'un long discours, téléchargez le logiciel DOS CREECIR (garanti sans virus), avec comme circuit le fichier MONACO.CIR, fourni à titre de circuit de démonstration.
! Nécessite un driver Souris et un écran VGA (et surtout un DOS) !

Pour ceux qui ne bénéficient pas d'écran VGA, ou de drivers de souris, ainsi que pour les inconditionnels de Windows..

Vous trouverez dans les annexes de cette page quelques outils complémentaires (sous DOS, pour le moment) :

– VERIFCIR.EXE programme non graphique permettant de vérifier la conformité d'un circuit vis à vis du règlement.

– CIR2BMP.EXE programme permettant la conversion des fichiers CIR en fichiers BMP non compressés (16 couleurs). Ceci peut vous permettre d'utiliser vos outils classiques de dessin.

– BMP2CIR.EXE programme inverse du précédent, permettant de générer un fichier CIR, à partir d'un dessin BMP 16 couleurs non compressé.

Attention, pour être compatible avec les circuits, les fichiers BMP doivent être de taille 150*100 pixels et n'utiliser que les 16 couleurs standard de Windows dans leur ordre d'origine !

Chronométrage des résultats

Vous avez développé un pilote automatique de compétition, et il génère un fichier résultat (d'extension F1) très performant !

Mais votre programme est-il correct ?

C'est pas qu'on doute de votre bonne foi, mais une erreur est si vite arrivée (Argghhh ! Là je suis passé trop près du bord !).

Nous avons donc décidé d'écrire un programme arbitre, sous DOS, fourni par le REPORTER orignellement et dont nous n'avons pas les sources, du nom TESTF1.EXE, qui vérifie que le fichier résultat généré par les pilotes logiciels est correct.

A savoir, il vérifie que le tour de piste a été effectué, dans le bon sens et à partir du point de départ imposé. Il contrôle, point par point, l'évolution de votre voiture sur la piste, pour savoir si vous ne faites que des déplacements autorisés et si vous n'entrez pas en collision avec le bord de la piste.

De plus TESTF1 joue le rôle de chronomètre officiel de chaque course.

Il compte le nombre de coups nécessaires à votre voiture pour effectuer le tour de piste et extrapole le dernier coup afin de donner un temps au centième de seconde...

Par ailleurs, il calcule la vitesse moyenne de votre Formule 1, qui sert de départager des éventuels ex aequo.

Vous verrez qu'à l'usage, le programme TESTF1 est très utile, pour vous aider à mettre au point votre pilote.

Certaines options du programme ont en effet été rajoutées juste pour vous faciliter le déboguage de vos sources.

Le programme TESTF1.EXE joue donc à la fois le rôle d'arbitre et de chronométreur officiel du concours !

TESTF1 se lance a partir du DOS, à l'aide d'une ligne de commande de ce type :

TESTF1 fichier_résultat [-nxxx] [-t] [-l]

Les paramètres entre crochet [] sont des paramètres facultatifs.

En plus du nom du fichier résultat que TESTF1 est censé contrôler, on peut lui indiquer différentes options :

– -nxxx : Dans cette option le xxx correspond à un chiffre (par défaut le programme utilise -n100). Ce chiffre exprime, en centièmes de seconde, le temps d'attente entre l'affichage de deux points successifs du fichier résultat.

TESTF1 est en effet un programme qui vous permet aussi de visualiser la course, comme si vous y étiez ! (si votre ordinateur est équipé d'une carte VGA)

Ce paramétrage permet d'accélérer à volonté l'affichage, pour ceux qui n'ont pas la patience d'attendre.

A noter la possibilité d'indiquer -n0, qui commute le programme en mode pas à pas (Il faut appuyer sur une touche du clavier entre chaque déplacement...). C'est très pratique pour mettre son pilote logiciel au point !

– -t : Pour ceux qui n'ont vraiment pas la patience d'attendre, ou simplement ceux qui n'ont pas de carte VGA, l'option -t désactive l'affichage graphique. Le résultat est donné, brut de fonderie, en mode texte.

– -l : TESTF1 ne se contente pas de tout cela... Pour nous faciliter notre futur travail de dépouillement du résultat des courses, TESTF1 génère un fichier résumé, globalisant les résultats obtenus sur un circuit donné. TESTF1 crée et entretient un fichier de nom :

nom_du_circuit.LOG

pour chaque fichier circuit (extension .CIR). Par ce biais il recense tous les résultats obtenus sur ce circuit.

Cela peut vous être aussi utile, pour analyser les progrès de votre programme.

L'option -l interdit au programme TESTF1 d'ajouter le résultat au fichier LOG du circuit.

[1] Sur un 486 DX2 66mhz

Attention, ce article est une copie de l'article original publié dans le Reporter n°7.
Les logiciels dont on parle ici fonctionnenet sous DOS, vous pouvez utiliser soit DOSemu, sous linux, soit FreeDOS (qui est un OS à part entiÚre).

Le concours du reporter

Gaétan RYCKEBOER, Pascal Brognez — 2003-01-15T12:57:43Z

Pour les vacances 1995, période propice à la méditation, la réflexion et le jeu, le Reporter lançait un concours de programmation auprÚs de ses lecteurs.

Cette période avait été choisie spécialement en pensant aux étudiants qui auraient ainsi plus de temps à y consacrer qu'en période scolaire (s'ils n'ont pas autre chose a penser bien sur :-).

Aujourd'hui, CLX se propose de faire revivre ce concours sous Linux, en adaptant les rÚgles.

Introduction

L'objet du concours en lui-même est très simple. Il va s'agir de créer un pilote logiciel de formule 1.

Ce concours se veut rester dans l'esprit qui anime le REPORTER depuis sa création, à savoir rester accessible à tous quelque soit son niveau en programmation et être un moyen de partager une passion via le plaisir du "jeu" et non pas pour l'appât du gain.

Ce concours n'est donc pas primé selon le concept traditionnel Faire les choses comme tout le monde n'est pas notre sport favori :-). Ce qui ne veut pas dire que les participants n'y trouveront pas leur bonheur.

Outre le plaisir de participer que procure un jeu collectif, les 50 premiers d'entre-vous qui nous auront fait parvenir le résultat de leurs cogitations avant la clôture du concours recevront tous un cadeau.

Bien entendu cela ne concerne que les 50 premiers qui nous auront envoyé un programme parfaitement opérationnel, c'est-à-dire capable de traiter dans le respect des règles et sans planter au moins 70% des circuits qu'il aura à parcourir. Voilà qui va décevoir les astucieux qui espèraient envoyer un p'tit programme se contentant de s'exécuter rien que pour obtenir un cadeau :-)

Ici seul le mérite compte, il n'est pas nécessaire d'être vainqueur pour avoir droit à son cadeau.

A l'époque, celui-ci se présentait sous la forme d'un abonnement gratuit d'un an (4 numéros) au Reporter.

Les participants auraient reçu donc dans leur boite à lettre dès sa parution et en priorité le REPORTER sur disquette en version Dos et Windows. Et comme il restait de la place sur ces supports, Le reporter n'aurait pas manqué de la combler avec quelques petits bonus.

Aujourd'hui, nous proposons des cadeaux de valeur comparable, c'est à dire un abonnement gratuit à la liste de diffusion du CLX, un accès privilégié au site WEB de CLX ave la possibilité de publier des articles, et peut-être d'autres bonus. Si d'aimables mécènes souhaitent apporter leur contribution à la renaissance de ce concours en faisant bénéficier ces mêmes 50 premiers candidats de petits cadeaux, ils seront les bienvenus.

Nous ne manquerons pas de les signaler sur le site.

Dernière petite chose, tous les mois précédant la clôture du concours, nous ferons paraître les résultats des programmes reçus obtenus sur un circuit de référence (avec le nom de leur auteur bien sûr).

Il est temps maintenant que vous preniez connaissance des règles du jeu, mais n'oubliez pas que si l'important est de participer (Pierre de Coubertin), l'essentiel est de s'amuser (Le Reporter).

– présentation générale du concours
– règles d'évolution de la F1
– règles de description du circuit

en cours de rédaction
– syntaxe des fichiers résultat
– structure du pilote automatique
– création et vérification des circuits
– chronométrage du résultat
– règles de participation
– épreuves de qualification
– résumons par un exemple concret
– Le concours du Reporter : Annexes

Présentation

A la base, il s'agit d'un concours de programmation : chaque participant doit écrire un programme qui permet de piloter au plus vite une formule 1 sur un circuit quelconque dont il ne connait pas a priori le parcours.

Il faut donc écrire un programme de pilote automatique de formule 1.

En fait ce concours s'apparente à celui organisé à sa grande époque, par la revue Micro-Système. Ce concours avait passionné une bonne partie de la France, mais limitait fortement la participation car il fallait réaliser un vrai modèle réduit de voiture.

La différence c'est qu'ici le concours est uniquement logiciel et chacun peut facilement participer : il suffit de posséder un ordinateur compatible PC. Peu de moyens sont donc nécessaires (c'est ouvert à tous ou presque) et seule l'astuce du programmeur lui permettra de faire la différence.

Pour cela, des règles très simples définissent le comportement 'physique' de la voiture sur la piste. Le programme doit respecter ces règles, tout en suivant le tracé de la piste qui constitue le circuit, et joindre au plus vite la ligne d'arrivée.

L'originalité de ce concours réside dans le fait que même les organisateurs du concours (nous-même) ignorent sur quelles pistes se dérouleront les courses !

En effet chaque participant doit aussi fournir un fichier 'circuit' contenant une piste dont le tracé est laissé à sa discrétion, (et qui a priori favorisera son propre pilote).

Chacun des participants fera tourner sa voiture sur son propre circuit, mais aussi sur les circuits de ses adversaires.

Bref pour gagner, il faut jouer sur les deux tableaux :

– 1) Développer un pilote logiciel qui puisse tourner vite sur n'importe quel circuit sans en connaitre a priori le parcours.
– 2) Décrire un circuit sélectif, qui tendra à pieger et ralentir au maximum les pilotes adversaires par sa complexité tout en favorisant le sien.

Bien entendu il n'est pas question que vous perdiez du temps à créer un circuit ou un programme de chronométrage.

Sont donc fournis gratuitement avec ce numéro un programme vous permettant de dessiner graphiquement un circuit conforme ainsi qu'un programme de chronométrage et de validation qui utilise le fichier des déplacements généré par votre pilote logiciel pour évaluer ses performances.

L'éditeur de circuits originel nécessite une carte vga, mais n'est pas indispensable pour créer un circuit. Un simple éditeur de texte suffit comme expliqué plus loin, ce afin de rendre le concours accessible indépendamment du matériel PC utilisé. Par contre, le programme tourne sous DOS.

De même, ce n'est pas parce que l'on parle de 'tourner vite' ou de 'chronométrage' qu'il s'agit d'un concours favorisant un langage rapide (ASM par exemple). Comme vous le comprendrez en lisant cet article en détail, les temps en question sont des temps relatifs.

Plus que le langage et sa rapidité, c'est l'astuce du programmeur qui lui permettra de faire la différence. Tout le monde a ses chances dans ce concours, que ce soit un habitué du C ou du basic.

Règles d'évolution de la F1

Les règles qui régissent le déplacement d'une voiture sur la piste d'un circuit quelconque sont assez simples.

Elles sont basées sur un petit jeu qui se pratiquait (et se pratique sûrement encore !) alors que nous usions nos fonds de culottes sur les bancs du lycée...

Imaginez une feuille de papier quadrillée sur laquelle on a délimité une piste à l'aide de deux tracés continus formant un circuit bouclé sur lui-même (vous voyez, ce n'est que du matériel classique pour les cancres du fond de la classe : juste des stylos et du papier !).

Ça se jouait à deux (voire plus), et chacun utilisait un stylo-bille de couleur différente, qui correspondait à la couleur de sa voiture fétiche.

La position de la voiture - qui devait bien sûr toujours rester sur la piste - était indiquée par un petit point, à l'intersection d'une ligne horizontale et d'une ligne verticale du quadrillage de la feuille.

Chacun, à tour de rôle, déplaçait sa voiture, en respectant la règle simple récurrente suivante.

La nouvelle position de la voiture s'obtenait en reportant le déplacement précédent de la voiture, et en choisissant soit le point obtenu, soit l'un de ses 8 voisins immédiats.

Dans l'exemple représenté ci dessus, la voiture, dont le déplacement précédent était de un point vers le haut et de 4 vers la droite, peut maintenant choisir l'un des 9 points indiqué par ' ?' comme nouvelle position.

On constate que par ce simple mécanisme, on pouvait accélérer (augmenter le déplacement d'un point), freiner (diminuer d'un point) ou rester à vitesse constante indépendamment dans les deux directions.

On obtenait ainsi un comportement similaire à celui d'une voiture (essayez et vous verrez qu'il ne faut pas prendre des virages tendus à vitesse trop élevée !).

Bien entendu, il fallait aussi s'évertuer à éviter les collisions, soit avec les voitures adverses, soit avec la bord de la piste.

Les différences entre ce jeu scolaire et le concours sont peu nombreuses :

– Pour des raisons de simplification, la position de la voiture est au centre d'un carré (appelons-le "pixel", même si ce n'est pas une dénomination parfaite). Les bords de piste ne sont pas une ligne continue, mais sont aussi définis par des pixels carrés.

Voir ci-dessous un 'zoom' sur une portion de circuit :

– Le programme que vous avez à écrire (le pilote logiciel) doit décrire l'évolution d'une seule voiture sur la piste.

En fait, il s'agit plutôt d'essais de qualification que de la course en elle même. Chaque nouveau déplacement de la voiture correspond à un temps factice d'une seconde. La taille d'un
'pixel' correspond de façon arbitraire à celle d'un carré de 10 mètres par 10 mètres. Ces conventions permettent d'obtenir les vitesses de notre voiture virtuelle, exprimées en km/h, de façon assez réalistes.

Le chronomètrage de votre voiture correspond donc à un chiffre tout à fait identique quelque soit l'ordinateur, car il correspond au nombre de coups nécessaires pour boucler un circuit donné.

Le but, donc, c'est d'écrire un programme qui définit les positions successives de la voiture, en respectant les règles des déplacements, et suivant un tracé donné, afin de boucler un tour en moins de coups que les autres programmes.

Pour ce faire, le circuit est représenté dans un fichier à l'aide de caractères Ascii disposés dans une matrice rectangulaire de 100 lignes par 150 colonnes. Un caractère espace représente la
piste tandis que tout autre représente le décor. Les règles définissant le format de ce fichier sont décrites plus loin.

Le point de départ est fixé (c'est le point de coordonnées x=40 y=4), ainsi que le sens dans lequel il faut faire le tour du circuit (Départ vers la droite, soit un sens qui suit globalement celui des aiguilles d'une montre).

La vitesse au départ est nulle, ce qui signifie que le point d'arrivé du premier déplacement est un des 8 voisins du point de départ (ou plus exactement un des trois placés à sa droite, sinon le départ se ferait en marche arrière :-)

Le but du programme est donc d'écrire un fichier résultat donnant les différentes positions de la voiture calculées pour un circuit donné jusqu'à la ligne d'arrivée (de même coordonnées que le point de départ).

Il est, évidemment, interdit d'entrer en collision avec les bords de la piste, faute de quoi votre formule 1 sera considérée comme détruite et votre tour ne sera pas pris en compte ! (Ce n'est pas très solide ces bolides...)

Le fichier résultat est ensuite passé en paramètre au programme TESTF1.EXE qui se charge de vérifier que le circuit est bien bouclé, qu'il n'y a pas collisions, que les règles de déplacement sont respectées, et en final d'afficher les temps.

Il convient de préciser en détail la manière dont s'effectue les tests de collisions [1], qui vous empêchent de 'mordre' sur les bas
cotés pour couper un virage.

La règle est simple : on trace la ligne entre le point de départ et d'arrivée de la voiture, et si l'un des points intermédiaires n'est pas sur la piste, il y a collision !

Mais, me diront à juste titre certains d'entre vous, cette règle apparemment simple peut poser un problème, très connu par ceux qui ont déjà écrit des routines de tracé de lignes...

En effet certains cas particuliers peuvent devenir des cas litigieux, comme illustré par l'exemple suivant :

Le déplacement de la voiture est de 5 pixels vers la droite et de 1 pixels vers le haut (joignant les deux points jaunes. Pour les deux premiers et les deux derniers pixels, il n'y a pas de problème : si l'un des points gris n'est pas sur la piste, il y a collision.

Par contre pour un décalage de 5 pixels vers la droite, la voiture passe juste au milieu de deux pixels : ceux représentés en rouge. Il n'a pas de raison de privilégier a priori plus une solution que l'autre ! (alors que les routines de tracé de lignes feront un choix ou l'autre selon la manière dont elles sont programmées)

Nous avons donc décidé d'utiliser une routine de test de collision souple, à savoir de déclarer qu'il n'y a pas collision si l'un OU l'autre des deux pixels reste sur la piste.

Bien entendu si les deux pixels (l'un ET l'autre) sont hors de la piste, il y a collision.

Ainsi, quel que soit la routine de 'tracé' que vous utiliserez, le déplacement sera conforme, évitant toute ambiguïté.

Pour éviter toute discussion concernant la routine de test de collision un exemple de cet algorithme est donné, en langage Pascal (adaptation facile à tout autre langage).

Pour bien comprendre tout ce mécanisme très simple (bien que difficile à expliquer), vous trouverez ci-après quelques exemples illustrant les principes d'évolution.

Notez qu'il s'agit à chaque fois de portions de circuits.

Dans les exemples présentés, les positions précédentes de la voiture sont représentées en jaune

Pas de problème pour la voiture, elle contrôle bien sa vitesse, ce qui lui permet d'aborder le virage en toute quiétude...

Sur cet exemple, la voiture va trop vite.. Bien que restant toujours sur la piste, la trajectoire d'un point à l'autre coupe le bord, amenant la routine de test de collision à constater un accident.

Sur cet exemple la voiture ne va pas trop vite.. Elle reste
toujours sur la piste, et sur le point litigieux clignotant vert, la routine de test de collision, de par sa souplesse,
accepte la trajectoire, considérant que la voiture est passée
juste à gauche.

Dans ce cas, le programme déclarera la position de la voiture comme illicite. En effet, le dernier déplacement était de trois pixels vers la droite et la voiture se 'permet' brusquement un
déplacement que de un pixel.. La position permise de la voiture est l'un des points voisins du point blanc clignotant, ce qui signifie que le crash est inévitable...

La voiture va trop vite, mais heureusement une impasse lui permet de décélérer.. Il ne lui reste plus qu'à freiner à fond (jusqu'à un déplacement nul en X) pour reprendre le bon chemin, dans
l'autre sens.

Règles de description du circuit

Le fichier de description du circuit, d'extension CIR par convention, a pour but de délimiter la piste sur laquelle doit évoluer la voiture par rapport au reste du dessin.

Par convention, le circuit est compris dans un rectangle de longueur 150 et de hauteur 100 (limites extérieures).

Le fichier est donc simplement constitué d'un ensemble de 100 lignes de chaînes de caractères ASCII. Chaque chaîne de caractères est constituée de 150 caractères utiles, plus les classiques "carriage return" et "line feed" éventuels qui séparent les lignes.

On pourra donc relire aisément ce fichier et mettre les données dans un tableau de caractères de type (par exemple)

. donnee: array[0..149,0..99] 0 1 2 3 146 147 148 149 +-------------- -----------------+ 0 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +---+---+---+-- -+---+---+---+---¦ 1 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +---+---+---+-- -+---+---+---+---¦ 99 ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ ¦ +-------------- -----------------+

La première valeur du tableau, comprise entre 0 et 149, comporte les coordonnées en X (longueur) du dessin, avec la valeur 0 représentée classiquement à gauche sur l'écran.

La deuxième valeur du tableau, comprise entre 0 et 99, comporte les coordonnées en Y (hauteur) du dessin, avec la valeur 0 représentée classiquement en haut sur l'écran et correspondant à la première ligne du fichier CIR.

Pour distinguer la piste du reste du circuit, une convention simple : un point de la piste est indiqué dans le fichier par le caractère ' ' (espace, code ASCII 32).

Tout autre caractère ASCII doit être considéré par le programme pilote comme ne faisant pas partie de la piste, donc inaccessible à la voiture (rappel : une voiture hors piste provoque un accident qui l'élimine).

Néanmoins, pour permettre une représentation plus avenante du circuit, j'ai décidé d'utiliser une convention faisant correspondre une couleur à certains caractères ASCII.
Cette convention utilise les couleurs typiques de Windows, plutôt que celles de la carte VGA, pour permettre une conversion facile à partir d'un fichier "BMP" non compressé à 16 couleurs.

Cette convention est la suivante :

caractère	couleur
A	Noir
B	Rouge foncé
C	Vert foncé
D	Jaune foncé
E	Bleu foncé
F	Magenta foncé
G	Cyan foncé
H	Gris clair
J	Rouge vif
K	Vert vif
L	Jaune vif
M	Bleu vif
N	Magenta vif
O	Cyan vif
P	Blanc

Il faut noter que la couleur gris foncé est attribuée par convention au caractère espace (la piste) et non pas à la lettre 'I'.

Tous les autres caractères ASCII sont dessinés, dans les outils fournis, avec la couleur 'Vert vif'.

Rappelons cependant que ces codes de couleurs n'existent que pour faire joli, et qu'un circuit peut très bien être défini uniquement à l'aide de 'X' et ' ' via un éditeur de textes !

Mais rassurez-vous, vous pouvez complètement ignorer et oublier ces conventions de couleurs : un programme de dessin, CREECIR, est fourni ! Il est documenté plus loin, et va vous aider à créer votre circuit, ainsi que le colorier à votre (bon) goût.

Pour qu'un circuit soit considéré comme conforme, il faut qu'il vérifie les différentes règles suivantes :

– (1) La surface totale occupée par le circuit (piste et décors) doit être de taille 150*100, à savoir 100 lignes de 150 caractères (rappel)

– (2) La piste ne peut pas affleurer les bords du dessin. Plus précisément, on ne pas mettre de caractère ' ' en ligne 0 ou 99, ou en colonne 0 et 149. Le but de cette règle est de délimiter facilement le terrain sans avoir à y rajouter un bord fictif (et ainsi faciliter les tests !).

– (3) Une zone de piste est imposée : c'est le rectangle délimité par les points x=20, y=2 et x=59, y=6. C'est au milieu de cette zone que se situe le point de départ (x=40, y=4).

Après avoir bouclé un tour complet, en partant vers la droite (sens x croissant), la ligne d'arrivée est une ligne verticale, de la largeur de la piste, et située en x=40.

Le but de cette règle est, bien entendu, de fixer précisément les points de départ et la ligne d'arrivée, ainsi qu'une largeur et longueur de piste suffisante pour bien démarrer et passer la la ligne d'arrivée en accélération.

Le sens de rotation est fixé (globalement celui des aiguilles d'une montre), car la voiture doit se déplacer au départ dans le sens des x croissant (droite). Elle coupera la ligne d'arrivée lorsqu'elle aura atteint ou dépassé la coordonnée x=40, en venant bien entendu d'une position x plus faible (pas question de couper la ligne d'arrivée dans le mauvais sens !!!) :

La vitesse de départ est nulle, ce qui signifie, en pratique, que le premier point après la position (40,4) est l'un des voisins du point de départ.

– (4) Un seul chemin doit mener du départ vers l'arrivée. Le circuit doit donc être évidemment bouclé sur lui-même, mais il ne peut pas comporter d'ilôts au milieu de la piste. Par ilôt, j'entend un ou plusieurs caractères au beau milieu de la piste.

Par exemple ce genre de configurationest interdit :

Attention, ceci ne vous interdit pas certains 'pièges' amusants dans votre circuit. Par exemple la création d'impasses, ayant pour but de tromper les voitures adverses est permise.

– (5) La largeur de la piste est au minimum de 2. Le but de ce concours est d'écrire un pilote de Formule 1, et pas d'auto cross ! Cette règle peut s'énoncer plus précisément comme suit :
aucun point de la piste ne peut avoir pour "voisin" (i.e. une des 8 cases qui l'entoure) à la fois un bord de piste intérieur et un bord de piste extérieur. Il faut donc toujours au minimum deux caractères de piste (pixels) pour séparer les deux bords, y compris en diagonale.

Dans tous les cas de figure, si vous avez un doute sur la conformité de votre piste au règlement, le programme CREECIR est là pour vous aider en effectuant toutes les vérifications sur votre fichier CIR, et en indiquant, si nécessaire, pour quelle(s) raison(s) un circuit donné n'est pas conforme.

[1] Ci-joint un exemple en Pascal de l'algorithme de test de collision.

C'est une fonction surPiste, qui retourne vraie (TRUE) si la voiture reste sur la piste et faux (FALSE) lorsqu'il y a une collision dans le déplacement.

On suppose au départ que le joueur a placé son circuit dans un tableau donnee[x,y] et que le test donnee[x,y]=piste consiste à savoir si le point concerné est sur la piste.

Facile à adapter si on utilise une autre structure de données.

function surPiste(x,y,xf,yf:integer):boolean; { Teste si une ligne joignant x,y à xf,yf est sur le circuit. algorithme de Bresenham légèrement modifié pour les cas litigieux. retourne vrai (true) si on reste sur la piste, retourne faux (false) si on casse la voiture sur un bord. L. Rivière } var dx,dy,total,xi,yi:integer; ok:boolean; begin surPiste:=false; { Commençons par éliminer les cas triviaux } if donnee[x,y]<>piste then exit; { Retourne FAUX si on est pas déjà sur la piste! } if (x=xf) and (y=yf) then begin { Si on est sur la piste et que l'on bouge pas.. } surPiste:=true; exit; end; { Le cas général.. } ok:=true; { On commence, comme dans la plupart des algo de tracé, à se mettre dans le premier quadrant, pour raisonner avec des déplacement relatifs positifs } { D'abord en X.. dx toujours positif, xi prend le signe (±1) } if (xdy) then begin { Comme le déplacement en X est plus grand, on va y aller de x à xf avec l'incrémentant d'un xi à chaque fois. Le reste c'est quasi du Bresenham classique, à savoir que l'on incrémente un compteur (ici total) d'une valeur égale à deux fois le déplacement y. } total:=0; repeat x:=x+xi; total:=total+2*dy; if (total=dx) then ok:=(donnee[x,y]=piste) else ok:=false; { Le cas litigieux signalé pour le test de collision se repère au fait que le compteur tombe pile sur la valeur de dx. Dans ce cas on met une valeur booléenne (ok) à jour selon le fait que l'on soit sur la piste ou non, ceci avant la modification de Y. Si on est pas sur le cas litigieux, on met OK à false (comme si on était pas sur la piste), car par la suite on fera un OU logique... } if (total>=dx) then begin y:=y+yi; total:=total-2*dx; end; { Comme tout Bresenham, lorsque l'on atteint ou dépasse dx, on incrémente la valeur d'un cran } ok:=(ok or (donnee[x,y]=piste)); { Toute l'astuce du ok précédent. Si on était dans un cas litigieux on fait un 'ou' entre avant et après la décrémentation Y, donc on est sur la piste lorsque l'un ou l'autre des pixels l'est.. Sinon (cas non litigieux) on teste bien le seul pixel concerné car on fait un 'ou' avec une valeur initialement false } until (x=xf) or not(ok); { On arrête quand on est plus sur la piste ou que l'on a atteint l'objectif x=xf } end else begin { Idem mais avec un déplacement de base suivant Y } total:=0; repeat y:=y+yi; total:=total+2*dx; if (total=dy) then ok:=(donnee[x,y]=piste) else ok:=false; if (total>=dy) then begin x:=x+xi; total:=total-2*dy; end; ok:=(ok or (donnee[x,y]=piste)); until(y=yf) or not(ok); end; surPiste:=ok; end;

Notez-bien qu'actuellement CLX n'a pas redéveloppé sous Linux, les outils initiaux, fournis par le Reporter et programmés par Luc RiviÚre. Par contre, si vous avez installé FreeDOS (un DOS sous GPL) sur votre machine ou Dosemu (un émulateur DOS sous linux), vous pourrez les utiliser.

Nous allons réécrire des versions minimales de ces outils sous linux et les mettre sous licence GPL. Nous les publieront ici dans un avenir plus ou moins proche (à moins que vous ne vous sentiez le courage de le faire vous-même et d'en faire profiter la communauté entiÚre, bien sûr).

Notez également que la participation au présent concours implique que votre pilote soit publié sur le site de CLX à l'issue du concours sous la license libre de votre choix.

Vous trouverez tous les numéros du Reporter sur le site de l'un des ancien R.O.R.