Jeux mot le plus long : transfert entre serveur python et client console JS

Bonjour,

Je me permets d'écrire ce message car je suis vraiment désespéré cela fait bientôt une semaine que je bloque sur un même problème.

Je travail actuellement sur un jeu qui fournit une liste de lettres aux joueurs et les joueurs devront former un mot qui existe dans un dictionnaire. Celui qui fournit le mot le plus long a gagné. Je dois créer ce jeu sur navigateur et console. La version sur navigateur fonctionne sans problème mais la version sur console ne fonctionne pas alors que j'utilise littéralement les même fonctions pour le client navigateur et le client console Pour le serveur j'utilise Flask et pour la transmission de donnés j'utilise socket.io, le client et en JS. Lorsque je lance le serveur python sur console et et le client sur une autre console le jeu me demande de saisir mon nom et ensuite une série d'erreur apparait sur la console du serveur. Notamment j'ai un problème avec la fonction dichotomie alors que sur le navigateur cela fonctionne.

Code client:

Code:

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
const io = require('socket.io-client');
const readline = require('readline');
 
// Créer une interface readline pour obtenir l'entrée de l'utilisateur
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
 
// Créer une instance de client Socket.IO
const socket = io('http://127.0.0.1:5000');
 
// Fonction pour demander le nom du joueur via readline
function demanderNom() {
    return new Promise((resolve) => {
        rl.question("Entrez votre nom : ", (nomJoueur) => {
            resolve(nomJoueur);
            rl.close();  // Ferme l'interface readline une fois que l'entrée est reçue
        });
    });
}
 
// Lors de la connexion au serveur
socket.on('connect', async () => {
    console.log("Connecté au serveur");
 
    try {
        // Demander le nom du joueur et envoyer l'événement 'NouveauJoueur'
        const nomJoueur = await demanderNom();
        socket.emit('NouveauJoueur', nomJoueur);
 
        // Écouter les événements
        socket.on('Debutjeu', (data) => {
            console.log(`Les lettres choisies sont : ${data.lettres}`);
            socket.emit('ListeDeLettre', data);
        });
 
        socket.on('message', (data) => {
            console.log(`Message reçu du serveur: ${data}`);
        });
 
        // Boucle d'attente - la connexion est en écoute
        socket.on('disconnect', () => {
            console.log("Déconnecté du serveur");
        });
 
    } catch (error) {
        console.error("Erreur lors de la connexion ou de l'émission d'événements : ", error);
    }
});
 
// Gestion des erreurs de connexion
socket.on('connect_error', (error) => {
    console.log(`Erreur de connexion: ${error}`);
});
 
// Fermeture propre (par exemple, lors d'une déconnexion volontaire)
process.on('SIGINT', () => {
    console.log("Déconnexion du client...");
    socket.disconnect();
    process.exit();
});

code serveur:

Code:

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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
import copy
from dis import disco
from doctest import debug
import socket
from flask import Flask, render_template,request
from flask_socketio import SocketIO, emit
import random
import os
 
# Détermine le chemin absolu du répertoire où se trouve le script
dictionnaire_dir = os.path.dirname(os.path.abspath(__file__))
 
# Construit le chemin absolu du fichier dictionnaire
FichierDictionnaire = os.path.join(dictionnaire_dir, "dictionnaire.txt")
 
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
 
# Changer à 2 ou plus si vous souhaitez tester avec plusieurs joueurs
MAX_PLAYERS = 1
players_connected =0
ListPlayer=[]
players_sid = {}
players_mots={}
listPlusLongMot = []
 
@app.route('/')
def index():
    return render_template('index.html')  # Sert un fichier HTML séparé
 
@socketio.on('connect')
def handle_connection():
    print("Un joueur s'est connecté")
 
