Changer les caractères d'une chaîne pour chaque client.

Version imprimable

22/01/2019, 20h14
Tchams

Changer les caractères d'une chaîne pour chaque client.

Slt slt, les développeur! J'ai un problème avec une chaîne de caractère comme une liste ou un fichier texte dans mon cas et je voudrais svp savoir comment ajouter à chaque fois qu'un client se connecte au serveur, une lettre qui est un grand "X" dans cette chaîne de caractère. Mais, ce qui me <tourmente> le plus est le fait que chaque client qui se connecte doit se voir comme un grand "X" mais doit voir tout les autres clients comme des petits "x" et pour cette partie je ne sais vraiment pas comment débuter.
Un ami youtuber (Jason CHAMPAGNE) m'a conseillé d'ouvrir le fichier et ajouter le caractère que je veux et fermer le fichier ceci à chaque fois qu'un client se connecte et d'indiquer explicitement que <j'affiches tous les autres clients avec un "x" minuscule, sinon d'utiliser au pire la méthode lower() sur ton caractère X en majuscule, ce qui le mettra en minuscule>.
C'est cette partie entre guillemet que je ne pige pas trop et que je voulais que l'on m'explique et je bien-sûr si je peu avoir d'autres éléments de réponse à mon problème, ça serai vraiment cool. Je voulais quand même montré où j'en suis déçu niveau réflexion.:)

J'attend vos réponses avec impatiente.
22/01/2019, 20h49
zancrows
Bonsoir,

Ouvrir un fichier ce fait à l'aide open() et pour ajouter faut il utiliser le mode "a",
ex:
Code:

1 2 3 4 fp = open("mon_fichier.txt", mode="a") fp.write("X") fp.close()
mais je ne vois ou ce situe votre problème ? avez vous commencé à coder quelque chose ?
23/01/2019, 03h14
Tchams

Oui oui! J'ai commencé quelque chose, mais je reste bloqué sur le changement des "X" en "x".
En fait :
- j'ai réussi à ouvrir le fichier (fichier texte) à chaque fois qu'un client se connecte
- j'ajoute un "X" dans le fichier ceci de manière aléatoire pour chaque client qui se connecte
- MAIS, je n'arrive pas à ce qu'un client puissent ce voir comme le seul grand "X" du fichier et que les autres lui soient présentés sous la forme de petit "x".

C'est sur ce troisième tiret que réside la difficulté pour moi. Je ne sais pas si d'ailleurs il existerai une "SUPER":twisted: méthode qui me traiterai ce cas efficacement
23/01/2019, 08h30
zancrows

Bonjour,

que vous dire par ajouter de manière aléatoire ? normalement si le fichier contient que des X et que le client qui se connecte est le dernier tu as juste à afficher tous les x en minuscule sauf le dernier.
ou alors je comprend mal la demande :aie:

edit : sinon quand tu écris dans le fichier il faudrait que tu associes le X du client à sa position dans le fichier et que quand il se connecte affiche cela affiche tous les X en minuscule sauf celui du client qui affiche son X par sa position. je ne sais pas si je suis clair :oops:
23/01/2019, 16h34
Tchams

Effectivement c'est un peu plus claire!!!

Le fichier est constitué d'autres lettres séparées par des espaces. Tout les "X" vont allés dans les espaces de manière aléatoire (j'utilise le module "randrange" pour cela).

Alors, devrais-je associé chaque "X" à un client? Et comment transformé les autres "X" en "x", quand j'utilise le module "index" ça ne me renvoi pas l'index de tout les "X" qui se trouve dans le fichier mais uniquement celui du premier "X" que ça trouve, c'est pour cela que j'arrive pas à modifier les autres "X". Si il y'a d'autres méthodes, ça serait vraiment superbe.:mouarf:
23/01/2019, 17h24
wiztricks

Citation:

Envoyé par Tchams

Si il y'a d'autres méthodes, ça serait vraiment superbe.:mouarf:

La méthode .replace est faite pour çà.

Citation:

Envoyé par Tchams

Effectivement c'est un peu plus claire!!!

Tant que vous n'arrivez pas à montrer un exemple du contenu du fichier (ou du contenu qu'on en affiche) dans les différents cas de figures, çà risque de rester cafouilleux.

- W

Bsr wiztricks!
Voilà mon code, c'est encore très sale car j'ai pas fini ce que je veux réaliser:

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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
 
 
 
#-*- coding:utf-8 -*-
 
# Définition d'un client réseau gérant en parallèle l'émission
# et la réception des messages (utilisation de 2 THREADS).
 
host = ''
port = 12000
 
import socket, sys, threading, select, time, os, pickle, random
from threading import Thread
 
mode = True
deplacement = True
encadrement = True
#from labyrinthe_3 import *
 
class ThreadReception(threading.Thread):
    """objet thread gérant la réception des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            message_recu = self.connexion.recv(1024).decode("Utf8")
            print("*" + message_recu + "*")
            if message_recu.upper() == "Q" or "":
                break
        # Le thread <réception> se termine ici.
        # On force la fermeture du thread <émission> :
        th_E._stop()
        print("Client arrêté. Connexion interrompue.")
        self.connexion.close()
 
class ThreadEmission(threading.Thread):
    """objet thread gérant l'émission des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            message_emis = input()
            self.connexion.send(message_emis.encode("Utf8"))
 
