Discussion :

[bromy]

Bonjour,

Dans le cadre d'un projet scolaire, on essaye de programmer un Jeu dans le style d'un Pacman, sauf que les trois fantômes seraient contrôlés chacun par un joueur différent.

Donc pour l'instant, on a fait 2 Fantômes, et un "pacman"

Comment on s'y est pris :

1 Serveur qui gère les déplacements de 3 clients (2 pour les fantômes et 1 pour le "pacman")

Serveur :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### SERVEUR TCP - Multi-clients #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
HOTE = 'localhost'   # quelconque
PORT = 12345
TAILLE_MAX_PAQUET = 1024
recu = '' 
sSrv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sSrv.bind((HOTE, PORT))
sSrv.listen(4)  # Nbre maxi acceptés "en parallèle"
print("Le serveur écoute à présent sur le port", PORT)
 
 
#########  LISTE  ########
clients_connectes = []      #liste des clients connectés
liste_des_mecs = []         #liste des clients connectés + leur ip et leur port
piongentil=[]               #liste coordonnées du pion gentil (x et y)
pionmechant1=[]             #liste coordonnées du pion mechant1
pionmechant2=[]             #liste coordonnées du pion mechant2
coopion=[]                  #liste coordonnées des tous les pions
 
###########  VARIABLE  #############
i=0                     # prend la valeur du nombre de client connectés
lip=""                  # l'ip de l'envoyeur
lport=""                # le port de l'envoyeur
serveur_ecoute = True
dx = 0
dy = 0
 
x=245             #variable gestion coordonnées des pions
y=12
x1=232
y1=217
x2=257
y2=217
 
 
############  CREATION FENETRE PRINCIPALE  ##################
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Serveur")
 
 
 
###########  FONCTIONS  ################
 
 
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom)
 
def quibouge(gentiloumechant):               #fonction pour faire bouger 1 des pions
    fenetre_plateau.move(gentiloumechant, dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
 
 
#########  CODE PRINCIPALE  ###############
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
 
 
while serveur_ecoute:    # Boucle d'écoute du serveur
    # (1) On vérifie si des nouveaux clients demandent à se connecter
    #  => on écoute le serveur, maxi pendant 0.05 sec.
    connexions_demandees, wlist, xlist = select.select([sSrv],
                                                       [], [], 0.05)
    # en_ecoute, en_ecriture, en_except., pour select.select
    for connexion in connexions_demandees:
        sCli, infos_connexion = connexion.accept()
        # On ajoute le socket connecté à la liste des clients connectés
        clients_connectes.append(sCli)
 
 
    nb_clients_connectes=len(clients_connectes)
    while i<nb_clients_connectes:  #associe le client à son ip+port+donne un nom de joueur
                client = [clients_connectes[i],sCli.getpeername()[0],sCli.getpeername()[1],"joueur"+str(i)]
                liste_des_mecs.append(client)
                i=i+1
 
    # (2) Maintenant, on écoute la liste des clients *connectés*
    liste_sCli_a_lire = []
    try:        # sinon, exception levée si la liste des clients est vide
        liste_sCli_a_lire, wlist, xlist = select.select(clients_connectes,
                                                        [], [], 0.05)
    except select.error:
        pass    # Ne rien faire s'il n'y en a pas
    else:
        # On parcourt la liste des clients à lire
        for sCli in liste_sCli_a_lire:
            msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
            recu = str(msg_recu, encoding="utf-8")  #  à encoder...
            lip=sCli.getpeername()[0]               # met l'ip de l'envoyeur dans cette variable
            lport=sCli.getpeername()[1]             # met le port de l'envoyeur dans cette variable
 
 
 
 
    if recu == 'UP':                #si "UP" alors on va en haut 
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 0
        dy = -3
 
    if recu == 'DOWN':              #si "DOWN" alors on va en bas
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 0
        dy = 3
 
    if recu == 'LEFT':              #si "LEFT" alors on va à gauche
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = -3
        dy = 0
 
    if recu == 'RIGHT':             #si "RIGHT" alors on va à droite
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 3
        dy = 0
 
 
 
    fenetre_plateau.update()    #on actualise la fenêtre 
    fenetre_plateau.after(1) 
 
 
    if recu:
        if lip==liste_des_mecs[0][1] and lport==liste_des_mecs[0][2]:           #regarde si l'ip de l'envoyeur et celle du premier client (joueur0)
            quibouge("gentil")                                                      #fait bouger le pion violet (gentil)
            x=x+dx                                                              #permet de savoir les coordonnées x du pion gentil
            y=y+dy                                                              #permet de savoir les coordonnées y du pion gentil
            piongentil=[x,y]                
 
        if i>=2:                                                                #regarde si il y a un deuxieme client
 
            if lip==liste_des_mecs[1][1] and lport==liste_des_mecs[1][2]:       #regarde si l'ip de l'envoyeur et celle du deuxieme client (joueur1)
                quibouge("mechant1")                                                #fait bouger le pion rouge (mechant1)
                x1=x1+dx
                y1=y1+dy
                pionmechant1=[x1,y1]
        if i==3:                                                                #regarde si il y a un troisieme client
 
            if lip==liste_des_mecs[2][1] and lport==liste_des_mecs[2][2]:       #regarde si l'ip de l'envoyeur et celle du troisieme client (joueur2)
                    quibouge("mechant2")                                            #fait bouger le pion orange (mechant2)
                    x2=x2+dx
                    y2=y2+dy
                    pionmechant2=[x2,y2]
 
 
    coopion=[piongentil,pionmechant1,pionmechant2]                      
 
 
    recu=''                         
 
    dx = 0
    dy = 0
 
 
 
 
print("Fermeture des connexions au serveur")
for sCli in clients_connectes:
    sCli.close()
sSrv.close()

3 Clients :

1 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT)) 
print("Connexion établie avec le serveur sur le port", PORT)
#############################################
 
