**Bonjour à tous, bonjour à toute**Dans ce tutoriel, nous allons découvrir les bases pour la création d'un bot socket pour Dofus.Il s'agit vraiment de bases, ce code pourra être améliorer sans problème.Il a été rédigé par moi-même en étroite collaboration avec **MikeDotNet**.J'ai essayer de faire le plus complet possible, alors ça donne quelque chose de très long, ne faites pas tout en une fois, prenez le temps de bien comprendre.Je ne donnerai pas le projet final pour obliger les personnes à suivre, comprendre ce tutoriel.En cas de problème de compréhension n'hésitez pas à poser des questions. Les codes présent seront en c#, cependant, ils sont facile à traduire dans d'autre langage.Voici le plan de ce tutoriel :**- I - Prérequis- II - Création de la solution et de son contenue.- III - MyBot.Packet- 1) Arborescence de la library- 2) Reader/Writer- 3) Interfaces et class utiles- 4) La structure des packets- 5) Les Types- IV - MyBot.Network- Préambule - 1) MyBotSocket- 2) MyBotBuffer- 3) MyBotPacketDeserializer- 4) La méthode Send (MyBotSocket / Writer)- 5) Assemblage**Attention, c'est partie.**I - Prérequis**Pour réaliser ce tutoriel vous allez avoir de besoin de quelques connaissances rapide, de fournitures (pas scolaire ;) ), d'envie et de motivation.** - Connaissances : **Avant de se lancer dans la création d'un bot socket, il faut, tout de même, avoir quelques connaissances basiques, mais qui permettent néanmoins de comprendre le code que nous allons utiliser.Vous aurez donc besoin de :- Connaitre un langage de programmation (mieux vaut préciser, on sait jamais :p )- Connaitre un minimum les [socket](http://msdn.microsoft.com/fr-fr/library/system.net.sockets.socket.aspx) (leurs utilités, et les fonctions de base)- Connaitre également le terme de [Thread](http://msdn.microsoft.com/fr-fr/library/system.threading.thread.aspx)- Et enfin avoir compris les grandes lignes du fonctionnement de Dofus 2.0 (packets)** - Fournitures : **Du point de vue matériel, développer un bot socket ne demande pas beaucoup de chose, simplement :- Visual studio, dans le cadre de langage .net, sinon un IDE à adéquate - Une dll dont je parlerai par la suite.- Un cerveaux en forme, qui a la soif d'apprendre.Attention, c'est partie.On commence par : **II - Création de la solution et de son contenue.**Avant de foncer la tête la première dans le code, il faut se poser plusieurs questions sur l'architecture du projet (ça évitera de devoir tout recommencer à mi-chemin)**On commence par créer la solution de notre projet : MyBot**Comme vous le savez, pour communiquer dofus utilise des class, accessible dans les sources du jeux (DofusInvoker.swf) qui sont serializées et deserializées. Ces class sont nommées packet.** Dans notre solution, on va donc créer une library nommée MyBot.Packet qui contiendra toute ces class.****Ensuite, on va également créer une autre library que l'on nommera MyBot.Core, dans celle-ci, nous mettrons tout les algorithmes et la logique de notre projet. (tel que le Pathfinding, Cryptage du mot de passe, ... Ceux-ci ne seront pas expliqué dans ce tutoriel)****Encore une autre dll pour la communication: MyBot.Network****Pour finir, on va bien évidament, créer l'exe du projet que l'on nommera MyBot.Interface**Voilà, voici le projet prêt à être démarré : PS : Libre à vous, d'ajouter d'autre partie dans celui-ci comme par exemple, la lecture des .d2i, .d2o, ...**III - MyBot.Packet****1) Arborescence de la library**Etant donné que cette partie du projet contient, les sources du jeux, nous allons garder la même arborescence que celles-ci.Il est très important de ranger nos class comme ceci, sinon on est rapidement débordé par la masse de fichier.On crée donc le premier noeud avec les dossiers "Messages" et "Types" (on veillera toujours à mettre des majuscules)**2) Reader/Writer**Dans cette petite partie, nous allons un peu anticiper sur la suite du tutoriel, en effet, le projet Mybot.Packet va également contenir les class Reader et Writer pour serializer et deserializer nos packet.Si vous ne maîtrisez pas bien le protocol de Dofus 2.0, c'est le moment de s'y intéresser, même pour ce qui le connaisse bien, je vous conseil de relire ce [tutoriel](https://cadernis.com/d/218), un peu de révision ne fait pas de mal.> Et bien on utilise (sous .net) les classes BinaryWriter et BinaryReader (en faite non, mais j'expliquerai après) pour écrire le paquet. C'est ces classes qui se chargent d'écrire/lire les octets (comme quoi c'est plus facile hein )[...]Problème D. 2.0 utilise un grand endian alors qu’en .net tous les lecteurs binaires sont en petit endian (BinaryReader/Writer en autres). De base il n'y en a pas qui supporte les 2 modes.Résultat nous devons impérativement exporter une librairie tierce pour pouvoir lire/écrire en Big Endian. Je n'ai pas de conseil spécial à ce sujet, à vous de trouver la bonneComme l'a très bien expliqué Bouh2, le protocol de dofus 2.0, lit/écrit les octets en BigEndian (à l'envers) il faut donc trouver un moyen de faire de même.Je vous conseil vivement, si vous n'avez pas envie de vous prendre la tête, d'utiliser la dll MiscUtils (projet open source téléchargeable gratuitement.)Bon maintenant équipé, commençons par le reader :``` using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using MiscUtil.IO; using MiscUtil.Conversion; namespace MyBot.Packet { public class Reader { private EndianBinaryReader _reader; public Reader(byte[] data) { _reader = new EndianBinaryReader(BigEndianBitConverter.Big, new MemoryStream(data)); } ```Comme vous l'avez remarqué, on définie à Big le converter, comme l'a dit bouh. Jusque là, rien de bien compliqué, ne vous inquiétez pas, le reste l'est tout autant ;)Arrivé à ce stade, on va crée toute les méthodes, qui vont nous servir : ``` public int ReadInt() { return _reader.ReadInt32(); } ``` (faire de même pour uint, short (int16), ushort(uint16), byte, sbyte, bool , double)On complète ensuite avec : ``` public byte[] ReadBytes(int lenght) { return _reader.ReadBytes(lenght); } public string ReadString() { ushort stringLenght = ReadUShort(); byte[] byteString = ReadBytes(stringLenght); return ASCIIEncoding.UTF8.GetString(byteString); } ```Et voilà notre classe finie.Pour le writer c'est assez semblable :``` using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using MiscUtil.Conversion; using MiscUtil.IO; namespace MyBot.Packet { public class Writer { private EndianBinaryWriter _writer; private MemoryStream _stream; public Writer() { _stream = new MemoryStream(); _writer = new EndianBinaryWriter(EndianBitConverter.Big, _stream); } public void WriteString(string value) { byte[] stringByte = ASCIIEncoding.UTF8.GetBytes(value); WriteUShort((ushort)(stringByte.Length)); WriteBytes(stringByte); } public void WriteInt(int value) { _writer.Write(value); } ... faire de même avec les autre types ```**3) Interfaces et class utile**Comme vous le savez, j'en suis sûre, il y a **deux types différents de packet** :[tab]- Les packets que l'on reçois, qui sont envoyé par le serveur et réceptionné par le client (visible dans le MessageReceiver.as)[/tab][tab]- Et les packets que l'on envoie, ils sont envoyé par le client à destination du server ( le reste)[/tab]Ces deux types de packets, nous allons les différencier grâce à deux interfaces et deux enum :IClientPacket et ClientPacketEnum, pour ceux qui sont envoyé par le client .IServerPacket et ServerPacketEnum, pour les autres.[tab]A) Les Enum[/tab]Chaque enum contiendra la liste des packets correspondant avec le protocolId associé exemple : ``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet { public enum ServerPacketEnum { HelloConnectMessage = 3, //HelloConnectMessage est un packet envoyé par le server ayant pour protocolId 3. } } ```Et``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet { public enum ClientPacketEnum { IdentificationMessage = 4, // IdentificationMessage est un packet envoyé par le client ayant pour protocolId 4. } } ```A chaque fois que l'on ajoutera un packet à notre library, on ajoutera sont équivalent dans l'enum correspondant.[tab]B) Les Interfaces[/tab]Avant tout si vous ne savez pas ce qu'est une interface, il faut aller vous renseigner, [ici par exemple](http://msdn.microsoft.com/fr-fr/library/87d83y5b(v=vs.100).aspx)Les interfaces IClientPacket et IServerPacket vont être implantées sur chacun de nos packets, ils nous permettrons, entre autre, de garder toujours la même structure pour nos packets.Voici les interfaces : ``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet { public interface IClientPacket { ClientPacketEnum PacketType { get; } void Serialize(Writer writer); } } `````` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet { public interface IServerPacket { ServerPacketEnum PacketType { get; } void Deserialize(Reader reader); } } ```Je ne vais pas développer plus cette sous-partie, j'en parle davantage dans la partie suivante.**4) La structure des packets**Comme je l'ai expliqué ci-dessus, il est très important de garder toujours la même structure pour nos packets.Voici celle que nous allons adopter : [tab]**Notions de base :**[/tab]Avant tout, on essayera de remplacer, les variables de type _loc_... par **des noms en rapport avec leur rôle**.On remplacera également les boucles **while()** par des boucles **for()/foreach()** pour plus de propretéIl faut toujours **déclarer la variable dans le type avec lequel elle va être lu/écrite**, exemple : une variable est déclarée en int mais plus bas, dans la méthodes de deserialization on trouve "maVariable = param1.ReadUint();" dans ce cas maVariable devra être déclarée en uint et pas en int.On utilise des **void **( **Sub **en Vb) pour serializer/deserializer un packet (les fonctions ne servent pas)[tab]**A) Les packets client :**[/tab]Les packets client sont donc, je le rappelle, les packets qui sont envoyé par le client.Voici un exemple de ceci (je n'ai pas pris IdentificationMessage car il est trop long) :[spoiler]``` package com.ankamagames.dofus.network.messages.connection { import com.ankamagames.jerakine.network.*; import flash.utils.*; public class ServerSelectionMessage extends NetworkMessage implements INetworkMessage { private var _isInitialized:Boolean = false; public var serverId:int = 0; public static const protocolId:uint = 40; public function ServerSelectionMessage() { return; }// end function override public function get isInitialized() : Boolean { return this._isInitialized; }// end function override public function getMessageId() : uint { return 40; }// end function public function initServerSelectionMessage(param1:int = 0) : ServerSelectionMessage { this.serverId = param1; this._isInitialized = true; return this; }// end function override public function reset() : void { this.serverId = 0; this._isInitialized = false; return; }// end function override public function pack(param1:IDataOutput) : void { var _loc_2:* = new ByteArray(); this.serialize(_loc_2); writePacket(param1, this.getMessageId(), _loc_2); return; }// end function override public function unpack(param1:IDataInput, param2:uint) : void { this.deserialize(param1); return; }// end function public function serialize(param1:IDataOutput) : void { this.serializeAs_ServerSelectionMessage(param1); return; }// end function public function serializeAs_ServerSelectionMessage(param1:IDataOutput) : void { param1.writeShort(this.serverId); return; }// end function public function deserialize(param1:IDataInput) : void { this.deserializeAs_ServerSelectionMessage(param1); return; }// end function public function deserializeAs_ServerSelectionMessage(param1:IDataInput) : void { this.serverId = param1.readShort(); return; }// end function } } ```[/spoiler]Comme vous pouvez le voir, c'est assez conséquent, surtout que plus de la moitié est inutile, nous nous avons simplement besoin :**- de properties- d'un constructeur - d'une méthode de Serialisation (car on souhaite envoyer ce packet) **Commençons point par point:- Les properties :Comme il s'agit d'un packet envoyé par le client, nous n'avons donc pas besoin de connaitre les valeurs de ses variable, on peut donc les déclarer en private :``` private short _serverId; ```Vous pouvez constater que j'ai modifié le type (int en short) car dans la méthode de deserialization, on trouve "_serverId = param1.ReadShort();"- Le constructeur :On utilisera un constructeur classique :``` public ServerSelectionMessage(short serverId) { _serverId = serverId; } ```- La méthode de serialisation :``` public void Serialize(Writer writer) { writer.WriteShort(_serverId); } ```- Pour identifier le packet, on utilisera le ClientPacketEnum ( et non le protocolId)``` public ClientPacketEnum PacketType { get { return ClientPacketEnum.ServerSelectionMessage; } } ```Voici la structure de base d'un ClientPacketLa class finale est donc :[spoiler]``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet.Messages.Connection { public class ServerSelectionMessage : IClientPacket { public ClientPacketEnum PacketType { get { return ClientPacketEnum.ServerSelectionMessage; } } private short _serverId; public ServerSelectionMessage(short serverId) { _serverId = serverId; } public void Serialize(Writer writer) { writer.WriteShort(_serverId); } } } ```[/spoiler] (bien plus courte que la .as)[tab]**B) Les packets server**[/tab]Les packets server sont donc, eux, les packets envoyé par le server.Voici un exemple : [spoiler]``` package com.ankamagames.dofus.network.messages.connection { import __AS3__.vec.*; import com.ankamagames.jerakine.network.*; import flash.utils.*; public class HelloConnectMessage extends NetworkMessage implements INetworkMessage { private var _isInitialized:Boolean = false; public var salt:String = ""; public var key:Vector.; public static const protocolId:uint = 3; public function HelloConnectMessage() { this.key = new Vector.; return; }// end function override public function get isInitialized() : Boolean { return this._isInitialized; }// end function override public function getMessageId() : uint { return 3; }// end function public function initHelloConnectMessage(param1:String = "", param2:Vector. = null) : HelloConnectMessage { this.salt = param1; this.key = param2; this._isInitialized = true; return this; }// end function override public function reset() : void { this.salt = ""; this.key = new Vector.; this._isInitialized = false; return; }// end function override public function pack(param1:IDataOutput) : void { var _loc_2:* = new ByteArray(); this.serialize(_loc_2); writePacket(param1, this.getMessageId(), _loc_2); return; }// end function override public function unpack(param1:IDataInput, param2:uint) : void { this.deserialize(param1); return; }// end function public function serialize(param1:IDataOutput) : void { this.serializeAs_HelloConnectMessage(param1); return; }// end function public function serializeAs_HelloConnectMessage(param1:IDataOutput) : void { param1.writeUTF(this.salt); param1.writeShort(this.key.length); var _loc_2:uint = 0; while (_loc_2 < this.key.length) { param1.writeByte(this.key[_loc_2]); _loc_2 = _loc_2 + 1; } return; }// end function public function deserialize(param1:IDataInput) : void { this.deserializeAs_HelloConnectMessage(param1); return; }// end function public function deserializeAs_HelloConnectMessage(param1:IDataInput) : void { var _loc_4:int = 0; this.salt = param1.readUTF(); var _loc_2:* = param1.readUnsignedShort(); var _loc_3:uint = 0; while (_loc_3 < _loc_2) { _loc_4 = param1.readByte(); this.key.push(_loc_4); _loc_3 = _loc_3 + 1; } return; }// end function } } ```[/spoiler]Cette fois-ci, nous avons besoin :**- De properties- D'une methode de Deserialisation **- Les properties :Ici, nous avons besoin de connaitre les valeurs des variables, on va donc les déclarer en private/publique (principe de la POO) :``` private string _salt; private List _key = new List(); public string Salt { get { return _salt; } } public List Key { get { return _key; } } ```- Une méthode de deserialisation (comme je l'ai dit, j'utilise ici une boucle for()) :``` public void Deserialize(Reader reader) { _salt = reader.ReadString(); ushort keyCount = reader.ReadUShort(); for (int i = 0; i < keyCount; i++) { _key.Add(reader.ReadByte()); } } ```- Pour identifier le packet on utilisera ServerPacketEnum:``` public ServerPacketEnum PacketType { get { return ServerPacketEnum.HelloConnectMessage; } } ```On a donc au final : [spoiler]``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet.Messages.Connection { public class HelloConnectMessage : IServerPacket { public ServerPacketEnum PacketType { get { return ServerPacketEnum.HelloConnectMessage; } } private string _salt; private List _key = new List(); public string Salt { get { return _salt; } } public List Key { get { return _key; } } public void Deserialize(Reader reader) { _salt = reader.ReadString(); ushort keyCount = reader.ReadUShort(); for (int i = 0; i < keyCount; i++) { _key.Add(reader.ReadByte()); } } } } ```[/spoiler]** 5) Les Types**Notre lib va également contenir les typee, on va donc choisir également une structure à respecter pour ceci, elle va être très semblable à celle que nous avons vue précédemment.On commence par crée, même principe, un enum :``` namespace MyBot.Packet { public enum TypeEnum { Version = 11, } } ```On crée ensuite une interface :``` namespace MyBot.Packet { public interface ITypes { TypeEnum Type { get; } void Serialize(Writer writer); void Deserialize(Reader reader); } } ```Que l'on implémentera sur tout nos types.Je ne fait pas d'exemple complet, c'est la même chose que pour les packet sauf que l'on a les deux méthode (Serialize et Deserialize).Voilà, je pense que vous êtes maintenant capable d'ajouter des packet à ce projet sans problème.La base de notre library terminée, nous pouvons désormais passer à autre chose.**IV - MyBot.Network****Préambule :**Avant de commencer cette partie, je pense qu'il est nécessaire de faire plusieurs précisions.Les méthodes que je vais expliquer ci-dessous ont été faites par **Mike**, le pro du réseaux !Vous pouvez d’ailleurs consulter ses tutos sur ce sujet, qui sont très intéressant, dans la partie [C#](http://www.cadernis.fr/viewforum.php?f=6).Cette partie de notre solution va donc gérer toute **la communication botServer** , c'est un peu technique et pas très facile à expliqué, donc il est possible que je ne soit pas très claire. Il faudra donc que vous posiez des questions si besoin.Cette communication va se décomposer en trois parties, trois class primordiales.Voici un schémas explicatif:![img](http://img11.hostingpics.net/pics/386580MyBotNetwork.jpg)**1) MyBotSocket**Cette première class jouera le rôle d'une socket classique, à laquelle on va ajouter plusieurs fonctionnalités. Donc pour ce qui est de la réception des donnés, nous allons faire ceci de façons synchrone avec un thread dans une boucle infini qui réceptionne les données envoyées par le server.A) Déclaration des variables :``` using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; using System.Net; using System.Threading; using MyBot.Packet; namespace MyBot.Network { public class MyBotSocket { private Socket _socket; private Thread _listeningThread; private IPEndPoint _endPoint; ```Je pense que les noms sont assez claires pour que l'on puisse comprendre. B) Le constructeur :``` public MyBotSocket(IPEndPoint endPoint) { _endPoint = endPoint; _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); _listeningThread = new Thread(new ThreadStart(Listening)); } ```Rien de bien complexe non plus, la méthode Listening est expliquée plus bas C) Le démarage : ``` public void ConnectEndListen() { _socket.Connect(_endPoint); _listeningThread.Start(); } ```On connecte la socket et on lance le thread pour écouter la connexion. D) L'écoute :Ça se complique légèrement mais rien d'insurmontable.``` byte[] receiverBuffer; byte[] buffer; int bufferSize; while (true) // Attaquons maintenant la structure concrète d'un paquet D. 2.0 :[HEADER:[HI-HEADER:2 bytes (PacketId 6 bits + LengthType 2 bits)][LENGTH:LengthType (1/2/3) bytes][MESSAGE:LENGTH bytes]]jusqu'a :Voilà, désormais vous savez, lire correctement un paquet dans D. 2.0Il faut également connaitre l'objet [Queue](http://msdn.microsoft.com/fr-fr/library/system.collections.queue.aspx) car c'est la pièce maîtresse de cette class (on peut faire sans, avec d'autre objet, mais ce serai plus long, ou bien avec quelque chose de plus poussé, plus performant cependant, pour un bot socket pour dofus, Queue est largement suffisant).A) Déclaration des variables :``` private Queue _byteQueue = new Queue(); public event EventHandler RecievePacketBuffer; ```L'EventArg PacketBufferEventArg est très simple, elle contient simplement l'id du packet et sont contenue (byte[]) :[spoiler]``` namespace MyBot.Network { public class PacketBufferEventArg : EventArgs { private byte[] _data; private short _packetId; public byte[] Data { get { return _data; } } public short PacketId { get { return _packetId; } } public PacketBufferEventArg(short packetId, byte[] buffer) { _data = buffer; _packetId = packetId; } } } ```[/spoiler]B) La méthode d'ajout de byte[] (Enqueue)Cette méthode va permettre de remplir notre _byteQueue avec un byte array (byte[])``` public void Enqueu(byte[] buffer) { foreach (byte b in buffer) { _byteQueue.Enqueue(b); // On ajoute chaque byte du buffer à _byteQueue } ProcessQueue(); // A voir plus bas } ```C) La méthode de traitement du buffer (ProcessQueue)Cette méthode est un peu complexe, elle va "regarder" si dans _byteQueue il y a un packet.Si c'est le cas elle lance l'event crée ci-dessus.``` private void ProcessQueue() { while (_byteQueue.Count > 0) // Tant que _byteQueue n'est pas vide { if (_byteQueue.Count < 2) // Si le nombre de byte contenue est plus petit que 2, on ne pourra pas lire le header du packet, dans ce cas, on sort de la méthode return; Reader temp = new Reader(_byteQueue.ToArray()); // On crée un reader temporaire pour lire le header short header = temp.ReadShort(); // On lit le header short packetId = (short)(header >> 2); // On récupère l'id du packet short lenghtSize = (short)(header & 3); // On récupère la taille de la taille du packet if (_byteQueue.Count < 2 + lenghtSize) // Si on ne peu pas lire la taille du packet, on quitte la méthode return; short lenght; // On récupère la taille du packet switch (lenghtSize) { case 0: lenght = 0; break; case 1: lenght = temp.ReadByte(); break; case 2: lenght = temp.ReadShort(); break; case 3: lenght = (short)((((temp.ReadByte() & 255)