class ThreadClient(threading.Thread):
    """dérivation d'un objet thread pour gérer la connexion avec un client"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion_avec_client = conn
 
    def run(self):
        # Dialogue avec le client :
        nom = self.getName() # Chaque thread possède un nom
 
 
 
 
 
 
# Programme principal - Établissement de la connexion :
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    connexion_principale.bind((host, port))
except socket.error:
    print("La connexion a échoué.")
    sys.exit()
print("Connexion établie avec le serveur.")
 
 
 
########
def choix_carte():
    global b
    print ("Mode de jeux : 1- facile ou 2- prison ")
    b = input ("Bonjour! Veuillez choisir une carte en tappant le numéro correspondant : ")
    b = int(b)
    while mode:
        if b==1 or b==2:
            print ("Vous avez choisi le mode de jeux : ", b)
            break
        else:
            print ("Veuillez réessayer!")
            b = input()
            b = int(b)
 
choix_carte()
########
 
 
 
 
 
def ouverture_carte_1():
    global fihier, fs, txt_1, b, S, data, Fic, r, fic
    print ("facile")
 
    if len(clients_connectes) <= 1 :
        fs = open ("facile_0.txt", "r")
        fichier = open ("facile_1.txt", "w")
        txt = fs.read()
        fichier.write(txt)
        fs.close()
        fichier.close()
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
        #print (indices_espace)
 
        #for it in conn_client:
        indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 41, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
        r = random.choice(indices_espace)
        data = data[:r] + "X" + data[r+1:]
    else:
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        f = range(len(data))
 
        #for it in conn_client:
        indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 41, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
        r = random.choice(indices_espace)
 
        # On s'assure qu'il y ait pas collision des "X" au marquage des joueurs.
        if data[r] == "X":
            r = random.choice(indices_espace)
            data = data[:r] + "X" + data[r+1:]
        else:
            data = data[:r] + "X" + data[r+1:]
        print (data)
        fichier.close()
 
    # On enregistre le fichier après chaque connexion de clients.
    with open("facile_1.txt", "w") as fic:
        fic.write(data)
    with open("facile_1.txt", "r") as fic:
        Fic = fic.read()
 
 
if b==1:
 
 
    # Faire écouter le serveur
    connexion_principale.listen(5)
 
    serveur_lance = True
    clients_connectes = []
    conn_client = {}
 
    while serveur_lance:
        # On va vérifier que de nouveaux clients ne demandent pas à se connecter
        # Pour cela, on écoute la connexion_principale en lecture
        # On attend maximum 50ms
        connexions_demandees, wlist, xlist = select.select([connexion_principale],
                                                           [], [], 0.05)
 
        for connexion in connexions_demandees:
            connexion_avec_client, infos_connexion = connexion.accept()
            # On ajoute le socket connecté à la liste des clients
            clients_connectes.append(connexion_avec_client)
 
            # Créer un nouvel objet thread pour gérer la connexion :
            th = ThreadClient(connexion_avec_client)
            th.start()
            # Mémoriser la connexion dans le dictionnaire :
            it = th.getName() # identifiant du thread
            conn_client[it] = connexion_avec_client
            print (len(conn_client))
            print("Client %s connecté, adresse IP %s, port %s." %\
                  (it, infos_connexion[0], infos_connexion[1]))
 
            ouverture_carte_1()
            connexion_avec_client.send(data.encode("Utf8"))
 
            for clients in clients_connectes: #carte_choisie.labyrinthe.joueurs:
                #Il faut l'ajouter au jeux, en lui proposant la carte par exemple
 
                # Dialogue avec le client :
                msg = "Joueur : {} connecté \n".format(it)
                clients.send(msg.encode("Utf8"))
 
 
 
 
                #msg_a_envoyer = "Bienvenue, Joueur {} \n".format(clients.num)
                #joueur.socket.send(msg_a_envoyer.encode("Utf8"))
                #msg_a_envoyer = client.choix_carte()
                #clients.socket.send(msg_a_envoyer.encode("Utf8"))
                if len(clients_connectes) > 1:
                    msg_a_envoyer = "\nEntrez C pour commencer a jouer :\n"
                    clients.send(msg_a_envoyer.encode("Utf8"))
                    """msg_recu = clients.recv(1024)
                    msg_recu = msg_recu.decode("Utf8")
                    if msg_recu.upper() == "C":
                        serveur_lance = False
                        #Coté serveur
                        print("La partie commence et est en cours...")
                        break
                    # Si la saisie n'est pas bonne (n'est pas "C")
                    else:
                        msg_a_envoyer = "Saisie invalide. reprenez !"
                        client.send(msg_a_envoyer.encode("Utf8"))"""
 
 
 
        # Maintenant, on écoute la liste des clients connectés
        # Les clients renvoyés par select sont ceux devant être lus (recv)
        # On attend là encore 50ms maximum
        # On enferme l'appel à select.select dans un bloc try
        # En effet, si la liste de clients connectés est vide, une exception
        # Peut être levée
        clients_a_lire = []
        try:
            clients_a_lire, wlist, xlist = select.select(clients_connectes,
                [], [], 0.05)
        except select.error:
            pass
        else:
            # On parcourt la liste des clients à lire
            for client in clients_a_lire:
                msg_recu = client.recv(1024)
                msg_recu = msg_recu.decode("Utf8")
                # Si le joueur est seul
                if len(clients_connectes) < 2:
                    msg_a_envoyer = "Patientez qu'au moins un autre joueur se connecte !"
                    client.send(msg_a_envoyer.encode("Utf8"))
                    # Si le nombre de  joueurs est > 1 et que quelqu'un saisi "C", on commence la partie
                elif msg_recu.upper() == "C":
                    serveur_lance = False
                    #Coté serveur
                    print("La partie commence et est en cours...")
                    break
                # Si la saisie n'est pas bonne (n'est pas "C")
                else:
                    msg_a_envoyer = "Saisie invalide. reprenez !"
                    client.send(msg_a_envoyer.encode("Utf8"))
 
 
 
            """if serveur_lance:
                for clients in clients_connectes: #carte_choisie.labyrinthe.joueurs:
                    msg_a_envoyer = "La partie commence.\n"
                    #clients.socket.send(msg_a_envoyer.encode("Utf8"))
                    clients.send(msg_a_envoyer.encode("Utf8"))
                    #clients.socket.send(utils.INSTRUCTIONS.encode("Utf8"))
                    #msg_a_envoyer = carte_choisie.labyrinthe.generer_contenu(joueur)
                    #clients.socket.send(msg_a_envoyer.encode("Utf8"))
                    #clients.send(msg_a_envoyer.encode("Utf8"))
                    msg_a_envoyer = "Attendez que ce soit votre tour pour jouer !\n"
                    #clients.socket.send(msg_a_envoyer.encode("Utf8"))
                    clients.send(msg_a_envoyer.encode("Utf8"))
                    # On ne prend plus de joueurs on sort de la boucle while
                break"""
 
 
    print("Fermeture des connexions")
    for clients in clients_connectes:
        clients.close()
 
    connexion_principale.close()

Ce qui me coince, je dirai c'est le fat que par exemple:
- le client A doit se voir en "X" et voir le client B en "x"
- le client B doit se voir en "X" et voir le client A en "x"

Je dirais que mon problème pourrais se résoudre dans la fonction "ouverture_carte_1":?

Et voilà mon fichier 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
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
 
 
 
#-*- coding:utf-8 -*-
 
"""Ce fichier contient le code l'application client.
 
        Exécutez-le avec python( version 3) pour connecter un joueur au serveur.
 