@socketio.on('NouveauJoueur')
def handle_New_Player(data):
    global ListPlayer
    global players_connected
    global l
 
    nom_joueur = data
    sid = request.sid
    # print(nom_joueur)
    if sid in players_sid:
        # Le joueur est déjà dans la liste, ne l'ajoutez pas à nouveau
        print(f"Le joueur {nom_joueur} est déjà dans la partie.")
        return
 
    if players_connected < MAX_PLAYERS:
        ListPlayer.append(nom_joueur)
        players_connected += 1
        players_sid[sid] = nom_joueur
        print(f"Joueur {nom_joueur} a rejoint. Nombre total de joueurs : {players_connected}")
        emit('majListeJoueurs', {'liste': ListPlayer}, broadcast=True)
        emit('attenteJoueur', {'message': 'En attente de joueurs...'}, broadcast=True)
    if players_connected == MAX_PLAYERS:
            # Rediriger tous les joueurs vers `index.html`
            emit('rediriger', {'url': '/index'}, broadcast=True)
 
            l = ListeLettre(7)
            print(l)
            emit('Debutjeu', {'message': 'La partie commence, voici ta liste des lettres :', 'lettres': l}, broadcast=True)
 
 
 
 
@socketio.on('disconnect')
def handle_disconnect():  
    global players_connected
    players_connected -= 1
    print(f"Un joueur déconnecté, nombre de joueurs est {players_connected}")
 
 
# Écoute l'événement 'new_message' envoyé par le client
@socketio.on('new_message')
def handleMessage(msg):
    print('Message: ' + msg)
    emit('message', msg, broadcast=True)  # Envoie le message à tous les clients
 
 
probabilteLettre = list(range(101)) # 0 a 100
random.shuffle(probabilteLettre)  
 
 
def LettreAleatoire():
    nombreAleatoire = random.choice(probabilteLettre)
    valeurLettre = [9, 11, 13, 16, 31, 33, 35, 37, 45, 46, 47, 52, 55, 61, 67, 69, 70, 76, 82, 88, 94, 96, 97, 98, 99, 101]
    alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    # Boucle pour vérifier où le nombre aléatoire se situe dans les intervalles de valeurLettre
    for i in range(len(valeurLettre) - 1):
        if nombreAleatoire <= valeurLettre[0]:
            return alphabet[0]
        if nombreAleatoire >= valeurLettre[i] and nombreAleatoire < valeurLettre[i + 1]:
            return alphabet[i]
    if nombreAleatoire == valeurLettre[-1]: # si nombreAleatoire = 101 lettre Z est renvoyer car probabilteLettre vas de 0 a 100
        return alphabet[-1]
 
# Fonction pour générer une liste de lettres aléatoires
def ListeLettre(nbLettre):
    listeFinale = []
    voyelle = ['A', 'E', 'I', 'O', 'U', 'Y']
 
    while True:
        lettre = LettreAleatoire()
        if lettre in voyelle:
            listeFinale.append(lettre)
            break
    while len(listeFinale) < nbLettre:
        lettre = LettreAleatoire()
        if lettre:
            listeFinale.append(lettre)  
    return listeFinale
 
 
def charger_donnees(fichier):
    liste_donnees = []
    with open(fichier, 'r') as file:
        for line in file:
            liste_donnees.append(line.strip())
    return liste_donnees
 
dicoListe = charger_donnees(FichierDictionnaire)
 
 
def recherche_dichotomique(liste, valeur):
    debut = 0
    fin = len(liste) - 1
    while debut <= fin:
        milieu = (debut + fin) // 2
        if liste[milieu][0] < valeur:
            debut = milieu + 1
        elif liste[milieu][0] > valeur:
            fin = milieu - 1
        else:
            return milieu
 
 
def dansDictionnaire(mot):
    index = recherche_dichotomique(dicoListe,mot[0])
    milieu = index
    while index < len(dicoListe) and dicoListe[index][0] == mot[0]:
        if dicoListe[index] == mot:
            return True
        index += 1
    index = milieu - 1
    while index >= 0 and dicoListe[index][0] == mot[0]:
        if dicoListe[index] == mot:
            return True
        index -= 1
    return False
 
 
 
 