from tkinter import *
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 1")
 
 
carrebleu = [[11,94], [53,94], [11,207], [53,207]]
carrebleu2 = [[438,92], [478,92], [438,206], [478,206]]
x = 240
y = 145
r = 8
dx = 0
dy = 0
couleur="red"
msg_a_envoyer = None
recu = ''
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
def up2 (event=None):
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
root2.bind('<1>', move)
root2.bind('<Up>', up)
root2.bind('<Down>', down)
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
 
###################################################
 
while 1:
 
    # Saisie du message
 
 
    # Envoi du message
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):
        envoi = bytes(msg_a_envoyer, encoding="utf-8")
        sCli.send(envoi)
        msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
        recu = str(msg_recu, encoding="utf-8")  #  à encoder...
        #print(recu)
        msg_a_envoyer = ''
        if recu == "UP":
            up2()
        if recu == "DOWN":
            down2()
        if recu == "LEFT":
            left2()
        if recu == "RIGHT":
            right2()
    fenetre_plateau.move("gentil", dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

2 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT)) 
print("Connexion établie avec le serveur sur le port", PORT)
#############################################
 
from tkinter import *
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 2")
 
 
 
carrebleu = [[11,94], [53,94], [11,207], [53,207]]
carrebleu2 = [[438,92], [478,92], [438,206], [478,206]]
x = 240
y = 145
r = 8
dx = 0
dy = 0
couleur="red"
msg_a_envoyer = None
recu = ''
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
def up2 (event=None):
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
root2.bind('<1>', move)
root2.bind('<Up>', up)
root2.bind('<Down>', down)
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
 
###################################################
 
while 1:
 
    # Saisie du message
 
 
    # Envoi du message
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):
        envoi = bytes(msg_a_envoyer, encoding="utf-8")
        sCli.send(envoi)
        msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
        recu = str(msg_recu, encoding="utf-8")  #  à encoder...
        #print(recu)
        msg_a_envoyer = ''
        if recu == "UP":
            up2()
        if recu == "DOWN":
            down2()
        if recu == "LEFT":
            left2()
        if recu == "RIGHT":
            right2()
    fenetre_plateau.move("mechant1", dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

3 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT)) 
print("Connexion établie avec le serveur sur le port", PORT)
#############################################
 
from tkinter import *
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 3")
 
 
 
carrebleu = [[11,94], [53,94], [11,207], [53,207]]
carrebleu2 = [[438,92], [478,92], [438,206], [478,206]]
x = 240
y = 145
r = 8
dx = 0
dy = 0
couleur="red"
msg_a_envoyer = None
recu = ''
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
def up2 (event=None):
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
root2.bind('<1>', move)
root2.bind('<Up>', up)
root2.bind('<Down>', down)
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
 
###################################################
 