"""
 
###################### Import des modules #########################################################
 
import sys # Module pour interragir avec le système
import socket # Module socket pour créer des objets de connexion
import threading # Module pour la programmation parallèle
import time # Ici pour simuler des délais
 
#import utils # Module regroupant des objets utils
 
 
###################### Definition de 2 Threads : l'un pour l'envoi et l'autre la reception#########
 
class Recevoir(threading.Thread):
 
    """Objet thread gérant la réception des messages"""
 
    def __init__(self, connexion):
 
        threading.Thread.__init__(self)
        self.connexion = connexion
 
    def run(self):
 
        while True:
 
            try:
                msg_recu = self.connexion.recv(1024)
            except socket.error:
                print("Vous êtes déconnecté du serveur")
                break
            else:
                msg_recu = msg_recu.decode("Utf8")
                print(msg_recu)
 
        tps=time.time()
 
        while time.time() - tps < 3 :
            pass
 
        self.connexion.close()
        sys.exit()
 
 
 
 
 
class Envoyer(threading.Thread):
 
    """objet thread gérant l'émission des messages"""
 
    def __init__(self, connexion):
 
        threading.Thread.__init__(self)
        self.connexion = connexion
 
        def run(self):
 
            while True:
 
                try:
                    msg_a_envoyer = input()
                except socket.error:
                    print("Vous êtes déconnecté du serveur")
                else:
                    self.connexion.send(msg_a_envoyer.encode("Utf8"))
                    if msg_a_envoyer.upper() == "Q" or "":
                        break
 
            tps=time.time()
            while time.time() - tps < 3 :
                pass
 
            self.connexion.close()
            sys.exit()
 
 
####################### Programme principal du client : Connexion avec le serveur######################
 
HOTE = 'localhost' # on s'attend à une connection de n'importe quel hote 
PORT = 12000 # port d'écoute du serveur
 
connexion_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
try:
    print("On tente de se connecter au serveur...\n")
    connexion_server.connect((HOTE, PORT))
except socket.error:
    print ("La connexion a échoué.")
    sys.exit()    
else :
    print("Connexion établie avec le serveur.")
 
# Dialogue avec le serveur : on lance deux threads pour gérer
# indépendamment l'émission et la réception des messages :
thread_envoi = Envoyer(connexion_server)
thread_reception = Recevoir(connexion_server)  
 
thread_reception.start()
thread_envoi.start()
 
thread_reception.join()
thread_envoi.join()

25/01/2019, 16h06
wiztricks

Où est:

Citation:

