Bon j'ai bossé sur le truc la voici avec quelque commentaire :
import sys
sys.path.append("C:\\Users\\33781\\Desktop\\DofusBot\\bot")
import binaryread as br
class Flux_Tcp_Client: #Flux TCP en direction du client
#But de la classe : A chaque flux tcp reçu elle prend les données du premier paquets surtout la taille.
#elle lit les bits jusqu'a temps qu'il n'y et plus de rapport avec le paquet sois a la fin du datalen.
#Ensuite elle envoie les datas dans une instance de NetworkMessage puis redémarre a 0 avec la suite du flux tcp
#datalen static
#data static
datalen = 0
data = 0
def __init__(self, data):
packet = br.Data(data) #Pour lire les data qui sont arrivée
if Flux_Tcp_Client.datalen == 0:
NetworkMessage(Flux_Tcp_Client.data) #Notre packet est devenu un objet NetworkMessage propre
Flux_Tcp_Client.data = 0 #On retire les datas de l'ancien paquets
Flux_Tcp_Client.datalen = 0
self.reading_data(packet) #On relance la lecture du packet header etc ..
while Flux_Tcp_Client.datalen > 0 and len(packet) >= packet.pos + 1: #Si il reste des choses a lire ET si il reste des bytes au paquet que on lit
Flux_Tcp_Client.data += packet.readByte()
Flux_Tcp_Client.datalen -= 1
def reading_data(self, packet):
#Header : 2 bytes (id + lentype), 1-2-3 bytes (en fonction de lentype)
(packetid, lentype) = br.header_info(packet)
Flux_Tcp_Client.datalen = self.lendata(lentype, packet) + 2 + lentype #On ajoute le header avec les +
packet.reset_pos()
#Header : 2 bytes (id + lentype), 4 bytes (unsigned int = instanceid), 1-2-3 bytes (en fonction de lentype)
# if self.cible == "server":
# (packetid, lentype) = br.header_info(packet)
# self.instance_id = packet.readUnsignedInt()
# self.datalen = self.lendata(lentype, packet)
def lendata(self, lentype, packet):
if lentype == 1:
taille = packet.readByte()
elif lentype == 2:
taille = packet.readShort()
elif lentype == 3:
high = packet.readByte()
low = packet.readShort()
high = high << 16
taille = high | low
else:
taille = 0
return taille
class Flux_Tcp_Server:#Flux TCP en direction du Server
#But de la classe : A chaque flux tcp reçu elle prend les données du premier paquets surtout la taille.
#elle lit les bits jusqu'a temps qu'il n'y et plus de rapport avec le paquet sois a la fin du datalen.
#Ensuite elle envoie les datas dans une instance de NetworkMessage puis redémarre a 0 avec la suite du flux tcp
#datalen static
#data static
datalen = 0
data = 0
def __init__(self, data):
packet = br.Data(data) #Pour lire les data qui sont arrivée
if Flux_Tcp_Server.datalen == 0:
NetworkMessage(Flux_Tcp_Server.data) #Notre packet est devenu un objet NetworkMessage propre
Flux_Tcp_Server.data = 0 #On retire les datas de l'ancien paquets
self.reading_data(packet) #On relance la lecture du packet header etc ..
while Flux_Tcp_Server.datalen > 0 and len(packet) >= packet.pos + 1: #Si il reste des choses a lire ET si il reste des bytes au paquet que on lit
Flux_Tcp_Server.data += packet.readByte()
Flux_Tcp_Server.datalen -= 1
def reading_data(self, packet):
# Header : 2 bytes (id + lentype), 4 bytes (unsigned int = instanceid), 1-2-3 bytes (en fonction de lentype)
(packetid, lentype) = br.header_info(packet)
self.instance_id = packet.readUnsignedInt()
Flux_Tcp_Server.datalen = self.lendata(lentype, packet) + 2 + 4 + lentype #id et lentype + instanceid + lendata
packet.reset_pos()
def lendata(self, lentype, packet):
if lentype == 1:
taille = packet.readByte()
elif lentype == 2:
taille = packet.readShort()
elif lentype == 3:
high = packet.readByte()
low = packet.readShort()
high = high << 16
taille = high | low
else:
taille = 0
return taille
class NetworkMessage:
instance_id = 0
def __init__(self, data): #Pour le moment on gère juste l'instance id
NetworkMessage.instance_id += 1
Voici le lieu ou je l'appelle :
def dumb_callback(soClient, soServer):
"""Forwards all the traffic between the two sockets
"""
conns = [soClient, soServer]
other = {soClient: soServer, soServer: soClient}
active = True
try:
while active:
rlist, wlist, xlist = select.select(conns, [], conns)
if xlist or not rlist:
break
for r in rlist:
data = r.recv(8192)
if other[r] == soServer: #Envoie des datas en fonction de qui l'envoie dans les classes spécifique au traitement de l'instance id
nm.Flux_Tcp_Server(data)
elif other[r] == soClient:
nm.Flux_Tcp_Client(data)
packet_gestion(data) #Gestion du packet en fonction de la data
if not data:
active = False
break
other[r].sendall(data) #On send les données a other[r]
finally:
for c in conns:
c.close()
Bon sa fait beaucoup de code a lire pour vous la j'espère que le résumé va vous permettre de comprendre plus vite ;)
Voilà le problème que je rencontre :
Evidemment l'instance id n'est toujours pas bon et je remarque que mon instance id semble augmenté uniquement quand j'envoie des informations au server. L'instance id augmente réellement quand je n'envoie rien au serveur (aucune action avec la fenetre dofus quelque seconde et l'instance id a augmenter map solo juste des messages dans le tchat). Alors que l'instance id que je calcule n'a augmenté que quand j'ai envoyé un message dans le tchat ou un déplacement sur la carte etc ...
Si quelqu'un vois une petite erreur bien évidement je continu a cherche de mon côté et alimenterai le sujet si je fais une découverte.
Bonne soirée au plus motivé d'entre vous :)