Discussion :

[aziz1015]

Bonjour,

je dois concevoir le jeu Puissance4 en projet, j'arrive à une question où il est demandé d'organiser un jeu où le temps de réponse est limité. c'est à dire que si le temps de jeu du joueur1 est de 5000ms, ça sera au tour du joueur2 de jouer après les 5s que le joueur 1 ait joué ou pas. le jeu en lui-même fonctionne déjà bien mais je n'arrive pas intégrer cette contrainte.

Pour cela, je dois rajouter un attribut

int temps

à la

classe JoueurMCTS (La classe JoueurMCTS dérivée de la classe Joueur met en oeuvre l’algorithme MCTS pour un nombre d’itérations fixé. L’attribut float a est un paramètre positif qui intervient pour le choix du coup le plus prometteur lors de la phase de sélection.)

qui doit correspondre au temps (en millisecondes) de réponse de la méthode Jouer et changer le constructeur de ma classe joueurMICTS comme ceci

JoueurMCTS(float a, int temps)

.

J'ai modifié ma méthode Jouer comme ci-dessous mais cela ne fonctionne pas, à vrai dire, je ne sais pas comment faire, j'ai bidouillé ceci en ayant découvert les thread.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
public override int Jouer(Position p)
 {
                Thread th = Thread.CurrentThread;
                bool fini = th.Join(temps);
 
                racine = new Noeud(null, p);
                while(fini)
                {
                    // Sélection
                    Noeud no = racine;
                    do
                    {
                        no.CalculMeilleurFils(a);
                        no = no.MeilleurFils();
                    } while (no.fils.Length > 0 && no.cross > 0);
                    // Simulation
                    Resultat res = JeuHasard(no.p);
                    int re = p.j1aletrait ? 0 : 1;
                    if (res == Resultat.j1gagne) { re = 1; }
                    if (res == Resultat.j0gagne) { re = 0; }
                    // Rétropropagation
                    while (no != null)
                    {
                        no.cross += 1;
                        no.win += re;
                        no = no.pere;
                    }
                }
                racine.CalculMeilleurFils(a);
                Console.WriteLine(racine);
                return racine.indiceMeilleurFils; ;
}

Merci d'avance pour votre aide,

Cordialement

[aziz1015]

Bonjour,

Personne pour m'apporter de l'aide ?

😕

[jopopmk]

Salut,

je ne suis pas sûr que Thread.Join soit ce que tu cherches, ni même que tu aies besoin des threads.
Perso ce que je ferais dans la fonction Jouer :

* avant le bloc while(!fini) :
- positionner fini à false,
- prendre l'heure courante à la ms près (que j'appellorio baseDate),

* à la fin du bloc while(!fini) :
- reprendre l'heure courante à la ms près (que j'appellerai iterDate),
- si (iterDate - baseDate) > temps alors je positionne fini à true.

edit : je pars du principe que tu veux limiter le nombre d'itérations d'un while par une durée donnée, je n'ai pas considéré ton implémentation/besoin réel.

[Noxen]

Y a-t-il une contrainte qui empêche d'utiliser un Timer ?

[François DORIN]

Bonjour,

Si j'ai bien compris le problème, l'approche choisi actuellement n'est effectivement pas bonne. Au delà de la mauvaise utilisation de Thread.Join, c'est sa position dans le code : il est situé dans la méthode Jouer qui appelée une fois que le joueur a fait son mouvement (et ensuite dans cette méthode tu essaies de vérifier si le délai est dépassé ou pas).

Aussi, ce n'est la bonne approche. Tu l'as bien compris, il faut réussir à attendre la survenue d'un événement (le premier) parmi plusieurs (le joueur joue, délai dépassé). Pour cela, il y a typiquement plusieurs approches possibles :

• ou bien faire une boucle qui scrute à un rythme plus ou moins important les changements d'états dans ton jeu ;
• ou bien utiliser des tâches.

Ici, je serais tenté par utilisé l'approche multitâche. Tu peux créer deux tâches, une pour faire jouer le joueur, une autre pour vérifier le délai) et ensuite te mettre en attente de la terminaison d'une des tâches (via un Task.WaitAny par exemple ou Task.WhenAny). Dès qu'une tâche a terminé son exécution, tu peux annuler les autres tâches en cours (ici, il n'y en a qu'une) et continuer l'exécution du programme.

Tu peux aller jeter un oeil sur les articles que j'ai écrit concernant l'utilisation du pool de theads, et particulièrement [URL=http://fdorin.developpez.com/tutoriels/csharp/threadpool/part2/]le second [/C] qui traite justement de la manière de chaîner les tâches entre elles, c'est-à-dire de lancer une tâche dès qu'une autre a terminé son exécution.