un exemple du contenu du fichier (ou du contenu qu'on en affiche) dans les différents cas de figure, çà risque de rester cafouilleux.

Y a pas... donc je ne sais pas d'où on part et ce qu'on doit obtenir... et tant que vous ne prenez pas le temps de l'exprimer, comme on n'est pas dans votre tête, on ne peut pas le savoir...

- W

2 pièce(s) jointe(s)

Désolé j'avais oublié d'envoyer le fichier texte.:ange:

J'ai un peu améliorer les codes entre temps, les voici:
Coté 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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
 
 
#-*- coding:utf-8 -*-
 
# Définition d'un client réseau gérant en parallèle l'émission
# et la réception des messages (utilisation de 2 THREADS).
 
host = ''
port = 12000
 
import socket, sys, threading, select, time, os, pickle, random
from threading import Thread
 
mode = True
deplacement = True
encadrement = True
Arret = True
 
 
 
class ThreadReception(threading.Thread):
    """objet thread gérant la réception des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            msg_recu = self.connexion.recv(1024).decode("Utf8")
            print("*" + msg_recu + "*")
            if msg_recu.upper() == "Q" or "":
                break
        # Le thread <réception> se termine ici.
        # On force la fermeture du thread <émission> :
        th_E._stop()
        print("Client arrêté. Connexion interrompue.")
        self.connexion.close()
 
class ThreadEmission(threading.Thread):
    """objet thread gérant l'émission des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            msg_emis = input()
            self.connexion.send(msg_emis.encode("Utf8"))
 
class ThreadClient(threading.Thread):
    """dérivation d'un objet thread pour gérer la connexion avec un client"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion_avec_client = conn
 
    def run(self):
        # Dialogue avec le client :
        nom = self.getName() # Chaque thread possède un nom
 
 
 
 
 
 
 
# Programme principal - Établissement de la connexion :
connexion_principale = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    connexion_principale.bind((host, port))
except socket.error:
    print("La connexion a échoué.")
    sys.exit()
print("Connexion établie avec le serveur.")
 
 
 
########
def choix_carte():
    global b
    print ("Mode de jeux : 1- facile ou 2- prison ")
    b = input ("Bonjour! Veuillez choisir une carte en tappant le numéro correspondant : ")
    b = int(b)
    while mode:
        if b==1 or b==2:
            print ("Vous avez choisi le mode de jeux : ", b)
            break
        else:
            print ("Veuillez réessayer!")
            b = input()
            b = int(b)
 
choix_carte()
########
 
 
 
 
###########
def ouverture_carte_1():
    global fihier, fs, txt_1, b, S, data, Fic, r, fic
    print ("facile")
 
    if len(clients_connectes) <= 1 :
        fs = open ("facile_0.txt", "r")
        fichier = open ("facile_1.txt", "w")
        txt = fs.read()
        fichier.write(txt)
        fs.close()
        fichier.close()
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
        #print (indices_espace)
 
        #for it in conn_client:
        indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 41, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
        r = random.choice(indices_espace)
        data = data[:r] + "X" + data[r+1:]
    else:
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        f = range(len(data))
 
        #for it in conn_client:
        indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 41, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
        r = random.choice(indices_espace)
 
        # On s'assure qu'il y ait pas collision des "X" au marquage des joueurs.
        if data[r] == "X":
            r = random.choice(indices_espace)
            data = data[:r] + "X" + data[r+1:]
        else:
            data = data[:r] + "X" + data[r+1:]
        print (data)
        fichier.close()
 
    # On enregistre le fichier après chaque connexion de clients.
    with open("facile_1.txt", "w") as fic:
        fic.write(data)
    with open("facile_1.txt", "r") as fic:
        Fic = fic.read()
############
 
 
 
 
 
###########
def deplacer():
    global l, ld
    #l = input ("Déplacez votre robot avec 'n' pour le haut, 'e' pour la droite, 's' pour le bas et 'o' pour la gauche : ")
    #l = str(l)
    #msg_a_envoyer = "\nDéplacez votre robot avec 'n' pour le haut, 'e' pour la droite, 's' pour le bas et 'o' pour la gauche : \n"
    #clients.send(msg_a_envoyer.encode("Utf8"))
    l = connexion_avec_client.recv(1024)
    l = l.decode("Utf8")
    l = str(l)
    while deplacement:
        if l.lower()=="n":
            print ("Dépalcement vers le haut")
            ld = -11
            break
        elif l.lower()=="e":
            print ("Déplacement vers la droite")
            ld = 1
            break
        elif l.lower()=="s":
            print ("Déplacement vers le bas")
            ld = 11
            break
        elif l.lower()=="o":
            print ("Déplacement vers la gauche")
            ld = -1
            break
        else:
            #msg_a_envoyer = "Saisie invalide. reprenez !"
            msg_a_envoyer = "\nVeuillez reprendre.\n"
            connexion_avec_client.send(msg_a_envoyer.encode("Utf8"))
            l = connexion_avec_client.recv(1024)
            l = l.decode("Utf8")
##############
 
 
 
 
 
#############
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
if b==1:
 
 
    # Faire écouter le serveur
    connexion_principale.listen(5)
 
    serveur_lance = True
    clients_connectes = []
    conn_client = {}
 
    while serveur_lance:
        # On va vérifier que de nouveaux clients ne demandent pas à se connecter
        # Pour cela, on écoute la connexion_principale en lecture
        # On attend maximum 50ms
        connexions_demandees, wlist, xlist = select.select([connexion_principale],
                                                           [], [], 0.05)
 
        for connexion in connexions_demandees:
            connexion_avec_client, infos_connexion = connexion.accept()
            # On ajoute le socket connecté à la liste des clients
            clients_connectes.append(connexion_avec_client)
 
            # Créer un nouvel objet thread pour gérer la connexion :
            th = ThreadClient(connexion_avec_client)
            th.start()
            # Mémoriser la connexion dans le dictionnaire :
            it = th.getName() # identifiant du thread
            conn_client[it] = connexion_avec_client
            print (len(conn_client))
            print("Client %s connecté, adresse IP %s, port %s." %\
                  (it, infos_connexion[0], infos_connexion[1]))
 
            ouverture_carte_1()
            connexion_avec_client.send(data.encode("Utf8"))
 
            for clients in clients_connectes: #carte_choisie.labyrinthe.joueurs:
                #Il faut l'ajouter au jeux, en lui proposant la carte par exemple
 
                # Dialogue avec le client :
                msg = "Joueur : {} connecté \n".format(it)
                clients.send(msg.encode("Utf8"))
 
 
 
 
                #msg_a_envoyer = "Bienvenue, Joueur {} \n".format(clients.num)
                #joueur.socket.send(msg_a_envoyer.encode("Utf8"))
                #msg_a_envoyer = client.choix_carte()
                #clients.socket.send(msg_a_envoyer.encode("Utf8"))
                if len(clients_connectes) > 1:
                    msg_a_envoyer = "\nEntrez C pour commencer a jouer :\n"
                    clients.send(msg_a_envoyer.encode("Utf8"))
 
 
 
        # Maintenant, on écoute la liste des clients connectés
        # Les clients renvoyés par select sont ceux devant être lus (recv)
        # On attend là encore 50ms maximum
        # On enferme l'appel à select.select dans un bloc try
        # En effet, si la liste de clients connectés est vide, une exception
        # Peut être levée
        clients_a_lire = []
        try:
            clients_a_lire, wlist, xlist = select.select(clients_connectes,
                [], [], 0.05)
        except select.error:
            pass
        else:
            # On parcourt la liste des clients à lire
            for client in clients_a_lire:
                #th_r = ThreadReception(client)
                #th_r.start()
                msg_recu = client.recv(1024)
                msg_recu = msg_recu.decode("Utf8")
                # Si le joueur est seul
                if len(clients_connectes) < 2:
                    msg_a_envoyer = "Patientez qu'au moins un autre joueur se connecte !"
                    client.send(msg_a_envoyer.encode("Utf8"))
                    # Si le nombre de  joueurs est > 1 et que quelqu'un saisi "C", on commence la partie
                else:
                    if msg_recu.upper() == "C":
                        serveur_lance = False
                        #Coté serveur
                        print("La partie commence et est en cours...")
                        break
                    # Si la saisie n'est pas bonne (n'est pas "C")
                    else:
                        msg_a_envoyer = "Saisie invalide. reprenez !"
                        client.send(msg_a_envoyer.encode("Utf8"))
 
 
 
            """if serveur_lance:
                for clients in clients_connectes:
                    msg_a_envoyer = "La partie commence.\n"
                    clients.send(msg_a_envoyer.encode("Utf8"))
                    msg_a_envoyer = "Attendez que ce soit votre tour pour jouer !\n"
                    clients.send(msg_a_envoyer.encode("Utf8"))
                    # On ne prend plus de joueurs on sort de la boucle while
                break"""
 
    while Arret:
        msg_a_envoyer = "\nDéplacez votre robot avec 'n' pour le haut, 'e' pour la droite, 's' pour le bas et 'o' pour la gauche : \n"
        connexion_avec_client.send(msg_a_envoyer.encode("Utf8"))
 
        deplacer()
 
 
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        lenn = len(data)
        print (lenn)
        f = range(lenn)
 
        indices_tout_X = list(set(data[k:].index("X") + k for k in f if "X" in data[k:]))
        print (indices_tout_X)
 
        index_X = data.index("X")
        print (index_X)
        index_U = data.index("U")
        Arret = False
 
 
 
 
 
 
 
 
 
    print("Fermeture des connexions")
    for clients in clients_connectes:
        clients.close()
 
    connexion_principale.close()

Coté 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
 
 
# Définition d'un client réseau gérant en parallèle l'émission
# et la réception des messages (utilisation de 2 THREADS).
 
host = 'localhost'
port = 12000
 
import socket, sys, threading
 
class ThreadReception(threading.Thread):
    """objet thread gérant la réception des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            message_recu = self.connexion.recv(1024).decode("Utf8")
            print(message_recu)
            if not message_recu or message_recu.upper() =="Q":
                break
        # Le thread <réception> se termine ici.
        # On force la fermeture du thread <émission> :
        th_E._stop()
        print("Client arrêté. Connexion interrompue.")
        self.connexion.close()
 
class ThreadEmission(threading.Thread):
    """objet thread gérant l'émission des messages"""
    def __init__(self, conn):
        threading.Thread.__init__(self)
        self.connexion = conn # réf. du socket de connexion
 
    def run(self):
        while 1:
            message_emis = input()
            self.connexion.send(message_emis.encode("Utf8"))
            if not message_emis or message_emis.upper() =="Q":
                break
        th_R._stop()
        print("Client arrêté. Connexion interrompue.")
        self.connexion.close()
 
# Programme principal - Établissement de la connexion :
connexion = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
    print("On tente de se connecter au serveur...\n")
    connexion.connect((host, port))
except socket.error:
    print("La connexion a échoué.")
    sys.exit()
print("Connexion établie avec le serveur.")
 
# Dialogue avec le serveur : on lance deux threads pour gérer
# indépendamment l'émission et la réception des messages :
th_E = ThreadEmission(connexion)
th_R = ThreadReception(connexion)
th_E.start()
th_R.start()

Le code n'est pas fini pour ce cas si mais en console j'ai réussi à le terminer. C'est parce que je ne voix toujours pas comment je ferai avec la différenciation des différents "X":(

27/01/2019, 15h25
wiztricks

Citation:

Envoyé par Tchams

Désolé j'avais oublié d'envoyer le fichier texte.:ange:

Dans le premier fichier, il n'y a pas de X et dans l'autre, il y en a deux.
Pourquoi ils apparaissent? à quoi çà correspond? Mystère...

- W
28/01/2019, 15h04
Tchams

Salut salut!
Il faut juste remplacé les "X" par des vides j'avais fait un essai avec le code et ça a enregistrer. J'ai omis de vérifier avant d'envoyer
28/01/2019, 16h02
wiztricks

Citation:

Envoyé par Tchams

Salut salut!
Il faut juste remplacé les "X" par des vides j'avais fait un essai avec le code et ça a enregistrer. J'ai omis de vérifier avant d'envoyer

Dans ce cas, str.replace(<votre texte>, 'X', '') devrait suffire.

- W
28/01/2019, 20h51
Tchams

Non Non wiztricks!

Je te demandais de remplacé stp les "X" de ce fichier par des espaces;). En bref, tu efface les "X" et tu tape sur "espace".
Mon problème reste le même que depuis le début, à savoir: comment faire en sorte que le joueur 1 se voix en "X" et voix le joueur 2, 3 ou 4 en "x" et même chose pour les autres joueurs, ils doivent tous voir leur adversaire en comme des "x" et se voir en "X".
28/01/2019, 21h33
bistouille

