/*
* Reads data into Packet.
* This assumes the byte array is structured as follows: [PacketType][Data]
*/
public static Packet ReadPacketFromByteArray(TcpClient Sender, byte[] Data)
{
Packet packet = new Packet();
//Make sure we have some data.
if (Data.Length > 0)
{
//Stream to read data.
MemoryStream stream = new MemoryStream(Data);
//Read packetType.
byte[] packetTypeBuffer = new byte[sizeof(EPacketType)];
stream.Read(packetTypeBuffer, 0, sizeof(EPacketType));
int packetTypeRaw = BitConverter.ToInt32(packetTypeBuffer, 0);
EPacketType packetType = EPacketType.None;
//Check so it is a valid packet type and if it is let's use it.
if (Enum.IsDefined(typeof(EPacketType), packetTypeRaw))
{
packetType = (EPacketType)packetTypeRaw;
}
//The rest is just data so let's read that.
byte[] packetData = new byte[stream.Length - stream.Position + 1];
stream.Read(packetData, 0, packetData.Length);
//Now create the packet.
packet = new Packet(Sender, packetType, packetData);
}
return(packet);
}
internal virtual void RPCServer(EPacketType type, params object[] objs)
{
if (null != Netlayer)
{
Netlayer.RPCServer(type, objs);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Packet" /> class.
/// </summary>
public Packet(EServerType server_type, EPacketType type, byte value, uint length, byte[] data)
{
BufferChunk.SetNetworking();
Header = new PacketHeader(server_type);
Header.type = (byte)type;
Header.value = value;
Header.packet_number = PacketNumber++;
var len = PacketHeader.Length + 1; // +1 checksum
Header.datalength = 1;
if ((data != null) &&
(length > 0))
{
Header.datalength = length + 1;
len += Header.datalength;
Data = new BufferChunk((int)len);
Data.Add(Header);
Data += data;
//var str = Encoding.ASCII.GetString(Data.Buffer);
}
else
{
Data = new BufferChunk((int)len);
Data.Add(Header);
}
AddChecksumm();
}
protected void RPC_Sync(uLink.BitStream stream, uLink.NetworkMessageInfo info)
{
EPacketType type = EPacketType.PT_MAX;
try
{
type = stream.Read <EPacketType>();
_actionEvent[type](stream, info);
}
catch (Exception e)
{
if (_actionEvent.ContainsKey(type))
{
if (LogFilter.logError)
{
Debug.LogErrorFormat("Message:[{0}]\r\n{1}\r\n{2}\r\n{3}", GetType(), type, e.Message, e.StackTrace);
}
}
else
{
if (LogFilter.logDev)
{
Debug.LogWarningFormat("Message:[{0}]|[{1}] does not implement\r\n{2}", type, GetType(), e.StackTrace);
}
}
}
}
public Packet(EPacketType type)
{
Id = m_nextId;
Type = type;
m_nextId++;
}
public static Packet Deserialize(byte[] packetsBuffer)
{
int index = 0;
Packet packetDeserialize = null;
// Deerialize id
uint uniqueId;
Serializer.DeserializeData(packetsBuffer, ref index, out uniqueId);
// Deerialize id
EPacketType type = (EPacketType)((int)packetsBuffer[index]);
index++;
// Deerialize id
ushort serializedSize;
Serializer.DeserializeData(packetsBuffer, ref index, out serializedSize);
packetDeserialize = PacketFactory.CreatePacket(type);
packetDeserialize.Id = uniqueId;
packetDeserialize.Type = type;
packetDeserialize.SerializedSize = serializedSize;
packetDeserialize.OnDeserialize(packetsBuffer, index);
return(packetDeserialize);
}
public _SubPacketHead(EPacketType packetType, byte seq = 0, byte sub = 0)
{
this.fid = _FIX_ID;
this.tid = _TYPE_ID[(int)packetType];
this.seq = seq;
this.sub = sub;
}
public override void Push(JsonDataObject Value_)
{
{
SByte Var = 0;
Value_.Pop("PacketType", ref Var);
PacketType = (EPacketType)Var;
}
Value_.Pop("RecvPacketSeq", ref RecvPacketSeq);
}
public override void Push(CStream Stream_)
{
{
SByte Var = 0;
Stream_.Pop(ref Var);
PacketType = (EPacketType)Var;
}
Stream_.Pop(ref RecvPacketSeq);
}
public void AddListener(EPacketType type, EventHandler <SocketPacketEventArgs> listener)
{
if (!m_onMessageReceived.ContainsKey(type))
{
m_onMessageReceived.Add(type, listener);
}
else
{
m_onMessageReceived[type] += listener;
}
}
public bool RemoveListener(EPacketType type, EventHandler <SocketPacketEventArgs> listener)
{
if (!m_onMessageReceived.ContainsKey(type))
{
return(false);
}
else
{
m_onMessageReceived[type] -= listener;
}
return(true);
}
/*
* Registers a packet handler.
*/
public void RegisterPacketHandler(EPacketType packetType, HandlePacketDelegate packetDelegate)
{
HandlePacketDelegate existingDelegate;
if (_packetHandlers.TryGetValue(packetType, out existingDelegate))
{
existingDelegate += packetDelegate;
}
else
{
_packetHandlers.Add(packetType, packetDelegate);
}
}
/*
* Creates a byte array from data.
* Packet returnes is in the following format: [Length][PacketType][Data]
*/
public static byte[] CreatePacketByteArray(EPacketType packetType, byte[] Data)
{
int size = sizeof(EPacketType) + Data.Length;
MemoryStream stream = new MemoryStream(1 + size);
//Write length
stream.Write(BitConverter.GetBytes(size), 0, sizeof(int));
//Write Packettype
stream.Write(BitConverter.GetBytes((int)packetType), 0, sizeof(EPacketType));
//Write Data
stream.Write(Data, 0, Data.Length);
return(stream.ToArray());
}
public void RegisterPacketHandler(EPacketType packetType, HandlePacketDelegate packetDelegate)
{
List <HandlePacketDelegate> existingDelegate;
if (_packetHandlers.TryGetValue(packetType, out existingDelegate))
{
existingDelegate.Add(packetDelegate);
}
else
{
List <HandlePacketDelegate> newList = new List <HandlePacketDelegate>();
newList.Add(packetDelegate);
_packetHandlers.Add(packetType, new List <HandlePacketDelegate>(newList));
}
}
public static ushort Size(EPacketType type)
{
switch (type)
{
case EPacketType.UdpSmall:
case EPacketType.Tcp:
return(2);
case EPacketType.UdpLargeFirst:
case EPacketType.UdpLargeOther:
return(4);
default:
return(ushort.MaxValue);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Packet" /> class.
/// </summary>
public Packet(EServerType server_type, EPacketType type, byte cmd)
{
BufferChunk.SetNetworking();
Header = new PacketHeader(server_type);
Header.type = (byte)type;
Header.value = cmd;
Header.packet_number = PacketNumber++;
Header.datalength = 1;
var len = PacketHeader.Length;
len += Header.datalength;
Data = new BufferChunk((int)len);
Data.Add(Header);
AddChecksumm();
}
protected void BindAction(EPacketType type, Action <uLink.BitStream, uLink.NetworkMessageInfo> action)
{
if (_actionEvent.ContainsKey(type))
{
if (LogFilter.logDebug)
{
Debug.LogWarningFormat("Replace msg handler:{0}", type);
}
_actionEvent.Remove(type);
}
if (LogFilter.logDev)
{
Debug.LogWarningFormat("Register msg handler:{0}", type);
}
_actionEvent.Add(type, action);
}
/// <summary>
/// Initializes a new instance of the <see cref="Packet" /> class.
/// </summary>
public Packet(EServerType server_type, EPacketType type,
byte cmd, byte value = 0, byte[] data = null)
{
BufferChunk.SetNetworking();
Header = new PacketHeader(server_type);
Header.type = (byte)type;
Header.value = value;
Header.packet_number = PacketNumber++;
var len = PacketHeader.Length + 1; // +1 checksum
Header.datalength = 1;
if ((data != null) &&
(data.Length > 0))
{
Header.datalength += (uint)data.Length;
len += Header.datalength;
Data = new BufferChunk((int)len);
Data.Add(Header);
Data += data;
}
else
{
Data = new BufferChunk((int)len);
Data.Add(Header);
}
AddChecksumm();
#if LOCAL_DEBUG
Console.WriteLine(Encoding.ASCII.GetString(Header.sign));
if (data != null)
{
var str = Encoding.ASCII.GetString(data);
Console.WriteLine(str);
}
#endif
}
/// <summary>
/// Initializes a new instance of the <see cref="Packet"/> class.
/// </summary>
public Packet(EServerType server_type, EPacketType type, string data)
{
BufferChunk.SetNetworking();
Header = new PacketHeader(server_type);
Header.type = (byte)type;
Header.value = 0;
Header.packet_number = PacketNumber++;
data += "\0"; // quick&dirty
if (!string.IsNullOrEmpty(data))
{
Header.datalength = (uint)data.Length + 1; // +1 checksum
var len = PacketHeader.Length;
len += Header.datalength;
Data = new BufferChunk((int)len);
Data.Add(Header);
Data += data;
var str = Encoding.ASCII.GetString(Data.Buffer);
}
else
{
Header.datalength = 1;
Data = new BufferChunk((int)(PacketHeader.Length + 1));
Data.Add(Header);
}
AddChecksumm();
#if LOCAL_DEBUG
Console.WriteLine(Encoding.ASCII.GetString(Header.sign));
if (!string.IsNullOrEmpty(data))
{
var str = data;
Console.WriteLine(str);
}
#endif
}
public static Packet CreatePacket(EPacketType packetType)
{
Packet packet = null;
switch (packetType)
{
case EPacketType.Text:
packet = new PacketTextMessage();
break;
case EPacketType.Ack:
packet = new PacketAck();
break;
case EPacketType.Connected:
packet = new PacketClientConnected();
break;
case EPacketType.CreateGameRequest:
packet = new PacketCreateGameRequest();
break;
case EPacketType.CreateGameAnswer:
packet = new PacketCreateGameAnswer();
break;
case EPacketType.JoinGameRequest:
packet = new PacketJoinGameRequest();
break;
case EPacketType.JoinGameAnswer:
packet = new PacketJoinGameAnswer();
break;
case EPacketType.GetGameRequest:
packet = new PacketGetGameRequest();
break;
case EPacketType.GetGameAnswer:
packet = new PacketGetGameAnswer();
break;
case EPacketType.LeaveGameRequest:
packet = new PacketLeaveGameRequest();
break;
case EPacketType.LeaveGameAnswer:
packet = new PacketLeaveGameAnswer();
break;
case EPacketType.ObjectEnter:
packet = new PacketObjectEnter();
break;
case EPacketType.ObjectLeave:
packet = new PacketObjectLeave();
break;
case EPacketType.NewPlayerJoin:
packet = new PacketNewPlayerJoin();
break;
case EPacketType.UpdateMovementAnswer:
packet = new PacketMovementUpdateAnswer();
break;
case EPacketType.GameStarted:
packet = new PacketGameStarted();
break;
case EPacketType.PingAnswer:
packet = new PacketPingAnswer();
break;
case EPacketType.PingRequest:
packet = new PacketPingRequest();
break;
case EPacketType.ClockSyncAnswer:
packet = new PacketSyncClockAnswer();
break;
default:
throw new Exception("Impossible to instantiate the packet");
}
return(packet);
}
public SHeader2(SHeader2 Obj_)
{
PacketType = Obj_.PacketType;
RecvPacketSeq = Obj_.RecvPacketSeq;
}
public SHeader2(EPacketType PacketType_, TPacketSeq RecvPacketSeq_)
{
PacketType = PacketType_;
RecvPacketSeq = RecvPacketSeq_;
}
public void Set(SHeader2 Obj_)
{
PacketType = Obj_.PacketType;
RecvPacketSeq = Obj_.RecvPacketSeq;
}
public PacketView(EPacketType type) : base(type)
{
}
public PacketAnswer(EPacketType type) : base(type)
{
}
public Packet(TcpClient sender, EPacketType packetType, byte[] data)
{
_sender = sender;
_packetType = packetType;
_data = data;
}
void _SendBegin(EPacketType PacketType_ = EPacketType.User) // 외부에서 Stream 에 한번에 담아 보낼 수 있으나, 복사를 한번 더 하게 되기 때문에 SProto 를 여러 파라미터로받아 내부에서 SendBegin, SendEnd 영역을 두어 보내는 방식으로 처리
{
new SHeader(0, 0, _SendPacketSeq + 1).Pop(_StreamSnd);
new SHeader2(PacketType_, _RecvPacketSeq).Pop(_StreamSnd);
}
public Packet(EPacketType type, bool reliable = true)
{
Type = type;
IsReliable = reliable;
}