Whoa gros tuto! C'est vraiment bien. J'aime ton style de coding :)

:lol: J'espère que tu as vu :> Les méthodes que je vais expliquer ci-dessous ont été faites par Mike, le pro du réseaux !(Je devrai p-e le mettre en gras :) )

Très beau tutoriel je les suivis à la lettre donc aucune erreur pour le moment je vais l'utiliser dans la journée (surement après mettre réveiller)Avec se que tu nous à donner ont peut faire n'importe quoi avec le bot y à pas de restriction?PS : tu à oublier de dire qu'il faut rajouter quelque chose dans ClientPacketEnum si ont suit bien le tutoriel ont le rajoute facilement ;)

Merci beaucoup pour ce super tuto.Il ne doit pas être en c# plutot?

@miniteck27140 : Avec cette base, tu peux faire tout type de bot oui (à l’exception d'un MITM, la partie Network serai plus compliquée). C'est quoi le souci au niveau de ClientPacketEnum ?@Geraff : Je me suis justement posé la question avant de poster, mais je pense que l'architecture pourrait être utile pour les personnes pratiquant d'autres langages, enfin comme tu le souhaite, si tu penses qu'il serai mieux en C# déplace-le :)

Il faut rajouter ceci : ServerSelectionMessage = 40,Dans ClientPacketEnumJ'ai oublier de dire dansPour ceci : case ServerPacketEnum.ProtocolRequired: // packet = new ProtocolRequired(); // Comme ceci break;Vous trouverez une erreur à ProtocolRequired donc ajouter le dans ServerPacketEnum comme ceci :ProtocolRequired = 1,Ensuite il faut créer la class ProtocolRequired j'ai fait comme ceci :[spoiler]``` using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MyBot.Packet.Messages.handshake { public class ProtocolRequired : IServerPacket { public ServerPacketEnum PacketType { get { return ServerPacketEnum.ProtocolRequired; }// Ont renvois dans ServerPacketEnum.ProtocolRequired pour avoir l'id du packet donc 1 } private uint requiredVersion; private uint currentVersion; public uint requiredVersions { get { return requiredVersion; } } public uint currentVersions { get { return currentVersion; } } public void Deserialize(Reader reader) { requiredVersion = reader.ReadUint(); if (requiredVersion < 0) { Console.WriteLine("Forbidden value (" + currentVersion + ") on element of ProtocolRequired.currentVersion."); } currentVersion = reader.ReadUint(); if (currentVersion < 0) { Console.WriteLine("Forbidden value (" + currentVersion + ") on element of ProtocolRequired.currentVersion."); } } } } ```[/spoiler]Dite moi si j'ai fait une faute le C# N'est pas le langage dans le quelle je pratique tout les jours

Dans la Sub WriteString du PacketWriter, il faut faire une nouvelle Sub appelé WriteBytes. Jusque là OK, mais le problème c'est qu'il n'existe pas dans la Dll MiscUtil. Dois-je chercher ça sur le net ou c'est une erreur ? Sinon excellent tutoriel, Nickel !Edit: j'ai aussi un problème avec les Interfaces : Class 'HelloConnectMessage' doit implémenter 'ReadOnly Property PacketType As Enums.ServerPacketEnum' pour l'interface 'Interfaces.IServerPacket'. La propriété d'implémentation doit avoir des spécificateurs 'ReadOnly' ou 'WriteOnly' correspondants.

Jilakin voyons , as tu vraiment besoin d'une DLL pour ecrire 2 octets suivis du texte ?

@miniteck : En effet, c'est cela, enfin à vue d'oeil, cependant, les "if" ne sont nécessaire, ils n'ont pas vraiment d'utilités sauf alourdir le code, je te conseille de ne pas les mettre.@Jilakin : Oui, il faut créer un sub, WriteBytes(byte[] ) n'est rien d'autre qu'une surcharge de plus.On aurrait pu mettre _writer.write(stringByte)Pour ton erreur, je pense que tu doit déclarer PacketType en Read Only, comme dans ton interface.

@Toons : Je ne fait que suivre ce qui est écrit dans le tutoriel, sinon c'est vrai que ma question est inutile.@Maxilia : Eh bien justement pour mon erreur, c'est louche car PacketType est déclarer en ReadOnly..Edit : Pour l'erreur, je viens de trouver. Voilà ce qu'il faut faire pour ceux qui la rencontrerais aussi :[spoiler]Public ReadOnly Property PacketType() As ServerPacketEnum Implements Interfaces.IServerPacket.PacketType Get Return ServerPacketEnum.HelloConnectMessage End Get End Property[/spoiler]Et pour la Sub WriteBytes, c'est bon ! C'est la même Sub que WriteByte mais il faut rajouter "()" a (Byval value As Byte())

Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

[Tuto] Bot socket, les fondamentaux

DevChris

Shornaal
J'ai une erreur System.NullReferenceException lors de l'exécution de cette ligne :
RecievePacketBuffer(null, new PacketBufferEventArg(protocolID, data));
Voici la ligne où je l'instancie :
public event EventHandler<PacketBufferEventArg> RecievePacketBuffer;
J'ai vérifié, les valeurs de ProtocolID & Data existent bel et bien. Cela fait une heure que je planche et je ne comprends pas d'où ça peut venir. Faut-il remplacer le "null" en argument ? Si oui, par quoi ? Je commence tout juste à me mettre au C# et je dois avouer que là, ça me pose une belle colle !

J'ai exactement la même erreur que toi... tu as reussi a la résoudre depuis le temps? ou quelqu'un d'autre saurais? Merci

Someone

If i would be able to understand one thing is that we have to recreate every (i don't mean all of them only those necessary) class there's in The DofusInvoker in C# only optimizing it removing all the useless functions am i wrong ?

Apokah

Kind of, its usually done by a tool (a tool that converts .as files in DofusInvoker to .cs or .vb files for you to add to your project).

Nameless

By the way, you can also store them into a cloud

zahid98

Not all of the classes , just the ones used to serialize or deserialize the packets notably those who's name ends with a 'Message' . There are many tools used to used to automaticly translate all of these in your desired language but I belivieve that the most efficient and 'shapable' one is BiM project translator wich is based on a template systeme .

link : https://github.com/Emudofus/BehaviorIsManaged

Check the protocolBuilder folder and if you're curious enough take a look at the whole project , most current .Net bots contains some code from this masterpiece .

Someone

so i can get a packet analyse it call the deserialize method relative to it and such, Now i wanna send something say for example make the character move How do i know the structure on which my packet should be based on so the server would understand and i can't find the ClientPacketEnums in the Dofusinvoker why is that ? i know that the ServerPacketEnums located in the MessageReciever

Avocado

Quelqu'un peut m'aider pour la méthode Send(IClientPacket packet) de la partie IV.I.D) ?

J'ai essayé quelque chose comme ça (les noms changent un peu par rapport au tuto mais ça devrait être clair) :


// init writer et écrit le paquet dans le stream
MessageWriter writer = new MessageWriter();
writer.WritePacket(packet);
// envoie le packet au serveur via la socket
Socket.Send(writer.Stream.GetBuffer());

Mais ça ne marche pas, ça me met que j'ai été déconnecté (parce que je me retrouve dans la condition (bufferSize == 0) dans le listen).

BlueDream

@Avocado

La fonction WritePacket() a changé depuis une récente mise à jour du jeu.

Il y a un système de comptage des packets qui a été ajouté via la variable _instance_id.

A chaque paquet envoyé ou reçu la variable instance prend la valeur += 1.

NetworkMessage.as

public function writePacket(param1:ICustomDataOutput, param2:int, param3:ByteArray) : void
      {
         var _loc5_:uint = 0;
         var _loc6_:uint = 0;
         var _loc4_:uint = computeTypeLen(param3.length);
         param1.writeShort(subComputeStaticHeader(param2,_loc4_));
         param1.writeUnsignedInt(this._instance_id);
         switch(_loc4_)
         {
            case 0:
               return;
            case 1:
               param1.writeByte(param3.length);
               break;
            case 2:
               param1.writeShort(param3.length);
               break;
            case 3:
               _loc5_ = param3.length >> 16 & 255;
               _loc6_ = param3.length & 65535;
               param1.writeByte(_loc5_);
               param1.writeShort(_loc6_);
               break;
         }
         param1.writeBytes(param3,0,param3.length);
      }

Towzeur

Désolé, une erreur est survenue lors de l'affichage du contenu. Si vous êtes un utilisateur, veuillez réessayer plus tard. Si vous êtes un administrateur, consultez les fichiers journaux de votre forum pour obtenir plus d'informations.

« Page précédente