Salut.

J'ai lu une seconde fois ton sujet depuis le début, et pour ma part je ne comprends rien à ton problème, je ne crois pas être le seul.
Il faudrait quand même détailler d'où sortent tes X, décrire de A à Z comment se déroule ton application, car cela semble tout à fait clair pour toi, mais pour nous lecteurs, c'est complètement obscur.

Si tu as besoin que chaque "joueur" se voient représentés par tel caractère, il me semble que ce serait au serveur de faire ce travail, ce qui fait que dans tes fichiers *.txt, ce n'est pas des "X" qu'il faudrait enregistrer, mas des identifiants clients, et en fonction de "à quel client" est transmis le contenu de ton fichier txt, il suffirait alors de remplacer l'id client destinataire par X et les autres par x.
29/01/2019, 07h53
Tchams

Bonjour bistouille, tu as tout compris à mon problème. Et c'est justement le fait de donné un identifiant à tout les clients pour pouvoir les distingués et ainsi faire le changement des "X" qui pour moi est difficile.:traine:

Comment pourrais-je agencé mon code, à quels endroits ferais-je des modifications??? Je suis vraiment en panne d'inspiration.
29/01/2019, 08h38
wiztricks

Citation:

Envoyé par Tchams

Comment pourrais-je agencé mon code, à quels endroits ferais-je des modifications??? Je suis vraiment en panne d'inspiration.

Il va falloir associer une connexion client à un numéro de client, le faire correspondre à quelque chose dans le fichier et expédier le contenu du fichier mis à jour aux différents clients.
Donc vous savez où doit être modifié le code.
Mais comme vous n'avez toujours pas dit quelles pourraient être les règles pour gérer tout çà... difficile de savoir comment le coder.

note: on n'est pas la pour coder à votre place, juste pour vous aider à comprendre comment utiliser le langage ce qui suppose que vous savez déjà exprimer ce que vous voulez et que vous avez essayé de coder quelque chose.

- W

2 pièce(s) jointe(s)

Voici une des versions pour le jeux mais jouable en console:

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
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
 
 
 
import sys
import os
import pickle
import random
 
mode = True
deplacement = True
encadrement = True
 
from outils import *
 
""" Le jeu commencé et le joueur choisi sa carte. """
 
chaine = str()
 
 
def choix_carte():
    global b
    print ("Mode de jeux : 1- facile ou 2- prison ")
    b = input ("Bonjour! Veuillez choisir une carte en tappant le numéro correspondant : ")
    b = int(b)
    while mode:
        if b==1 or b==2:
            print ("Vous avez choisi le mode de jeux : ", b)
            break
        else:
            print ("Veuillez réessayer!")
            b = input()
            b = int(b)
 
choix_carte()
 
 
 
""" Je commence par déterminer si il existe une sauvegarde ou non et je donne
    le choix au joueur de la terminée ou de commencer une nouvelle partie. """
 