while 1:
 
    # Saisie du message
 
 
    # Envoi du message
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):
        envoi = bytes(msg_a_envoyer, encoding="utf-8")
        sCli.send(envoi)
        msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
        recu = str(msg_recu, encoding="utf-8")  #  à encoder...
        #print(recu)
        msg_a_envoyer = ''
        if recu == "UP":
            up2()
        if recu == "DOWN":
            down2()
        if recu == "LEFT":
            left2()
        if recu == "RIGHT":
            right2()
    fenetre_plateau.move("mechant2", dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

Donc quand on bouge tel ou tel pion (A l'aide des flèches), les informations arrivent bien au serveur, le pion X bouge bien sur le serveur et sur le Client dont vient l'informaton, mais on n'arrive pas a faire en sorte que les pions bougent sur les autres Clients.
On essaye de mettre en place la gestion des coordonnées de chaque pion pour ensuite gérer le déplacement sur TOUT les clients grâce a l'envoi des coordonnées de chaque pions a tout les serveurs pour actualiser leurs position, et par la suite gérer la collision sur les obstacles de la map.
On a un peu du mal, vous auriez des idées ?
On tiens par contre a rester avec les modules utilisés.


Si vous voulez la Map :
http://www.casimages.com/img.php?i=1...3950672744.gif

[wiztricks]

Salut,

Vous en étiez déjà là lors du post.
Quels sont les progrès depuis?

- W

[bromy]

On a règlé le problème de latence, on a ajouté une demande de confirmation du client au serveur avant le déplacement pour qu'ils restent synchronisés (ce qui n'était pas le cas avant) et on a séparer le client en 3 pour la gestion de déplacement de 3 "pions"
Nous pensons donc avoir une partie réseau qui 'fonctionne' comparé à la dernière fois.
La on essaye de terminer de résoudre notre problème de coordonnée pour pouvoir attaquer le déplacement de chaque pion sur tout les clients et pas uniquement sur celui d'où provient le pion qui se déplace et pouvoir ensuite finir sur la gestion de collision sur les murs pour donner l'aspect 'labyrinthe'

[wiztricks]

Salut
Votre code réseau est buggé mais c'est pas grave.
Si vous voulez que les déplacements du client 1 soient propagés par le serveur sur les clients 2, 3, ... Il faudrait ajouter une mécanique de "broadcast", le serveur expédie la mise à jour du client 1 sur 2 et 3.
Comment réaliser cà?
Plusieurs méthodes: ajouter une socket UDP ou TCP (le serveur parle aux clients), utiliser un AMQP genre rabbit, trouver une bibliothèque de publish/subscribe autre, ajouter ce dialogue (serveur=>clients) à la socket existante,...
Si on essaie de voir comment intégrer cela dans le code existant:
- le client doit pouvoir expédier et recevoir: la connexion IP devrait être gérée par select.select - comme côté serveur -.
- à chaque déplacement reçu, le serveur doit poster la mise à jour côté N-client, çà fait N-messages à transmettre (UDP serait mieux car 1->1). Les piles réseaux qui débordent à traiter plus tard.
- W

[Xelhh]

Salut,

Je suis dans le même groupe que bromy.
Savez vous comment reparer cette erreur :
failed to set __main__.__loader__

Pour pouvoir lancer le programme en faisant un double clique (depuis mon dossier contenant le programme).

Merci.

[Xelhh]

- le client doit pouvoir expédier et recevoir: la connexion IP devrait être gérée par select.select - comme côté serveur -.
- à chaque déplacement reçu, le serveur doit poster la mise à jour côté N-client, çà fait N-messages à transmettre (UDP serait mieux car 1->1).
- W

Merci pour ton aide, je viens d'essayer et ça marche ! Les clients sont bien mis à jour.

As-tu une idée pour l'erreur de lancement avec un double clique ?

[wiztricks]

As-tu une idée pour l'erreur de lancement avec un double clique ?

Google est ton ami.
Et heureusement car, avec les seules indications données il est galère d'avoir les conditions qui conduisent à...
- W

[bromy]

Bonjour !

On a réussit a gérer l'affichage des pions après leur déplacement sur tout les clients :

Serveur :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### SERVEUR TCP - Multi-clients #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
HOTE = 'localhost'   # quelconque
PORT = 12345
TAILLE_MAX_PAQUET = 1024
recu = '' 
sSrv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sSrv.bind((HOTE, PORT))
sSrv.listen(4)  # Nbre maxi acceptés "en parallèle"
print("Le serveur écoute à présent sur le port", PORT)
 
 
#########  LISTE  ########
clients_connectes = []      #liste des clients connectés
liste_des_mecs = []         #liste des clients connectés + leur ip et leur port
 
###########  VARIABLE  #############
i=0                     # prend la valeur du nombre de client connectés
lip=""                  # l'ip de l'envoyeur
lport=""                # le port de l'envoyeur
serveur_ecoute = True
dx = 0
dy = 0
 
 
 
############  CREATION FENETRE PRINCIPALE  ##################
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Serveur")
 
 
 
###########  FONCTIONS  ################
 
 
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom)
 
