public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
if (len >= offset + 4)
{
NetPacketHeader.HtonFloat(buf, offset, (float)m_Vlue);
return(4);
}
return(0);
}
public override UInt16 Read(Byte[] buf, UInt16 offset, int len)
{
if (len >= offset + 8)
{
m_Vlue = NetPacketHeader.NtohDouble(buf, offset);
return(8);
}
return(0);
}
public NetPacketHeader Clone()
{
NetPacketHeader header = new NetPacketHeader();
header.m_nPacketId = m_nPacketId;
header.m_nIsZip = m_nIsZip;
header.m_nBodyLen = m_nBodyLen;
return(header);
}
public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
if (len >= offset + 8)
{
NetPacketHeader.HtonDouble(buf, offset, (double)m_Vlue);
return(8);
}
return(0);
}
public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
if (len >= offset + 2)
{
NetPacketHeader.HtonUInt16(buf, offset, (UInt16)m_Vlue);
return(2);
}
return(0);
}
public override UInt16 Read(Byte[] buf, UInt16 offset, int len)
{
//int i = offset;
//while (buf[i] != 0)
//{
// i++;
//}
ushort length = NetPacketHeader.NtohUint16(buf, offset);
string str = Encoding.UTF8.GetString(buf, offset + 2, length);
m_Vlue = str;
return((UInt16)(length + 2));
}
public static String NtohString(Byte[] buf, int offset, out UInt16 len)
{
ushort length = NetPacketHeader.NtohUint16(buf, offset);
if (m_IsBigEndian)
{
Array.Reverse(buf, offset, length + 2);
}
len = (ushort)(length + 2);
string str = Encoding.UTF8.GetString(buf, offset + 2, length);
return(str);
}
protected UInt16 WriteArrayHead(Byte[] buf, UInt16 offset)
{
if (m_bBigArray)
{
NetPacketHeader.HtonUInt16(buf, offset, m_nLen);
return(2);
}
else
{
buf[offset] = (Byte)m_nLen;
}
return(1);
}
protected UInt16 ReadArrayHead(Byte[] buf, UInt16 offset)
{
if (m_bBigArray)
{
m_nLen = NetPacketHeader.NtohUint16(buf, offset);
return(2);
}
else
{
m_nLen = buf[offset];
}
return(1);
}
public UInt16 Write(Byte[] buf)
{
UInt16 offset = NetPacketHeader.GetHeadLen();
if (m_datas == null)
{
}
else
{
Array.ConstrainedCopy(m_datas, 0, buf, offset, m_datas.Length);
offset += (UInt16)m_datas.Length;
}
m_header.WriteHead(buf);
return(offset);
}
public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
UInt16 nResult = 0;
if (null != m_Vlue)
{
String str = (string)m_Vlue;
Byte[] strbuf = Encoding.UTF8.GetBytes(str);
NetPacketHeader.HtonUInt16(buf, offset, (ushort)strbuf.Length);
Array.ConstrainedCopy(strbuf, 0, buf, offset + 2, strbuf.Length);
nResult = (UInt16)(strbuf.Length + 2);
}
return(nResult);
}
public static UInt16 HtonString(Byte[] buf, int offset, string vl)
{
UInt16 nResult = 0;
if (null != vl)
{
String str = vl;
Byte[] strbuf = Encoding.UTF8.GetBytes(str);
NetPacketHeader.HtonUInt16(buf, offset, (ushort)strbuf.Length);
Array.ConstrainedCopy(strbuf, 0, buf, offset + 2, strbuf.Length);
nResult = (UInt16)(strbuf.Length + 2);
}
return(nResult);
}
public NetPacket(ushort id, byte[] datas, ushort length)
{
m_header = new NetPacketHeader();
m_header.PacketId = id;
m_header.BodyLength = length;
if (datas == null || length == 0)
{
m_header.BodyLength = 0;
}
else
{
m_header.BodyLength = length;
m_datas = new byte[length];
Array.ConstrainedCopy(datas, 0, m_datas, 0, length);
}
}
public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
UInt16 nResult = offset;
UInt16 n = WriteArrayHead(buf, offset);
if (len > offset + n + m_nLen * 2)
{
offset += n;
for (n = 0; n < m_nLen; ++n)
{
NetPacketHeader.HtonUInt16(buf, offset, (UInt16)m_Vlue);
offset += 2;
}
return((UInt16)(offset - nResult));
}
return(0);
}
public override UInt16 Write(Byte[] buf, UInt16 offset, int len)
{
double[] buffer = (double[])m_Vlue;
UInt16 nResult = offset;
UInt16 n = WriteArrayHead(buf, offset);
offset += n;
if (len >= offset + (8 * m_nLen))
{
for (n = 0; n < m_nLen; ++n)
{
NetPacketHeader.HtonDouble(buf, offset, buffer[n]);
offset += 8;
}
return((UInt16)(offset - nResult));
}
return(0);
}
public override UInt16 Read(Byte[] buf, UInt16 offset, int len)
{
UInt16[] buffer;
UInt16 nResult = offset;
UInt16 n = ReadArrayHead(buf, offset);
if (len > offset + n + m_nLen * 2)
{
offset += n;
buffer = new UInt16[m_nLen];
for (n = 0; n < m_nLen; ++n)
{
buffer[n] = NetPacketHeader.NtohUint16(buf, offset);
offset += 2;
}
m_Vlue = buffer;
return((UInt16)(offset - nResult));
}
return(0);
}
public override UInt16 Read(Byte[] buf, UInt16 offset, int len)
{
double[] buffer;
UInt16 nResult = offset;
UInt16 n = ReadArrayHead(buf, offset);
offset += n;
if (len >= offset + (m_nLen * 8))
{
buffer = new double[m_nLen];
for (n = 0; n < m_nLen; ++n)
{
buffer[n] = NetPacketHeader.NtohDouble(buf, offset);
offset += 8;
}
m_Vlue = buffer;
return((UInt16)(offset - nResult));
}
return(0);
}
public NetPacket(NetPacketHeader header)
{
m_header = header.Clone();
}
private bool _TcpRecv()
{
int recvlen = 0;
if (m_pNetPacketHeader.PacketId > 0)
{
recvlen = m_pNetPacketHeader.BodyLength;
//-m_pNetPacketHeader.GetHeadLen();
}
else
{
recvlen = NetPacketHeader.GetHeadLen();
}
if (m_TcpSocket.Available <= 0)
{
return(false);
}
m_nRecvBufferOffset += m_TcpSocket.Receive(m_Recvbuffer, m_nRecvBufferOffset, recvlen - m_nRecvBufferOffset, 0);
if (m_nRecvBufferOffset < recvlen)
{
Debug.Log("bao ti shu liang bu gou");
return(false);
}
if (m_pNetPacketHeader.PacketId > 0)
{
NetPacket packet = null;
// string str = "";
// Debug.Log("m_pNetPacketHeader.BodyLength:" + m_pNetPacketHeader.BodyLength);
// for(int i = 0;i < m_pNetPacketHeader.BodyLength;i++){
// str += (m_Recvbuffer[i] + "_");
// }
// Debug.Log("m_Recvbuffer:" + str);
packet = new NetPacket(m_pNetPacketHeader);
packet.Read(m_Recvbuffer, m_pNetPacketHeader.BodyLength);
m_RecvQueue.Enqueue(packet);
m_pNetPacketHeader.PacketId = 0;
m_nRecvBufferOffset = 0;
}
else
{ //read packet header
if (m_pNetPacketHeader.ReadHead(m_Recvbuffer))
{
if (m_pNetPacketHeader.BodyLength <= 0)
{//dose not have body data
NetPacket msg = new NetPacket(m_pNetPacketHeader);
m_RecvQueue.Enqueue(msg);
// Debug.Log("m_pNetPacketHeader.PacketId:" + m_pNetPacketHeader.PacketId);
// Debug.Log("msg:" + msg.Count);
m_pNetPacketHeader.PacketId = 0;
}
m_nRecvBufferOffset = 0;
}
else
{
m_TcpSocket.Close(1);
return(false);
}
}
return(true);
}