if b==1:
    def ouverture_carte_1():
        global fihier, fs, txt_1, b, S, data, Fic, r, fic
        print ("facile")
        fs = open ("facile_0.txt", "r")
        fichier = open ("facile_1.txt", "r")
        txt_1 = fs.read()
        data = fichier.read()
        fs.close()
        fichier.close()
        if txt_1 != data:
            S = input("Voulez vous continuez la dernière partie enregistrée ? Tapez 'o' si oui et une autre lettre si non : ")
            S = str(S)
            fichier = open ("facile_1.txt", "r")
            data = fichier.read()
            fichier.close()
            if S.lower() != "o":
                fs = open ("facile_0.txt", "r")
                fichier = open ("facile_1.txt", "w")
                txt = fs.read()
                fichier.write(txt)
                fs.close()
                fichier.close()
                data = txt
                print(data)
            else:
                print (data)
        else:
            fichier = open ("facile_1.txt", "r")
            data = fichier.read()
            index_X = data.index("X")
            f = range(len(data))
            #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
            #print (indices_espace)
            indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
            r = random.choice(indices_espace)
            print (r)
 
            data = data[:index_X] + " " + data[index_X+1:]
            data = data[:r] + "X" + data[r+1:]
            print (data)
            fichier.close()
 
            with open("facile_1.txt", "w") as fic:
                fic.write(data)
            with open("facile_1.txt", "r") as fic:
                Fic = fic.read()
 
    ouverture_carte_1()
 
 
 
    while chaine.lower() != "q":
 
 
 
        """ Je définit ensuite les différentes actions ou mouvements que le joueur
            pourra effectuée. """
 
        def deplacer():
            global l, ld
            l = input ("Déplacez votre robot avec 'n' pour le haut, 'e' pour la droite, 's' pour le bas et 'o' pour la gauche : ")
            l = str(l)
            while deplacement:
                if l.lower()=="n":
                    print ("Dépalcement vers le haut")
                    ld = -11
                    break
                elif l.lower()=="e":
                    print ("Déplacement vers la droite")
                    ld = 1
                    break
                elif l.lower()=="s":
                    print ("Déplacement vers le bas")
                    ld = 11
                    break
                elif l.lower()=="o":
                    print ("Déplacement vers la gauche")
                    ld = -1
                    break
                else:
                    print ("Veuillez entrer une des lettres proposées : ")
                    l = input ()
 
        deplacer()
 
 
 
        """ Ici je propose au joueur de se déplacer 'n' fois selon bien-sûr la
            longeur de notre chaîne (fichier). """
 
        fichier = open ("facile_1.txt", "r")
        data = fichier.read()
        lenn = len(data)
        print (lenn)
        f = range(lenn)
 
        index_X = data.index("X")
        print (index_X)
        index_U = data.index("U")
 
 
        def nbre_deplacement():
            global D, new_index_X, D_ld, f
            D = input ("De combien de fois voulez vous vous déplacez ?")
            D = int(D)
            while encadrement:
                D = int(D)
                D_ld = D*ld
                new_index_X = index_X + D_ld
                if new_index_X in f:
                    break
                else:
                    print ("Vous êtes hors du cadre, veuillez reprendre")
                    D = input()
 
        nbre_deplacement()
 
 
 
        """ Les lignes de codes plus bas sont justes là pour montrer comment j'ai
            fait pour obtenir les indices du point et ceux de 'O'. """
 
 
        #indices_pt = list(set(data[j:].index(".") + j for j in f if "." in data[j:]))
        #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
        #print (indices_espace)
        #print (indices_pt)
        #indices_O = list(set(data[j:].index("O") + j for j in f if "O" in data[j:]))
        #print (indices_O)
        #indices_grille = list(set(data[j:].index("A") + j for j in f if "A" in data[j:]))
        #print (indices_grille)
 
        indices_espace = [12, 14, 15, 16, 17, 19, 23, 25, 28, 29, 30, 34, 36, 38, 39, 40, 45, 50, 56, 58, 60, 61, 62, 63, 67, 78, 80, 81, 82, 83, 84, 85, 89, 91, 100, 102, 104, 105, 106, 107]
        indices_grille = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 20, 22, 31, 33, 42, 44, 53, 55, 66, 75, 77, 86, 88, 97, 99, 108, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119]
        indices_pt = [24, 74, 52, 101]
        indices_O = [13, 18, 26, 27, 35, 37, 46, 47, 48, 49, 51, 57, 59, 68, 69, 70, 71, 72, 73, 79, 90, 92, 93, 94, 95, 96, 103]
 
 
 
        """ Je pose les conditions pour le déplacement du robot. """
 
        def placement():
            global index_X, ld, D, data, dd
            i = 0
            while i <= D:
                dd = index_X+(ld*i)
                if data[index_X+(ld*i)] == "O":
                    print ("Mouvement impossible, vous êtes entrer dans un mur")
                    if index_X+(ld*i) in indices_grille:
                        print ("Désolé mais vous êtes dans la grille et vous ne pouez la percée, veuillez recommencer")
                        break
                    else:
                        percer = input("Vous êtes dans un mur, voulez-vous le percer ? Taper 'p' si oui et 'n' si non et choisir une autre destination : ")
                        percer = str(percer)
                        while i <= D:
                            if percer.lower()=="p":
                                if index_X+(ld*(i-1)) in indices_pt:
                                    data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                elif index_X+(ld*(i-1)) in indices_O:
                                    data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                else:
                                    data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                print ("Le mur à été percé.")
                                print (data)
                                break
 
                            elif percer.lower()=="n":
                                print ("Vous avez choisi de chercher un autre chemin")
                                break
                            else:
                                print ("Veuillez entrer une des lettres proposées : ")
                                percer = input ()
                        break
 
 
                elif data[index_X+(ld*i)] == "\n":
                    print ("Mouvement impossible, vous êtes dans le vide")
                    break
                elif data[index_X+(ld*i)] == "U":
                    print ("Bravo, vous terminer le jeux")
                    break
 
 
                elif data[index_X+(ld*i)] == ".":
                    murer = input("Vous êtes dans une porte, voulez-vous la murer ? Taper 'm' si oui et 'n' si non et choisir une autre destination : ")
                    murer = str(murer)
                    while i <= D:
                        if murer.lower()=="m":
                            if index_X+(ld*(i-1)) in indices_O:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            elif index_X+(ld*(i-1)) in indices_espace:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            elif index_X+(ld*(i-1)) in indices_pt:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            else:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            print ("La porte à été scellé.")
                            print (data)
                            break
 
                        elif murer.lower()=="n":
                            print ("Vous avez choisi de chercher continuer votre chemin normalement.")
                            if index_X+(ld*(i-1)) in indices_pt:
                                data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            elif index_X+(ld*(i-1)) in indices_O:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            elif index_X+(ld*(i-1)) == index_U:
                                data = data[:index_X+(ld*(i-1))] + "U" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            else:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                print (data)
                            break
 
                        else:
                            print ("Veuillez entrer une des lettres proposées : ")
                            murer = input ()
 
 
                elif data[index_X+(ld*i)] == " ":
                    if index_X+(ld*(i-1)) in indices_pt:
                        data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    elif index_X+(ld*(i-1)) in indices_O:
                        data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    elif index_X+(ld*(i-1)) == index_U:
                        data = data[:index_X+(ld*(i-1))] + "U" + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    else:
                        data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
 
                    print ("Mouvement effectuer")
                    print (data)
 
 
                else:
                    print ("Mouvement inconnu")
 
                i += 1
 
        placement()
 
        fichier.close()
 
 
 
        """ Je pose la condition pour que le joueur sorte du jeux si il gagne,
            c'est-à-dire si il atteint 'U'. """
 
        if data[dd] == "U":
            fs = open ("facile_0.txt", "r")
            fichier = open ("facile_1.txt", "w")
            txt = fs.read()
            fichier.write(txt)
            fs.close()
            fichier.close()
            break
 
 
        """ Je fait une sauvegarde de mon jeux après chaque mouvement du robot. """
        with open("facile_1.txt", "w") as fic:
            fic.write(data)
        with open("facile_1.txt", "r") as fic:
            Fic = fic.read()
 
 
        print ("Vous pouvez taper 'q' à tout moment pour sortir et enregistrer ou une autre lettre pour continuer : ")
        chaine  = input()
 
    print ("Merci d'avoir jouer")
 
    os.system("pause")
 
 
 
 
 
 
 
    """ Je déterminer si il existe une sauvegarde ou non et je donne dans ce mode
        le choix au joueur de la terminée ou de commencer une nouvelle partie. """
 