def quibouge(gentiloumechant):               #fonction pour faire bouger 1 des pions
    fenetre_plateau.move(gentiloumechant, dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
 
 
#########  CODE PRINCIPALE  ###############
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
 
 
while serveur_ecoute:    # Boucle d'écoute du serveur
    # (1) On vérifie si des nouveaux clients demandent à se connecter
    #  => on écoute le serveur, maxi pendant 0.05 sec.
    connexions_demandees, wlist, xlist = select.select([sSrv],
                                                       [], [], 0.05)
    # en_ecoute, en_ecriture, en_except., pour select.select
    for connexion in connexions_demandees:
        sCli, infos_connexion = connexion.accept()
        # On ajoute le socket connecté à la liste des clients connectés
        clients_connectes.append(sCli)
 
 
    nb_clients_connectes=len(clients_connectes)
    while i<nb_clients_connectes:  #associe le client à son ip+port+donne un nom de joueur
                client = [clients_connectes[i],sCli.getpeername()[0],sCli.getpeername()[1],"joueur"+str(i)]
                liste_des_mecs.append(client)
                i=i+1
 
    # (2) Maintenant, on écoute la liste des clients *connectés*
    liste_sCli_a_lire = []
    try:        # sinon, exception levée si la liste des clients est vide
        liste_sCli_a_lire, wlist, xlist = select.select(clients_connectes,
                                                        [], [], 0.05)
    except select.error:
        pass    # Ne rien faire s'il n'y en a pas
    else:
        # On parcourt la liste des clients à lire
        for sCli in liste_sCli_a_lire:
            msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
            recu = str(msg_recu, encoding="utf-8")  #  à encoder...
            lip=sCli.getpeername()[0]               # met l'ip de l'envoyeur dans cette variable
            lport=sCli.getpeername()[1]             # met le port de l'envoyeur dans cette variable
 
 
 
 
 
 
 
 
    fenetre_plateau.update()    #on actualise la fenêtre 
    fenetre_plateau.after(1) 
 
 
    ##############
 
 
    if recu:
        if lip==liste_des_mecs[0][1] and lport==liste_des_mecs[0][2]:           #regarde si l'ip de l'envoyeur et celle du premier client (joueur0)
            if recu == 'UP':                #si "UP" alors on va en haut 
                for envoimouv in clients_connectes:
                    envoimouv.send(bytes("mouvgentilUP", encoding="utf-8"))
                dx = 0
                dy = -3
 
            if recu == 'DOWN':              #si "DOWN" alors on va en bas
                for envoimouv in clients_connectes:
                    envoimouv.send(bytes("mouvgentilDOWN", encoding="utf-8"))
                dx = 0
                dy = 3
 
            if recu == 'LEFT':              #si "LEFT" alors on va à gauche
                for envoimouv in clients_connectes:
                    envoimouv.send(bytes("mouvgentilLEFT", encoding="utf-8"))
                dx = -3
                dy = 0
 
            if recu == 'RIGHT':             #si "RIGHT" alors on va à droite
                for envoimouv in clients_connectes:
                    envoimouv.send(bytes("mouvgentilRIGHT", encoding="utf-8"))
                dx = 3
                dy = 0
            quibouge("gentil")                                                      #fait bouger le pion violet (gentil)
 
 
        ##############    
 
 
        if i>=2:                                                                    #regarde si il y a un deuxieme client
 
            if lip==liste_des_mecs[1][1] and lport==liste_des_mecs[1][2]:       #regarde si l'ip de l'envoyeur et celle du deuxieme client (joueur1)
                if recu == 'UP':                #si "UP" alors on va en haut 
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant1UP", encoding="utf-8"))
                    dx = 0
                    dy = -3
 
                if recu == 'DOWN':              #si "DOWN" alors on va en bas
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant1DOWN", encoding="utf-8"))
                    dx = 0
                    dy = 3
 
                if recu == 'LEFT':              #si "LEFT" alors on va à gauche
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant1LEFT", encoding="utf-8"))
                    dx = -3
                    dy = 0
 
                if recu == 'RIGHT':             #si "RIGHT" alors on va à droite
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant1RIGHT", encoding="utf-8"))
                    dx = 3
                    dy = 0
                quibouge("mechant1")                                                #fait bouger le pion rouge (mechant1)
 
 
        ##############
 
 
        if i==3:                                                                #regarde si il y a un troisieme client
 
            if lip==liste_des_mecs[2][1] and lport==liste_des_mecs[2][2]:       #regarde si l'ip de l'envoyeur et celle du troisieme client (joueur2)
                if recu == 'UP':#si "UP" alors on va en haut 
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant2UP", encoding="utf-8"))
                    dx = 0
                    dy = -3
 
                if recu == 'DOWN':              #si "DOWN" alors on va en bas
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant2DOWN", encoding="utf-8"))
                    dx = 0
                    dy = 3
 
                if recu == 'LEFT':              #si "LEFT" alors on va à gauche
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant2LEFT", encoding="utf-8"))
                    dx = -3
                    dy = 0
 
                if recu == 'RIGHT':             #si "RIGHT" alors on va à droite
                    for envoimouv in clients_connectes:
                        envoimouv.send(bytes("mouvmechant2RIGHT", encoding="utf-8"))
                    dx = 3
                    dy = 0
                quibouge("mechant2")                                            #fait bouger le pion orange (mechant2)
 
 
 
 
 
    recu=''                         
 
    dx = 0
    dy = 0
 
 
print("Fermeture des connexions au serveur")
for sCli in clients_connectes:
    sCli.close()
sSrv.close()

Client 1 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
            ################################
#############      VARIABLE/LISTE          ##################
            ################################
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
dx = 0
dy = 0
recu = ''
yaqqchose=[] 
 
 
            ################################
#############    INITIALISATION CLIENT     ##################
            ################################
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT))                                  #connexion au serveur avec l'hote et le port
print("Connexion établie avec le serveur sur le port", PORT)
 
 
 
            ################################
#############  CREATION FENETRE GRAPHIQUE  ##################
            ################################
 
 
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")    #dimention fenêtre graphique
photo = PhotoImage(file="mapcouper.gif")                    # nom de l'image de fond
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 1")                                     #titre de la fenêtre créée
 
 
            ################################
#############            FONCTIONS         ##################
            ################################
 
 
 
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):                #fonction pour d'associer les fleches au message à envoyer
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
 
 
 
def up2 (event=None):               #fonction pour associer le deplacement à faire suivant les fleches
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
 
def fonc2(nom):                             #fonction pour associer le message de mouvement du serveur au mouvement des differents pions
    if recu == "mouv"+nom+"UP":
         up2()
    if recu == "mouv"+nom+"DOWN":
        down2()
    if recu == "mouv"+nom+"LEFT":
        left2()
    if recu == "mouv"+nom+"RIGHT":
        right2()
    if recu in ("mouv"+nom+"RIGHT","mouv"+nom+"LEFT","mouv"+nom+"DOWN","mouv"+nom+"UP"):
        fenetre_plateau.move(nom, dx,dy) 
 
 
 
 
 
            ################################
#############      CODE PRINCIPALE         ##################
            ################################ 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
root2.bind('<Up>', up)              #association des fleches directionnel aux 
root2.bind('<Down>', down)          # fonction correspondante
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
while 1:
 
 
 
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):    # Envoi du message
        envoi = bytes(msg_a_envoyer, encoding="utf-8")      
        sCli.send(envoi)
        msg_a_envoyer = ''
 
 
 
 
    try:                                                                
        yaqqchose, wlist, xlist =select.select([sCli],[], [], 0.05)             #ecoute le serveur 
    except select.error:
        pass                                                                # Ne rien faire s'il n'y a pas de message
    else:
        for recevoir in yaqqchose:                                          #boucle pour associer les message envoyés à la variable message recu
            msg_recu = recevoir.recv(TAILLE_MAX_PAQUET)  
            recu = str(msg_recu, encoding="utf-8")  
 
 
 
 
 
    if recu:                                #si on reçoit quelque chose...
        fonc2("gentil")                 
        fonc2("mechant1")
        fonc2("mechant2")
 
    fenetre_plateau.update()            #actualiser la fenetre
    fenetre_plateau.after(1)
 
    recu=''         #remise a zero des variable de message et de mouvement
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

