void C_OnReceivedMessage(byte[] rawMessage)
{
SharpSerializer ser = SharpSerializer.Create(rawMessage);
SharpConnectionMessages incomingType = (SharpConnectionMessages)ser.ReadByte();
if (incomingType == SharpConnectionMessages.ClientConnected)
{
SharpClient incomingClient = new SharpClient(ref ser);
this.room.AssignClient(incomingClient);
C_OnClientConnected(incomingClient);
}
else if (incomingType == SharpConnectionMessages.ClientDisconnected)
{
short netID = ser.ReadInt16();
C_OnClientDisconnected(this.room.Get(netID));
}
else if (incomingType == SharpConnectionMessages.DirectData)
{
short sender = ser.ReadShort();
int channel = ser.ReadInt32();
int packageSize = ser.ReadInt32();
byte[] rawData = ser.ReadBytes(packageSize);
C_OnReceivedData(this.room.Get(sender), channel, rawData);
}
ser.Post();
}
void S_OnReceivedMessage(SharpClient sender, byte[] data)
{
SharpSerializer ser = SharpSerializer.Create(data);
SharpConnectionMessages type = (SharpConnectionMessages)ser.ReadByte();
if (type == SharpConnectionMessages.MessageType1)
{
#region Message Type 1
SharpTargets targets = (SharpTargets)ser.ReadByte();
int channel = ser.ReadInt32();
int size = ser.ReadInt32();
byte[] rawData = ser.ReadBytes(size);
if (targets == SharpTargets.Server)
{
S_OnReceivedData(sender, channel, rawData);
return;
}
SharpSerializer package = SharpSerializer.Create();
package.Write((byte)SharpConnectionMessages.DirectData);
package.Write(sender.NetworkID);
package.Write(channel);
package.Write(size);
package.Write(rawData);
if (targets == SharpTargets.All)
{
Broadcast(package.DataAndPost(), null);
S_OnReceivedData(sender, channel, rawData);
}
else if (targets == SharpTargets.ClientsOnly)
{
Broadcast(package.DataAndPost(), null);
}
else if (targets == SharpTargets.OtherClientsOnly)
{
Broadcast(package.DataAndPost(), sender);
}
else if (targets == SharpTargets.Others)
{
Broadcast(package.DataAndPost(), sender);
S_OnReceivedData(sender, channel, rawData);
}
#endregion
}
else if (type == SharpConnectionMessages.MessageType2)
{
#region Message Type 2
short targetID = ser.ReadInt16();
int channel = ser.ReadInt32();
int size = ser.ReadInt32();
byte[] rawData = ser.ReadBytes(size);
if (targetID == 0)
{
S_OnReceivedData(sender, channel, rawData);
return;
}
SharpSerializer package = SharpSerializer.Create();
package.Write((byte)SharpConnectionMessages.DirectData);
package.Write(sender.NetworkID);
package.Write(channel);
package.Write(size);
package.Write(rawData);
this.room.Get(targetID).SendMessage(package.DataAndPost());
#endregion
}
else if (type == SharpConnectionMessages.MessageType3)
{
#region Message Type 3
short targetCount = ser.ReadInt16();
short[] targets = new short[targetCount];
for (int i = 0; i < targetCount; i++)
{
targets[i] = ser.ReadInt16();
}
int channel = ser.ReadInt32();
int size = ser.ReadInt32();
byte[] rawData = ser.ReadBytes(size);
SharpSerializer package = SharpSerializer.Create();
package.Write((byte)SharpConnectionMessages.DirectData);
package.Write(sender.NetworkID);
package.Write(channel);
package.Write(size);
package.Write(rawData);
byte[] goData = package.DataAndPost();
for (int i = 0; i < targets.Length; i++)
{
if (targets[i] == 0)
{
S_OnReceivedData(sender, channel, rawData);
}
else
{
this.room.Get(targets[i]).SendMessage(goData);
}
}
#endregion
}
}
public bool Connect(string IP, int Port, string Password, SharpClient Self, out ConnectResults result)
{
if (Password == null)
{
Password = "";
}
if (this.connected)
{
result = ConnectResults.AlreadyConnected;
return(false);
}
try
{
server_client = new TcpClient();
IPAddress address = null;
#region IP Parse
try
{
address = IPAddress.Parse(IP);
}
catch
{
result = ConnectResults.InvalidIpAddress;
return(false);
}
#endregion
IPEndPoint remoteAddress = new IPEndPoint(address, Port);
#region Physical Connetion
try
{
server_client.Connect(remoteAddress);
}
catch
{
result = ConnectResults.UnhandledException;
return(false);
}
#endregion
#region ID Self
SharpSerializer hailMessage = SharpSerializer.Create();
hailMessage.Write((byte)IncomingConnectionRequests.ConnectionApprove);
Self.Write(ref hailMessage);
hailMessage.Write(Password);
TCPMessageHandler.Write(server_client, hailMessage.DataAndPost());
#endregion
#region Wait For Response
byte[] responseRaw = TCPMessageHandler.Read(server_client);
SharpSerializer response = SharpSerializer.Create(responseRaw);
#endregion
IncomingConnectionResponse message = (IncomingConnectionResponse)response.ReadByte();
if (message == IncomingConnectionResponse.WrongPassword)
{
TCPMessageHandler.CloseConnection(server_client);
result = ConnectResults.InvalidPassword;
return(false);
}
if (message == IncomingConnectionResponse.ServerIsFull)
{
TCPMessageHandler.CloseConnection(server_client);
result = ConnectResults.ServerIsFull;
return(false);
}
if (message == IncomingConnectionResponse.NameIsExist)
{
TCPMessageHandler.CloseConnection(server_client);
result = ConnectResults.NameIsExist;
return(false);
}
short myID = response.ReadInt16();
Self.AssingNetID(myID);
this.room = new SharpRoom(ref response);
this.listenerThread = new Thread(ListenServer);
this.listenerThread.Start();
connected = true;
me = Self;
room.AssignClient(me);
room.Server.Connection = server_client;
room.Server.ListeningThread = listenerThread;
C_OnConnected(room);
result = ConnectResults.Succes;
return(true);
}
catch (Exception e)
{
try
{
TCPMessageHandler.CloseConnection(server_client);
}
catch { }
server_client = null;
connected = false;
try
{
listenerThread.Abort();
}
catch { }
listenerThread = null;
me = null;
room = null;
result = ConnectResults.UnhandledException;
return(false);
}
}