else:
    def ouverture_carte_2():
        global fihier, fs, txt_1, b, S, data, Fic, r, fic
        print ("prison")
        fs = open ("prison_0.txt", "r")
        fichier = open ("prison_1.txt", "r")
        txt_1 = fs.read()
        data = fichier.read()
        fs.close()
        fichier.close()
        if txt_1 != data:
            S = input("Voulez vous continuez la dernière partie enregistrée ? Tapez 'o' si oui et une autre lettre si non : ")
            S = str(S)
            fichier = open ("prison_1.txt", "r")
            data = fichier.read()
            fichier.close()
            if S.lower() != "o":
                fs = open ("prison_0.txt", "r")
                fichier = open ("prison_1.txt", "w")
                txt = fs.read()
                fichier.write(txt)
                fs.close()
                fichier.close()
                data = txt
                print(data)
            else:
                print (data)
        else:
            fichier = open ("prison_1.txt", "r")
            data = fichier.read()
            index_X = data.index("X")
            f = range(len(data))
            #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
            #print (indices_espace)
            indices_espace = [24, 26, 28, 29, 30, 31, 33, 35, 36, 37, 38, 39, 45, 47, 49, 50, 51, 52, 54, 56, 57, 58, 59, 60, 64, 66, 68, 70, 71, 72, 73, 75, 77, 78, 79, 80, 81, 87, 89, 91, 92, 93, 94, 96, 98, 99, 100, 101, 102, 106, 108, 110, 117, 119, 120, 121, 122, 123, 127, 129, 131, 132, 133, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 148, 150, 161, 162, 163, 164, 165, 171, 173, 174, 175, 176, 177, 178, 179, 180, 182, 183, 184, 185, 186, 190, 192, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206, 207, 211, 213, 215, 216, 217, 218, 219, 220, 221, 222, 224, 225, 226, 227, 228, 232, 236, 237, 238, 239, 240, 241, 242, 243, 245, 246, 247, 248, 249, 255, 257, 258, 259, 260, 261, 262, 263, 264, 266, 267, 268, 269, 270, 274, 276, 278, 279, 280, 281, 282, 283, 284, 285, 287, 288, 289, 290, 291, 295, 297, 299, 300, 301, 302, 303, 304, 305, 306, 308, 309, 310, 311, 312, 316, 318, 320, 321, 322, 323, 324, 325, 326, 327, 329, 330, 331, 332, 333, 337, 339, 341, 342, 343, 344, 345, 346, 347, 348, 350, 351, 352, 353, 354, 360, 362, 363, 364, 365, 366, 367, 368, 369, 371, 372, 373, 374, 375, 379, 380, 381, 383, 384, 385, 386, 387, 388, 389, 390, 392, 393, 394, 395, 396]
            r = random.choice(indices_espace)
            print (r)
 
            data = data[:index_X] + " " + data[index_X+1:]
            data = data[:r] + "X" + data[r+1:]
            print (data)
            fichier.close()
 
            with open("prison_1.txt", "w") as fic:
                fic.write(data)
            with open("prison_1.txt", "r") as fic:
                Fic = fic.read()
 
    ouverture_carte_2()
 
 
 
    while chaine.lower() != "q":
 
 
        """ Je définit ensuite les différentes actions ou mouvements que le joueur
            pourra effectuée. """
 
        def deplacer():
            global l, ld
            l = input ("Déplacez votre robot avec 'n' pour le haut, 'e' pour la droite, 's' pour le bas et 'o' pour la gauche : ")
            l = str(l)
            while deplacement:
                if l.lower()=="n":
                    print ("Dépalcement vers le haut")
                    ld = -21
                    break
                elif l.lower()=="e":
                    print ("Déplacement vers la droite")
                    ld = 1
                    break
                elif l.lower()=="s":
                    print ("Déplacement vers le bas")
                    ld = 21
                    break
                elif l.lower()=="o":
                    print ("Déplacement vers la gauche")
                    ld = -1
                    break
                else:
                    print ("Veuillez entrer une des lettres proposées : ")
                    l = input ()
 
        deplacer()
 
 
        """ Ici je propose au joueur de se déplacer 'n' fois selon bien-sûr la
            longeur de notre chaîne (fichier). """
 
        fichier = open ("prison_1.txt", "r")
        data = fichier.read()
        lenn = len(data)
        print (lenn)
        f = range(lenn)
 
        index_X = data.index("X")
        index_U = data.index("U")
 
 
        def nbre_deplacement():
            global D, nex_index_X, D_ld, f
            D = input ("De combien de fois voulez vous vous déplacez ?")
            D = int(D)
            while encadrement:
                D = int(D)
                D_ld = D*ld
                new_index_X = index_X + D_ld
                if new_index_X in f:
                    break
                else:
                    print ("Vous êtes hors du cadre, veuillez reprendre")
                    D = input()
 
        nbre_deplacement()
 
 
 
        """ Les lignes de codes plus bas sont justes là pour montrer comment j'ai
            fait pour obtenir les indices du point et ceux de 'O'. """
 
 
        #indices_pt = list(set(data[j:].index(".") + j for j in f if "." in data[j:]))
        #indices_espace = list(set(data[k:].index(" ") + k for k in f if " " in data[k:]))
        #print (indices_espace)
        #print (indices_pt)
        #indices_O = list(set(data[j:].index("O") + j for j in f if "O" in data[j:]))
        #print (indices_O)
        #indices_grille = list(set(data[j:].index("A") + j for j in f if "A" in data[j:]))
        #print (indices_grille)
 
        indices_espace = [24, 26, 28, 29, 30, 31, 33, 35, 36, 37, 38, 39, 45, 47, 49, 50, 51, 52, 54, 56, 57, 58, 59, 60, 64, 66, 68, 70, 71, 72, 73, 75, 77, 78, 79, 80, 81, 87, 89, 91, 92, 93, 94, 96, 98, 99, 100, 101, 102, 106, 108, 110, 117, 119, 120, 121, 122, 123, 127, 129, 131, 132, 133, 134, 135, 136, 137, 138, 140, 141, 142, 143, 144, 148, 150, 161, 162, 163, 164, 165, 171, 173, 174, 175, 176, 177, 178, 179, 180, 182, 183, 184, 185, 186, 190, 192, 194, 195, 196, 197, 198, 199, 200, 201, 203, 204, 205, 206, 207, 211, 213, 215, 216, 217, 218, 219, 220, 221, 222, 224, 225, 226, 227, 228, 232, 236, 237, 238, 239, 240, 241, 242, 243, 245, 246, 247, 248, 249, 255, 257, 258, 259, 260, 261, 262, 263, 264, 266, 267, 268, 269, 270, 274, 276, 278, 279, 280, 281, 282, 283, 284, 285, 287, 288, 289, 290, 291, 295, 297, 299, 300, 301, 302, 303, 304, 305, 306, 308, 309, 310, 311, 312, 316, 318, 320, 321, 322, 323, 324, 325, 326, 327, 329, 330, 331, 332, 333, 337, 339, 341, 342, 343, 344, 345, 346, 347, 348, 350, 351, 352, 353, 354, 360, 362, 363, 364, 365, 366, 367, 368, 369, 371, 372, 373, 374, 375, 379, 380, 381, 383, 384, 385, 386, 387, 388, 389, 390, 392, 393, 394, 395, 396]
        indices_grille = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 145, 21, 147, 271, 273, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 292, 412, 166, 294, 40, 168, 42, 414, 415, 416, 417, 418, 313, 187, 315, 61, 189, 63, 334, 208, 336, 82, 210, 84, 399, 355, 229, 357, 103, 231, 105, 411, 413, 376, 250, 378, 124, 252, 126]
        indices_pt = [256, 34, 358, 169, 234, 43, 172, 85, 25, 90, 253]
        indices_O = [23, 27, 32, 44, 46, 48, 53, 55, 65, 67, 69, 74, 76, 86, 88, 95, 97, 107, 109, 111, 112, 113, 114, 115, 116, 118, 128, 130, 139, 145, 149, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 170, 181, 191, 193, 202, 212, 214, 223, 233, 235, 244, 254, 265, 275, 277, 286, 296, 298, 307, 317, 319, 328, 338, 340, 349, 359, 361, 370, 382, 391]
 
 
 
        """ Je pose les conditions pour le déplacement du robot. """
 
        def placement():
            global index_X, ld, D, data, dd
            i = 0
            while i <= D:
                dd = index_X+(ld*i)
                if data[index_X+(ld*i)] == "O":
                    print ("Mouvement impossible, vous êtes entrer dans un mur")
                    if index_X+(ld*i) in indices_grille:
                        print ("Désolé mais vous êtes dans la grille et vous ne pouez la percée, veuillez recommencer")
                        break
                    else:
                        percer = input("Vous êtes dans un mur, voulez-vous le percer ? Taper 'p' si oui et 'n' si non et choisir une autre destination : ")
                        percer = str(percer)
                        while i <= D:
                            if percer.lower()=="p":
                                if index_X+(ld*(i-1)) in indices_pt:
                                    data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                elif index_X+(ld*(i-1)) in indices_O:
                                    data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                else:
                                    data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                    data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
 
                                print ("Le mur à été percé.")
                                print (data)
                                break
                            elif percer.lower()=="n":
                                print ("Vous avez choisi de chercher un autre chemin")
                                break
                            else:
                                print ("Veuillez entrer une des lettres proposées : ")
                                percer = input ()
                        break
 
 
                elif data[index_X+(ld*i)] == "\n":
                    print ("Mouvement impossible, vous êtes dans le vide")
                    break
                elif data[index_X+(ld*i)] == "U":
                    print ("Bravo, vous terminer le jeux")
                    break
 
 
                elif data[index_X+(ld*i)] == ".":
                    murer = input("Vous êtes dans une porte, voulez-vous la murer ? Taper 'm' si oui et 'n' si non et choisir une autre destination : ")
                    murer = str(murer)
                    while i <= D:
                        if murer.lower()=="m":
                            if index_X+(ld*(i-1)) in indices_O:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            elif index_X+(ld*(i-1)) in indices_espace:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            elif index_X+(ld*(i-1)) in indices_pt:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
                            else:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "O" + data[index_X+(ld*i)+1:]
                                data = data[:index_X+(ld*i)+ld] + "X" + data[index_X+(ld*i)+ld+1:]
 
                            print ("La porte à été scellé.")
                            print (data)
                            break
 
                        elif murer.lower()=="n":
                            print ("Vous avez choisi de chercher continuer votre chemin normalement.")
                            if index_X+(ld*(i-1)) in indices_pt:
                                data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            elif index_X+(ld*(i-1)) in indices_O:
                                data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            elif index_X+(ld*(i-1)) == index_U:
                                data = data[:index_X+(ld*(i-1))] + "U" + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                            else:
                                data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                                data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                                print (data)
                            break
 
                        else:
                            print ("Veuillez entrer une des lettres proposées : ")
                            murer = input ()
 
 
                elif data[index_X+(ld*i)] == " ":
                    if index_X+(ld*(i-1)) in indices_pt:
                        data = data[:index_X+(ld*(i-1))] + "." + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    elif index_X+(ld*(i-1)) in indices_O:
                        data = data[:index_X+(ld*(i-1))] + "O" + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    elif index_X+(ld*(i-1)) == index_U:
                        data = data[:index_X+(ld*(i-1))] + "U" + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
                    else:
                        data = data[:index_X+(ld*(i-1))] + " " + data[index_X+(ld*(i-1))+1:]
                        data = data[:index_X+(ld*i)] + "X" + data[index_X+(ld*i)+1:]
 
                    print ("Mouvement effectuer")
                    print (data)
 
 
                else:
                    print ("Mouvement inconnu")
 
                i += 1
 
        placement()
 
        fichier.close()
 
 
 
        """ Je pose la condition pour que le joueur sorte du jeux si il gagne,
            c'est-à-dire si il atteint 'U'. """
 
        if data[dd] == "U":
            fs = open ("prison_0.txt", "r")
            fichier = open ("prison_1.txt", "w")
            txt = fs.read()
            fichier.write(txt)
            fs.close()
            fichier.close()
            break
 
 
 
        """ Je fait une sauvegarde de mon jeux après chaque mouvement du robot. """
        with open("prison_1.txt", "w") as fic:
            fic.write(data)
        with open("prison_1.txt", "r") as fic:
            Fic = fic.read()
 
 
        print ("Vous pouvez taper 'q' à tout moment pour sortir et enregistrer ou une autre lettre pour continuer : ")
        chaine  = input()
 
    print ("Merci d'avoir jouer")
 
    os.system("pause")