Client 2 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
            ################################
#############      VARIABLE/LISTE          ##################
            ################################
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
dx = 0
dy = 0
recu = ''
yaqqchose=[] 
 
 
            ################################
#############    INITIALISATION CLIENT     ##################
            ################################
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT))                                  #connexion au serveur avec l'hote et le port
print("Connexion établie avec le serveur sur le port", PORT)
 
 
 
            ################################
#############  CREATION FENETRE GRAPHIQUE  ##################
            ################################
 
 
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")    #dimention fenêtre graphique
photo = PhotoImage(file="mapcouper.gif")                    # nom de l'image de fond
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 2")                                     #titre de la fenêtre créée
 
 
            ################################
#############            FONCTIONS         ##################
            ################################
 
 
 
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):                #fonction pour d'associer les fleches au message à envoyer
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
 
 
 
def up2 (event=None):               #fonction pour associer le deplacement à faire suivant les fleches
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
 
def fonc2(nom):                             #fonction pour associer le message de mouvement du serveur au mouvement des differents pions
    if recu == "mouv"+nom+"UP":
         up2()
    if recu == "mouv"+nom+"DOWN":
        down2()
    if recu == "mouv"+nom+"LEFT":
        left2()
    if recu == "mouv"+nom+"RIGHT":
        right2()
    if recu in ("mouv"+nom+"RIGHT","mouv"+nom+"LEFT","mouv"+nom+"DOWN","mouv"+nom+"UP"):
        fenetre_plateau.move(nom, dx,dy) 
 
 
 
 
 
            ################################
#############      CODE PRINCIPALE         ##################
            ################################ 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
root2.bind('<Up>', up)              #association des fleches directionnel aux 
root2.bind('<Down>', down)          # fonction correspondante
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
while 1:
 
 
 
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):    # Envoi du message
        envoi = bytes(msg_a_envoyer, encoding="utf-8")      
        sCli.send(envoi)
        msg_a_envoyer = ''
 
 
 
 
    try:                                                                
        yaqqchose, wlist, xlist =select.select([sCli],[], [], 0.05)             #ecoute le serveur 
    except select.error:
        pass                                                                # Ne rien faire s'il n'y a pas de message
    else:
        for recevoir in yaqqchose:                                          #boucle pour associer les message envoyés à la variable message recu
            msg_recu = recevoir.recv(TAILLE_MAX_PAQUET)  
            recu = str(msg_recu, encoding="utf-8")  
 
 
 
 
 
    if recu:                                #si on reçoit quelque chose...
        fonc2("gentil")                 
        fonc2("mechant1")
        fonc2("mechant2")
 
    fenetre_plateau.update()            #actualiser la fenetre
    fenetre_plateau.after(1)
 
    recu=''         #remise a zero des variable de message et de mouvement
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

Client 3 :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
            ################################
#############      VARIABLE/LISTE          ##################
            ################################
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
dx = 0
dy = 0
recu = ''
yaqqchose=[] 
 
 
            ################################
#############    INITIALISATION CLIENT     ##################
            ################################
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT))                                  #connexion au serveur avec l'hote et le port
print("Connexion établie avec le serveur sur le port", PORT)
 
 
 
            ################################
#############  CREATION FENETRE GRAPHIQUE  ##################
            ################################
 
 
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")    #dimention fenêtre graphique
photo = PhotoImage(file="mapcouper.gif")                    # nom de l'image de fond
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 3")                                     #titre de la fenêtre créée
 
 
            ################################
#############            FONCTIONS         ##################
            ################################
 
 
 
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):                #fonction pour d'associer les fleches au message à envoyer
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
 
 
 
def up2 (event=None):               #fonction pour associer le deplacement à faire suivant les fleches
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
 
 
 
def fonc2(nom):                             #fonction pour associer le message de mouvement du serveur au mouvement des differents pions
    if recu == "mouv"+nom+"UP":
         up2()
    if recu == "mouv"+nom+"DOWN":
        down2()
    if recu == "mouv"+nom+"LEFT":
        left2()
    if recu == "mouv"+nom+"RIGHT":
        right2()
    if recu in ("mouv"+nom+"RIGHT","mouv"+nom+"LEFT","mouv"+nom+"DOWN","mouv"+nom+"UP"):
        fenetre_plateau.move(nom, dx,dy) 
 
 
 
 
 
            ################################
#############      CODE PRINCIPALE         ##################
            ################################ 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
