If Not packet_id = 42 Then
MyLog.WriteLog("Reception id " & packet_id & ", Lenght -> " & packet_length)
MySock.Send(data)
Else
Dim _SSD As New Network.Connection.Server.Select.SelectedServerDataMessage
_SSD.Deserialize(New BigEndianReader(New System.IO.MemoryStream(packet)))
Main.GameIp = _SSD.Address
Main.GamePort = _SSD.port
Dim SSD As New Network.Connection.Server.Select.SelectedServerDataMessage
SSD.init(_SSD.serverId, "127.0.0.1", 443, _SSD.canCreateNewCharacter, _SSD.ticket) ' ces qui qui ecoute le porte 443
SSD.pack(MySock)
ServerSock.Close()
MySock.Close()
End If
package com.ankamagames.dofus.network.messages.connection
{
import com.ankamagames.jerakine.network.NetworkMessage;
import com.ankamagames.jerakine.network.INetworkMessage;
import com.ankamagames.jerakine.network.ICustomDataOutput;
import flash.utils.ByteArray;
import com.ankamagames.jerakine.network.CustomDataWrapper;
import com.ankamagames.jerakine.network.ICustomDataInput;
[Trusted]
public class SelectedServerDataMessage extends NetworkMessage implements INetworkMessage
{
public static const protocolId:uint = 42;
private var _isInitialized:Boolean = false;
public var serverId:uint = 0;
public var address:String = "";
public var port:uint = 0;
public var canCreateNewCharacter:Boolean = false;
public var ticket:Vector.<int>;
public function SelectedServerDataMessage()
{
this.ticket = new Vector.<int>();
super();
}
override public function get isInitialized() : Boolean
{
return this._isInitialized;
}
override public function getMessageId() : uint
{
return 42;
}
public function initSelectedServerDataMessage(param1:uint = 0, param2:String = "", param3:uint = 0, param4:Boolean = false, param5:Vector.<int> = null) : SelectedServerDataMessage
{
this.serverId = param1;
this.address = param2;
this.port = param3;
this.canCreateNewCharacter = param4;
this.ticket = param5;
this._isInitialized = true;
return this;
}
override public function reset() : void
{
this.serverId = 0;
this.address = "";
this.port = 0;
this.canCreateNewCharacter = false;
this.ticket = new Vector.<int>();
this._isInitialized = false;
}
override public function pack(param1:ICustomDataOutput) : void
{
var _loc2_:ByteArray = new ByteArray();
this.serialize(new CustomDataWrapper(_loc2_));
writePacket(param1,this.getMessageId(),_loc2_);
}
override public function unpack(param1:ICustomDataInput, param2:uint) : void
{
this.deserialize(param1);
}
public function serialize(param1:ICustomDataOutput) : void
{
this.serializeAs_SelectedServerDataMessage(param1);
}
public function serializeAs_SelectedServerDataMessage(param1:ICustomDataOutput) : void
{
if(this.serverId < 0)
{
throw new Error("Forbidden value (" + this.serverId + ") on element serverId.");
}
param1.writeVarShort(this.serverId);
param1.writeUTF(this.address);
if(this.port < 0 || this.port > 65535)
{
throw new Error("Forbidden value (" + this.port + ") on element port.");
}
param1.writeShort(this.port);
param1.writeBoolean(this.canCreateNewCharacter);
param1.writeVarInt(this.ticket.length);
var _loc2_:uint = 0;
while(_loc2_ < this.ticket.length)
{
param1.writeByte(this.ticket[_loc2_]);
_loc2_++;
}
}
public function deserialize(param1:ICustomDataInput) : void
{
this.deserializeAs_SelectedServerDataMessage(param1);
}
public function deserializeAs_SelectedServerDataMessage(param1:ICustomDataInput) : void
{
var _loc4_:* = 0;
this.serverId = param1.readVarUhShort();
if(this.serverId < 0)
{
throw new Error("Forbidden value (" + this.serverId + ") on element of SelectedServerDataMessage.serverId.");
}
this.address = param1.readUTF();
this.port = param1.readUnsignedShort();
if(this.port < 0 || this.port > 65535)
{
throw new Error("Forbidden value (" + this.port + ") on element of SelectedServerDataMessage.port.");
}
this.canCreateNewCharacter = param1.readBoolean();
var _loc2_:uint = param1.readVarInt();
var _loc3_:uint = 0;
while(_loc3_ < _loc2_)
{
_loc4_ = param1.readByte();
this.ticket.push(_loc4_);
_loc3_++;
}
}
}
}
public class SelectedServerDataMessage : NetworkMessage
{
public const uint Id = 42;
public override uint MessageId
{
get { return Id; }
}
public uint serverId;
public string address;
public ushort port;
public bool canCreateNewCharacter;
public sbyte[] ticket;
public SelectedServerDataMessage()
{
}
public SelectedServerDataMessage(uint serverId, string address, ushort port, bool canCreateNewCharacter, sbyte[] ticket)
{
this.serverId = serverId;
this.address = address;
this.port = port;
this.canCreateNewCharacter = canCreateNewCharacter;
this.ticket = ticket;
}
public override void Serialize(IDataWriter writer)
{
writer.WriteVarShort((int)serverId);
writer.WriteUTF(address);
writer.WriteUShort(port);
writer.WriteBoolean(canCreateNewCharacter);
writer.WriteVarInt((int)(ushort)ticket.Length);
foreach (var entry in ticket)
{
writer.WriteSByte(entry);
}
}
public override void Deserialize(IDataReader reader)
{
serverId = reader.ReadVarUhShort();
address = reader.ReadUTF();
port = reader.ReadUShort();
canCreateNewCharacter = reader.ReadBoolean();
var limit = (ushort)reader.ReadVarInt();
ticket = new sbyte[limit];
for (int i = 0; i < limit; i++)
{
ticket[i] = reader.ReadSByte();
}
}
}
Namespace Network.Connection.Server.Select
Public Class SelectedServerDataMessage
Public Const Id As UInteger = 42
Public ReadOnly Property MessageId() As UInteger
Get
Return Id
End Get
End Property
Public serverId As UInteger
Public address As String
Public port As UShort
Public canCreateNewCharacter As Boolean
Public ticket As SByte()
Public Sub New()
End Sub
Public Sub init(serverId As UInteger, address As String, port As UShort, canCreateNewCharacter As Boolean, ticket As SByte())
Me.serverId = serverId
Me.address = address
Me.port = port
Me.canCreateNewCharacter = canCreateNewCharacter
Me.ticket = ticket
End Sub
Public Function pack(ByVal sock As Object)
Dim _Writer As New BigEndianWriter()
Me.Serialize(_Writer)
BigEndianWriter.Send(SelectedServerDataMessage.Id, sock)
End Function
Public Sub Serialize(ByVal Writer As BigEndianWriter)
Writer.WriteVarShort(Me.serverId)
Writer.WriteUTF(Me.address)
Writer.WriteUShort(Me.port)
Writer.WriteBoolean(Me.canCreateNewCharacter)
Writer.writeVarInt(CInt(CUShort(ticket.Length)))
For Each entry As SByte In ticket
Writer.WriteSByte(entry)
Next
End Sub
Public Sub Deserialize(reader As BigEndianReader)
serverId = reader.ReadVarUhShort()
address = reader.ReadUTF()
port = reader.ReadUShort()
canCreateNewCharacter = reader.ReadBoolean()
Dim limit = CUShort(reader.ReadVarInt())
ticket = New SByte(limit - 1) {}
For i As Integer = 0 To limit - 1
ticket(i) = reader.ReadSByte()
Next
End Sub
End Class
End Namespace
Public Class SockManager
Public WithEvents LoginSock As New BazSocket.BazSocket
Public WithEvents GameSock As New BazSocket.BazSocket
Private MyLog As _Interface.Logger.LogConsole
Private Main As MainForm
Sub New(ByVal _MyLog As _Interface.Logger.LogConsole, ByVal _Main As MainForm)
MyLog = _MyLog
Main = _Main
End Sub
''############ Serveur ############
Public Sub InitializeLoginSock()
LoginSock = New BazSocket.BazSocket(Main)
LoginSock.Listen("127.0.0.1", 5555)
End Sub
Private Sub Client_Accepted(ByVal sender As System.Object, ByVal Request As AcceptRequest) Handles LoginSock.Accepted
Dim LoginSock As New Login.LoginSock
Dim AcceptSock As New BazSocket.BazSocket(New Form, Request)
AcceptSock.AlwaysRaiseClose = True
AcceptSock.AsyncEvent = True
Dim NewIP As String = AcceptSock.RemoteEP.Address.ToString
Dim NewPort As String = AcceptSock.RemoteEP.Port.ToString
MyLog.WriteLog("Nouveau client sur le socket de connexion : " & NewIP & ":" & NewPort)
LoginSock.MySock = AcceptSock
LoginSock.MyLog = MyLog
LoginSock.Main = Main
Main.ClientLogin.Add(LoginSock)
LoginSock.Initialize()
End Sub
Private Sub LoginSock_Listen(ByVal sender As Object, ByVal e As System.EventArgs) Handles LoginSock.Listening
MyLog.WriteLog("Jeu en écoute ... (Connexion)")
End Sub
Private Sub LoginSock_ListenFailed(ByVal sender As Object, ByVal ex As System.Exception) Handles LoginSock.ListenFailed
MyLog.WriteError("Impossible d'écouter le jeu (Connexion) !")
End Sub
'############### Jeu ###############
Public Sub InitializeGameSock()
GameSock = New BazSocket.BazSocket(Main)
GameSock.Listen("127.0.0.1", 5555)
End Sub
Private Sub Player_Accepted(ByVal sender As System.Object, ByVal Request As AcceptRequest) Handles GameSock.Accepted
Dim _FormBot As New FormBot
Dim AcceptSock As New BazSocket.BazSocket(_FormBot, Request)
AcceptSock.AlwaysRaiseClose = True
AcceptSock.AsyncEvent = True
Dim NewIP As String = AcceptSock.RemoteEP.Address.ToString
Dim NewPort As String = AcceptSock.RemoteEP.Port.ToString
MyLog.WriteLog("Nouveau client sur le socket de jeu : " & NewIP & ":" & NewPort)
Dim GameSock As New Game.GameSock
GameSock.MySock = AcceptSock
GameSock.MyLog = New LogBot(_FormBot)
GameSock.Main = Main
GameSock.ConsoleLog = MyLog
GameSock.FormBot = _FormBot
GameSock.Initialize(Main.GameIp, Main.GamePort)
Main.ClientGame.Add(GameSock)
_FormBot.GameSock = GameSock
_FormBot.MdiParent = Main
_FormBot.Show()
End Sub
Private Sub GameSock_Listen(ByVal sender As Object, ByVal e As System.EventArgs) Handles GameSock.Listening
MyLog.WriteLog("Jeu en écoute ... (Game)")
End Sub
Private Sub GameSock_ListenFailed(ByVal sender As Object, ByVal ex As System.Exception) Handles GameSock.ListenFailed
MyLog.WriteError("Impossible d'écouter le jeu (Game) !")
End Sub
End Class