Mais cette fois-ci avec les fichiers:

29/01/2019, 09h42
Tchams

2 pièce(s) jointe(s)

J'ajoute des pièces jointes ici parce qu'en haut ça refusait de les ajoutées.
29/01/2019, 11h59
wiztricks

Citation:

Envoyé par Tchams

Voici une des versions pour le jeux mais jouable en console:

Vous vous simplifieriez grandement la vie (et le nombre de lignes de code) en transformant votre chaîne de caractères (data) en un tableau (une liste de listes).
Déjà parce que si le robot est en (i, j), vous pourriez accéder directement aux cases voisines.... Et vous n'avez à placer le robot avec un X en (i, j) que pour afficher la carte (et la sauvegarder).

Donc vous avez une grille (la carte), la position (i, j) du robot (qui s'affiche sous la forme d'un "X" lorsqu'on en a besoin), des fonctions genre deplacer_robot(direction, nombre), ... qui retournent un status et un message d'erreur (eventuel).

Et une interface utilisateur qui saisit la commande (une chaine de caractères), essaie de la traduire en appels de fonctions.

Si vous ne savez pas encore structurer votre code comme çà, ben passer en client /serveur, c'est mission impossible (et on ne va pas coder çà pour vous).

- W
29/01/2019, 21h30
Tchams

Ok, merci! Je vais essayer de suivre tes conseils au mieux.:)