root2.bind('<Up>', up)              #association des fleches directionnel aux 
root2.bind('<Down>', down)          # fonction correspondante
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
while 1:
 
 
 
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):    # Envoi du message
        envoi = bytes(msg_a_envoyer, encoding="utf-8")      
        sCli.send(envoi)
        msg_a_envoyer = ''
 
 
 
 
    try:                                                                
        yaqqchose, wlist, xlist =select.select([sCli],[], [], 0.05)             #ecoute le serveur 
    except select.error:
        pass                                                                # Ne rien faire s'il n'y a pas de message
    else:
        for recevoir in yaqqchose:                                          #boucle pour associer les message envoyés à la variable message recu
            msg_recu = recevoir.recv(TAILLE_MAX_PAQUET)  
            recu = str(msg_recu, encoding="utf-8")  
 
 
 
 
 
    if recu:                                #si on reçoit quelque chose...
        fonc2("gentil")                 
        fonc2("mechant1")
        fonc2("mechant2")
 
    fenetre_plateau.update()            #actualiser la fenetre
    fenetre_plateau.after(1)
 
    recu=''         #remise a zero des variable de message et de mouvement
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

maintenant on essaye de gérer l'arrêt du déplacement lorsque le pion touche un mur.
On a noté toutes les coordonnées de chaque diagonales des obstacles :