def genererMots(l, taille_max):
    # print(l)
    print(f"Génération de mots jusqu'à la taille {taille_max}...")
    mots_actuels = l.copy()  # Commence avec les lettres individuelles
    tous_les_mots = list(set(mots_actuels)) # Copie initiale pour stocker tous les mots générés sans doublons
 
    for taille in range(2, taille_max + 1):
        nouveaux_mots = []
        for mot in mots_actuels:
            for lettre in l:
                nouveauMot = mot + lettre
                if dansDictionnaire(nouveauMot):
                    nouveaux_mots.append(nouveauMot)
                    print(f"Mot {nouveauMot} ajouté.")      
        tous_les_mots.extend(nouveaux_mots)  # Ajoute les nouveaux mots à la liste de tous les mots
        mots_actuels = nouveaux_mots  # Met à jour la liste des mots actuels pour la prochaine taille
    return list(set(tous_les_mots))   #renvoi la liste sans doublons
 
def plusLongMots(lettres, taille_max):
    print("Recherche des mots les plus longs jusqu'à la taille maximale spécifiée...")
    tous_les_mots = genererMots(lettres, taille_max)
    # if not tous_les_mots:  # Vérifier si tous_les_mots est vide
    #     return []
    max_taille = max(len(mot) for mot in tous_les_mots) if tous_les_mots else 0
    listeMotsPlusLong = [mot for mot in tous_les_mots if len(mot) == max_taille]
    print(f"Mots les plus longs de taille {max_taille}: {listeMotsPlusLong}")
    return listeMotsPlusLong
 
 
@socketio.on('ListeDeLettre')
def initialiseLettre(lettres):
    global listPlusLongMot
    listPlusLongMot=plusLongMots(lettres,len(lettres))
    # socketio.emit('ListeDeLettre',listPlusLongMot)
    print(f"Lettres initialisées : {lettres}")
    print(f"Mots les plus longs trouvés : {listPlusLongMot}")
 
@socketio.on('motDuJoueur')
def handle_mot(mot):
 
    sid =request.sid
 
    global players_mots
    global l
 
    #si le joueur saisi un mot en utilisant une ou plusieurs lettre qui ne sont pas dans celles proposées
    for i in range (len(mot)):
        if mot[i] not in l:
            emit('motInterdit',{'message':'Le mot saisi doit contenir les lettres proposées'}, to=sid)
            return
 
 
    tailleMot = len(mot)
    tailleMaxMot=len(listPlusLongMot[0])
    if (not dansDictionnaire(mot)):
        emit('motInterdit',{'message':'mots Introuve'}, to=sid)
        return 
    else:
        if sid not in  players_mots:
            players_mots[sid]=[]
        players_mots[sid].append(mot)
        if len(players_mots) == MAX_PLAYERS and all(players_mots.values()):
 
 
            mots_tous_joueurs = [mot for mots in players_mots.values() for mot in mots]
            mot_le_plus_long = max(mots_tous_joueurs, key=len) if mots_tous_joueurs else ""
            gagnants=[sid for sid , mots in players_mots.items() if mot_le_plus_long in mots]
 
            for gagnant in gagnants :
                mots_du_gagnant = players_mots[gagnant]
                a_trouve_long_mot = any(mot in listPlusLongMot for mot in mots_du_gagnant)
                mot_a_la_bonne_longueur = any(
                    len(mot) == len(listPlusLongMot[0]) and all(mot.count(lettre) <= l.count(lettre) for lettre in set(mot))
                        for mot in mots_du_gagnant
                    )
                if a_trouve_long_mot  :
                    emit('messageMax',{'message':'bravo vous avez trouvez un des mots le plus long '}, to =gagnant)
                elif mot_a_la_bonne_longueur:
                    emit('messageMax',{'message':'bravo vous avez trouvez un des mots le plus long '}, to =gagnant)
                else:
                    emit('messageCorrect', {'message':'bravo vous avez gagner sans trouvez le plus long mot  ','pluslongMOT':listPlusLongMot},to=gagnant)
                if sid not  in gagnants:
                    emit('messagePerdant', {'message':'vous avez perdue '}, to=sid)
            emit('finJeu', {'message': 'La partie est terminée. Merci d\'avoir joué !'}, broadcast=True)
 
        else :
            emit('enAttente', {'message' :'veuillez patienter, les autres joueurs saisissent leurs mots '},to=sid )
 
if __name__ == '__main__':  
    socketio.run(app, debug=True)

Comment ce fait-il que certaines fonctions marchent côté client navigateur et pas côté client console ?

Merci de bien vouloir m'aider
Cordialement,