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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
Juge automatique pour IA pour jeu générique...
==============================================
Les joueurs sont des programmes qui lisent des infos sur le jeu sur l'entrée
standard et jouent leur coups sur la sortie standard.
Organisation des fichiers
-------------------------
judge/ le code du juge
protocol.ml encodeur et décodeur pour le protocole décrit plus bas
core.ml la partie principale
main.ml la synchro et l'UI
morpionrec.ml la partie spécifique à un jeu
morpionrec/ dossier pour un jeu
joueur1/ dossier pour une IA
player le binaire/code du joueur
... fichiers de données perso
(le binaire est lancé dans le dossier du joueur)
joueur2/
player
...
201411202011.log log de chaque séance
201411202011.score enregistrement des scores de chaque séance
Protocole d'entrée-sortie
-------------------------
Le juge et le joueur s'envoient des messages
terminés par un retour à la ligne.
J : Juge, P : joueur
1. Le juge et le joueur se disent bonjour:
J Hello morpion-rec
P Hello morpion-rec
Le joueur doit charger ses données *avant* de répondre, car dès qu'il a
répondu on peut lui demnander de jouer et décompter son temps.
2. Lorsque c'est au joueur de jouer:
J Your turn secondes_pour_jouer
P Play des_infos_sur_le_coup
J OK
3. Lorsque l'adversaire a joué:
J Play des_infos_sur_le_coup
À partir de ce moment commence immédiatement le décompte du temps de
réflexion du joueur.
4. Lorsque la partie se termine, un des cas suivants se présentent:
J You win
J You lose
J Tie
J Eliminated
Le joueur répond alors:
P Fair enough
Le joueur doit enregistrer toutes ses données (apprentissage, ...) avant
d'envoyer ce message : en effet, le juge envoit un SIGTERM au joueur une fois
qu'il l'a reçu.
Organisation du tournoi
-----------------------
Chaque paire ordonnée de joueurs distincts est considérée (pour chaque paire de
joueurs, il y a deux matchs, un où chaque joueur commence). Les matchs sont mis
en attente, et n matchs sont lancés en parallèle (typiquement n = #CPU/2).
Interface de visualisation du juge
----------------------------------
On a une GUI avec les vues suivantes :
- Tableau des scores (classé, évidemment)
- Liste des matchs en cours, liste de tous les matchs (en cours et finis)
- Visualisation d'un match (géré par le jeu)
Les commandes sont les suivantes :
- Dans tous les modes:
- q : quitter (il y a un dialogue de confirmation)
- En mode tableau des scores:
- tab : aller à la liste des parties
- En mode liste des parties:
- tab : aller au tableau des scores
- f : afficher uniquement les matchs en cours/tous les matchs
- v : passe en mode 'partie en cours'
- n : passe en mode 'navigation des parties'
- r : lancer le tournoi ! (met tous les matchs du tournoi en attente)
- En mode 'partie en cours':
- tab : aller à la liste des parties
- En mode 'navigation des parties':
- n : partie suivante (next)
- p : partie précédente (prev)
- f : coup suivant (forward)
- b : coup précédent (back)
- a : début de partie
- z : fin de partie
Le morpion récursif
-------------------
Tout le monde connait les règles ;-)
Comment lancer le juge
----------------------
Prérequis : OCaml 3.12 à 4.02.
Instructions pour le cas du morpion récursif.
Pour compiler le juge :
$ cd judge/
$ ocamlbuild morpion_rec_judge.native
Pour compiler les IA d'exemple (Mayushii, FeirisuNyanNyan, AmaneSuzuha) :
$ cd morpion_rec/Mayushii/
$ make
Pour exécuter le juge :
$ cd morpion_rec/
$ ../judge/morpion_rec_judge.native .
Options supplémentaires pour la ligne de commande du juge : appeller le binaire
avec l'option `--help` pour en avoir la liste.
Les IA demo
-----------
Ci-présent quatre IA assez débiles à utiliser pour vos tests :
- Mayushii : joue le premier coup qu'elle trouve
- FeirisuNyanNyan : joue un coup au hasard
- Amane : joue un coup gagnant, ou joue un coup empêchant l'adversaire
de gagner immédiatement au coup suivant
- NiAh : joue le premier coup trouvé, et fait parfois des fautes qui l'éliminent
(merci à AP pour le code !)
|