M1 = [[0,0],[24,107]
M2 = [[0,77],[52,104]]
M3 = [[79,28],[104,77]]
M4 = [[104,52],[180,77]]
M5 = [[311,54],[410,77]]
M6 = [[387,28],[410,77]]
M7 = [[462,0],[487,104]]
M8 = [[438,77],[487,104]]
M9 = [[180,0],[206,28]]
M10 = [[285,0],[311,28]]
M11 = [[79,107],[104,154]]
M12 = [[104,131],[155,155]]
M13 = [[131,155],[155,231]]
M14 = [[180,105],[308,129]]
M15 = [[387,104],[410,155]]
M16 = [[337,131],[410,155]]
M17 = [[337,131],[361,231]]
M18 = [[79,180],[104,255]]
M19 = [[180,207],[206,255]]
M20 = [[206,231],[311,255]]
M21 = [[283,207],[311,255]]
M22 = [[287,180],[410,255]]
M23 = [[0,255],[52,284]]
M24 = [[0,255],[24,359]]
M25 = [[79,284],[180,307]
M26 = [[79,284],[104,333]]
M27 = [[311,284],[387,307]]
M28 = [[387,284],[410,333]]
M29 = [[438,255],[487,284]]
M30 = [[463,284],[487,359]]
M31 = [[180,333],[207,359]]
M32 = [[285,333],[311,259]]

J'ai fais quelques tests et on c'est vite rendu compte qu'a cause du faite que le déplacement du pion soit de 3 pixels, il était fort probable que le pion passe directement "dans" le mur.

On a donc mis en place une condition avant chaque déplacement vérifiant si le déplacement suivant ne provoque pas le déplacement du pion dans le mur et si c'est le cas, l'ajuster pour qu'il vienne se "coller" a l'obstacle.

On a fait le test avec l'obstacle le plus a gauche et le plus en haut de notre map dont les coordonnées de la diagonales sont [0,0] et [26,103] :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    if recu == 'LEFT':              #si "LEFT" alors on va à gauche
        if (x - r + dx > 26) or (x - r < 103):
            sCli.send(bytes(""+recu+"", encoding="utf-8"))
            dx = -3
            dy = 0
        if (x - r + dx <= 26) :
            sCli.send(bytes("stop", encoding="utf-8"))
            dx = -(x - 26 - r)
            print("test")
            dy = 0
        if (y - r >= 103) :
            sCli.send(bytes(""+recu+"", encoding="utf-8"))
            dx = -3
            dy = 0

Pour l'instant ca marche pas bien, et depuis que j'ai rajouté ses conditions, il arrive que la fenêtre se fige avec "ne répond pas ..."

Serveur :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### SERVEUR TCP - Multi-clients #####
 
import socket
import tkinter as tk
from tkinter import *
import select
 
HOTE = 'localhost'   # quelconque
PORT = 12345
TAILLE_MAX_PAQUET = 1024
recu = '' 
sSrv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sSrv.bind((HOTE, PORT))
sSrv.listen(4)  # Nbre maxi acceptés "en parallèle"
print("Le serveur écoute à présent sur le port", PORT)
 
 
#########  LISTE  ########
clients_connectes = []      #liste des clients connectés
liste_des_mecs = []         #liste des clients connectés + leur ip et leur port
piongentil=[]               #liste coordonnées du pion gentil (x et y)
pionmechant1=[]             #liste coordonnées du pion mechant1
pionmechant2=[]             #liste coordonnées du pion mechant2
coopion=[]                  #liste coordonnées des tous les pions
 
###########  VARIABLE  #############
i=0                     # prend la valeur du nombre de client connectés
lip=""                  # l'ip de l'envoyeur
lport=""                # le port de l'envoyeur
serveur_ecoute = True
dx = 0
dy = 0
 
x=245             #variable gestion coordonnées des pions
y=12
x1=232
y1=217
x2=257
y2=217
r = 8
 
############  CREATION FENETRE PRINCIPALE  ##################
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Serveur")
 
 
 
###########  FONCTIONS  ################
 
 
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom)
 
def quibouge(gentiloumechant):               #fonction pour faire bouger 1 des pions
    fenetre_plateau.move(gentiloumechant, dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
 
 
#########  CODE PRINCIPALE  ###############
 
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
 
 
 
while serveur_ecoute:    # Boucle d'écoute du serveur
    # (1) On vérifie si des nouveaux clients demandent à se connecter
    #  => on écoute le serveur, maxi pendant 0.05 sec.
    connexions_demandees, wlist, xlist = select.select([sSrv],
                                                       [], [], 0.05)
    # en_ecoute, en_ecriture, en_except., pour select.select
    for connexion in connexions_demandees:
        sCli, infos_connexion = connexion.accept()
        # On ajoute le socket connecté à la liste des clients connectés
        clients_connectes.append(sCli)
 
 
    nb_clients_connectes=len(clients_connectes)
    while i<nb_clients_connectes:  #associe le client à son ip+port+donne un nom de joueur
                client = [clients_connectes[i],sCli.getpeername()[0],sCli.getpeername()[1],"joueur"+str(i)]
                liste_des_mecs.append(client)
                i=i+1
 
    # (2) Maintenant, on écoute la liste des clients *connectés*
    liste_sCli_a_lire = []
    try:        # sinon, exception levée si la liste des clients est vide
        liste_sCli_a_lire, wlist, xlist = select.select(clients_connectes,
                                                        [], [], 0.05)
    except select.error:
        pass    # Ne rien faire s'il n'y en a pas
    else:
        # On parcourt la liste des clients à lire
        for sCli in liste_sCli_a_lire:
            msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
            recu = str(msg_recu, encoding="utf-8")  #  à encoder...
            lip=sCli.getpeername()[0]               # met l'ip de l'envoyeur dans cette variable
            lport=sCli.getpeername()[1]             # met le port de l'envoyeur dans cette variable
 
 
 
 
    if recu == 'UP':                #si "UP" alors on va en haut 
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 0
        dy = -3
 
    if recu == 'DOWN':              #si "DOWN" alors on va en bas
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 0
        dy = 3
 
    if recu == 'LEFT':              #si "LEFT" alors on va à gauche
        if (x - r + dx > 26) or (x - r < 103):
            sCli.send(bytes(""+recu+"", encoding="utf-8"))
            dx = -3
            dy = 0
        if (x - r + dx <= 26) :
            sCli.send(bytes("stop", encoding="utf-8"))
            dx = -(x - 26 - r)
            print("test")
            dy = 0
        if (y - r >= 103) :
            sCli.send(bytes(""+recu+"", encoding="utf-8"))
            dx = -3
            dy = 0
 
    if recu == 'RIGHT':             #si "RIGHT" alors on va à droite
        sCli.send(bytes(""+recu+"", encoding="utf-8"))
        dx = 3
        dy = 0
 
 
 
 
    fenetre_plateau.update()    #on actualise la fenêtre 
    fenetre_plateau.after(1) 
 
 
    if recu:
        if lip==liste_des_mecs[0][1] and lport==liste_des_mecs[0][2]:           #regarde si l'ip de l'envoyeur et celle du premier client (joueur0)
            quibouge("gentil")                                                      #fait bouger le pion violet (gentil)
            x=x+dx                                                              #permet de savoir les coordonnées x du pion gentil
            y=y+dy                                                              #permet de savoir les coordonnées y du pion gentil
            piongentil=[x,y]                
 
        if i>=2:                                                                #regarde si il y a un deuxieme client
 
            if lip==liste_des_mecs[1][1] and lport==liste_des_mecs[1][2]:       #regarde si l'ip de l'envoyeur et celle du deuxieme client (joueur1)
                quibouge("mechant1")                                                #fait bouger le pion rouge (mechant1)
                x1=x1+dx
                y1=y1+dy
                pionmechant1=[x1,y1]
        if i==3:                                                                #regarde si il y a un troisieme client
 
            if lip==liste_des_mecs[2][1] and lport==liste_des_mecs[2][2]:       #regarde si l'ip de l'envoyeur et celle du troisieme client (joueur2)
                    quibouge("mechant2")                                            #fait bouger le pion orange (mechant2)
                    x2=x2+dx
                    y2=y2+dy
                    pionmechant2=[x2,y2]
 
 
    coopion=[piongentil,pionmechant1,pionmechant2]                      
 
 
    recu=''                         
 
    dx = 0
    dy = 0
 
 
 
 
print("Fermeture des connexions au serveur")
for sCli in clients_connectes:
    sCli.close()
sSrv.close()

Client :

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
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
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
 
##### CLIENT TCP #####
 
import socket
import tkinter as tk
 
HOTE = 'localhost' 
PORT = 12345 
TAILLE_MAX_PAQUET = 100
up = False
down = False
left = False
right = False
msg_a_envoyer = ''
 
 
sCli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
sCli.connect((HOTE, PORT)) 
print("Connexion établie avec le serveur sur le port", PORT)
#############################################
 
from tkinter import *
 
root2 = Tk()
fenetre_plateau=Canvas(root2, width="487", height="359")
photo = PhotoImage(file="mapcouper.gif")
fenetre_plateau.create_image(243.5, 179.5, image=photo)
fenetre_plateau.pack()
root2.title("Client 1")
 
 
 
carrebleu = [[11,94], [53,94], [11,207], [53,207]]
carrebleu2 = [[438,92], [478,92], [438,206], [478,206]]
x = 240
y = 145
r = 8
dx = 0
dy = 0
couleur="red"
msg_a_envoyer = None
recu = ''
 
def move(event):
    x = fenetre_plateau.canvasx(event.x)
    y = fenetre_plateau.canvasy(event.y)
    #if (carrebleu2[0][0] < event.x < carrebleu2[1][0] and carrebleu2[0][1] < event.y < carrebleu2[2][1]) or (carrebleu[0][0] < event.x < carrebleu[1][0] and carrebleu[0][1] < event.y < carrebleu[2][1]):
 
 
def cercle(x, y, r,couleur,nom):  #fonction création de cercle
    "Trace le cercle de centre (x,y) et de rayon r"
    fenetre_plateau.create_oval((x-r, y-r, x+r, y+r), fill=couleur,tag=nom) 
 
 
def up (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'UP' 
 
def down (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'DOWN'
 
def left (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'LEFT'
 
def right (event=None):
    global msg_a_envoyer
    msg_a_envoyer = 'RIGHT'
 
def up2 (event=None):
    global dx
    global dy
    dx = 0
    dy = -3
def down2(event=None):
    global dx
    global dy
    dx = 0
    dy = 3
 
def left2(event=None):
    global dx
    global dy
    dx = -3
    dy = 0
 
def right2(event=None):
    global dx
    global dy
    dx = 3
    dy = 0
 
def stop (event=None):
    global dx
    global dy
    dx = -(x - 26 - r)
    dy = 0
    print(x,y)
 
cercle(245,12,8,"purple","gentil")      #creation des 3 pions
cercle(232,217,8,"red","mechant1")
cercle(257,217,8,"orange","mechant2")
 
root2.bind('<1>', move)
root2.bind('<Up>', up)
root2.bind('<Down>', down)
root2.bind('<Left>', left)
root2.bind('<Right>', right)
 
 
 
 
 
###################################################
 
while 1:
 
    # Saisie du message
 
 
    # Envoi du message
    if msg_a_envoyer in ('UP', 'DOWN', 'LEFT', 'RIGHT'):
        envoi = bytes(msg_a_envoyer, encoding="utf-8")
        sCli.send(envoi)
        msg_recu = sCli.recv(TAILLE_MAX_PAQUET) # octets, donc 
        recu = str(msg_recu, encoding="utf-8")  #  à encoder...
        #print(recu)
        msg_a_envoyer = ''
        if recu == "UP":
            up2()
        if recu == "DOWN":
            down2()
        if recu == "LEFT":
            left2()
        if recu == "RIGHT":
            right2()
        if recu == "stop":
            stop()
    fenetre_plateau.move("gentil", dx,dy)
    fenetre_plateau.update()
    fenetre_plateau.after(1)
 
    x = x + dx
    y = y + dy
 
    dx = 0
    dy = 0
 
    #########################################################
fen.mainloop()

Le problème c'est que même si j'arrive a faire fonctionner toute mes conditions, ça va être extrêmement long car on a plus de 30 rectangles d'obstacles, et si pour chaque obstacle on doit mettre une condition, voir plusieurs, je sens que ça va être le fouillis . Auriez vous des conseils pour gérer cette partie ?

Merci,
Bromy

[wiztricks]

Le problème c'est que même si j'arrive a faire fonctionner toute mes conditions, ça va être extrêmement long car on a plus de 30 rectangles d'obstacles, et si pour chaque obstacle on doit mettre une condition, voir plusieurs, je sens que ça va être le fouillis .
Auriez vous des conseils pour gérer cette partie ?

Plusieurs choses à clarifier:

• la gestion des déplacements dans le labyrinthe,
• les échanges d'informations entre les joueurs via le serveur.

gestion des déplacements
Virez la partie réseau, reste l'aspect Tk/Canvas et la définition d'une représentation à associer a l'image pour de contrôler que çà reste "dans" les limites autorisées (par les "murs").
Ces limites autorisées sont des ensembles de cellules (des carrés) qui ont des côtés "ouverts" (vers d'autres cellules) ou "fermés" (bords).
On peut ensuite associer ces cellules en zones plus grandes (des "rectangles") dans lesquels on peut se déplacer librement tant qu'on ne touche pas de "bords externes". Dans ce cas, il faut descendre au niveau de la cellule pour savoir s'il y a un passage vers une autre zone ou pas.

échanges d'informations
Le calcul du déplacement étant fait en local - côté "client" - avant d'autoriser le déplacement et éventuellement expédier un message de mise à jour de la position, çà devrait aller. Pour voir comment coder cela, je vous recommande la lecture de maze

- W

[bromy]

Re,

j'ai essayé deux/trois trucs, maintenant tout se passe dans le client, c'est effectivement plus simple

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
def up (event=None):
    if not (y - r - 3<2):
        global msg_a_envoyer
        msg_a_envoyer = 'UP' 
 
def down (event=None):
    if not (y+r+3>77 and x -r < 49) or (y + r + 3>356):
        global msg_a_envoyer
        msg_a_envoyer = 'DOWN'
 
def left (event=None):
    if not (x - r - 3 <24 and y - r < 77) or (x - r - 3<2):
        global msg_a_envoyer
        msg_a_envoyer = 'LEFT'
 
def right (event=None):
    if not (x + r + 3>484):
        global msg_a_envoyer
        msg_a_envoyer = 'RIGHT'

En gros là, je gère que les limites de la map (extreme gauche,droit,bas et haut) et le mur tout a gauche.
Le problème c'est que si je veux gerer tout nos murs, il va falloir faire des conditions a rallonge du style

Code :

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

if not (a < b or a < c or a + e < t or ... or ... or ... or ... or (... and ...) etc

Ca risque d'être très long et assez moche au niveau du code
Je me demandait comment faire autrement