using UnityEngine;
|
using System.Collections;
|
using System;
|
using System.Text;
|
using System.Collections.Generic;
|
|
/** 通迅包基类，处理字节流转换 */
|
public class GameNetPackBasic
|
{
|
|
public ServerType socketType = ServerType.Main;
|
|
/** 协议号 */
|
protected ushort _cmd = 0;
|
/** 协议号引用 */
|
public ushort cmd { get { return _cmd; } }
|
/** 信息转换后的字节包 */
|
protected byte[] _writedBytes;
|
/** 用于发送的组合帧 */
|
protected byte[] _combineBytes;
|
/** 信息转换后的字节包的引用 */
|
public byte[] dataBytes { get { return _writedBytes; } }
|
/** 用于发送的组合帧的引用 */
|
public byte[] combineBytes { get { return _combineBytes; } }
|
/** 字节写入位置索引 */
|
protected int _writeIndex = 0;
|
/** 解析位置索引 */
|
protected int _readIndex = 2;
|
/** 最终合并采用的协议，为0表示不调整 */
|
protected ushort combineCmd = 0;
|
/** 字符编码机 */
|
public static Encoding StrEncoding = Encoding.UTF8;
|
|
//自定义字段，用于后续更新用
|
private Dictionary<string, object> fields;
|
|
public void SetField(string key, object o)
|
{
|
if (fields == null)
|
fields = new Dictionary<string, object>();
|
fields[key] = o;
|
}
|
|
//获取自定义字段
|
public T GetField<T>(string key)
|
{
|
if (fields == null)
|
{
|
DebugEx.LogErrorFormat("未设置自定义字段：{0}", key);
|
return default(T);
|
}
|
if (fields.TryGetValue(key, out object o))
|
{
|
if (o is T)
|
return (T)o;
|
else
|
{
|
DebugEx.LogErrorFormat("自定义字段：{0}，不是类型：{1}", key, typeof(T));
|
return default(T);
|
}
|
}
|
DebugEx.LogErrorFormat("不存在自定义字段：{0}", key);
|
return default(T);
|
}
|
|
|
/** 子信息类型 */
|
public enum NetDataType
|
{
|
BYTE,
|
WORD,
|
DWORD,
|
Chars,
|
Int,
|
Double
|
}
|
|
/** 字符串长度写入的方式 */
|
public enum StrWriteLen
|
{
|
BYTE,
|
WORD,
|
DWORD
|
}
|
|
/** 字节占用字节量 */
|
public static short ByteLeng = 1;
|
/** 布尔值占用字节量 */
|
public static short BoolLeng = 1;
|
/** 短整型占用字节量 */
|
public static short ShortLeng = 2;
|
/** 整型占用字节量 */
|
public static short IntLeng = 4;
|
/** 长整型占用字节量 */
|
public static short LongLeng = 8;
|
/** 双浮点型占用字节量 */
|
public static short DoubleLeng = 8;
|
|
/** 从字节包中解析信息 */
|
public virtual void ReadFromBytes(byte[] vBytes)
|
{
|
|
}
|
|
/** 将信息写成字节包 */
|
public virtual void WriteToBytes()
|
{
|
}
|
|
private string _vInfoCont = "";
|
public string vInfoCont {
|
get {
|
return _vInfoCont;
|
}
|
}
|
/** 组合帧信息 */
|
public void CombineDatas(GameNetEncode encoder)
|
{
|
try
|
{
|
if (_writedBytes == null)
|
{
|
_writedBytes = new byte[0];
|
}
|
|
byte[] vCmdAndSubCmd = new byte[2];
|
vCmdAndSubCmd[0] = (byte)((_cmd & 0xFF00) >> 8);
|
vCmdAndSubCmd[1] = (byte)(_cmd & 0xFF);
|
byte[] vCmdAndBody = new byte[_writedBytes.Length + vCmdAndSubCmd.Length]; // 协议与内容
|
|
//DesignDebug.NetLog("GameNetPackBasic vCmdAndBody:" + vCmdAndBody.Length);
|
Array.Copy(vCmdAndSubCmd, 0, vCmdAndBody, 0, vCmdAndSubCmd.Length);
|
if (_writedBytes.Length > 0)
|
Array.Copy(_writedBytes, 0, vCmdAndBody, vCmdAndSubCmd.Length, _writedBytes.Length);
|
|
if (combineCmd != 0) // 采用另外的协议号
|
{
|
byte[] vExCmdAndBody = new byte[vCmdAndBody.Length + 4];
|
vExCmdAndBody[0] = (byte)((combineCmd & 0xFF00) >> 8);
|
vExCmdAndBody[1] = (byte)(combineCmd & 0xFF);
|
var _lengthBytes = BitConverter.GetBytes((ushort)vCmdAndBody.Length);
|
vExCmdAndBody[2] = _lengthBytes[0];
|
vExCmdAndBody[3] = _lengthBytes[1];
|
|
Array.Copy(vCmdAndBody, 0, vExCmdAndBody, 4, vCmdAndBody.Length);
|
vCmdAndBody = vExCmdAndBody;
|
}
|
|
vCmdAndBody = encoder.BaseXorAdd(vCmdAndBody); // 加密
|
|
_combineBytes = new byte[vCmdAndBody.Length + 6]; // 合并体
|
byte[] vFrameHead = new byte[] { 255, 204 };
|
byte[] vMsgBodyLength = BitConverter.GetBytes(vCmdAndBody.Length);
|
Array.Copy(vFrameHead, 0, _combineBytes, 0, vFrameHead.Length);
|
Array.Copy(vMsgBodyLength, 0, _combineBytes, 2, vMsgBodyLength.Length);
|
Array.Copy(vCmdAndBody, 0, _combineBytes, 6, vCmdAndBody.Length);
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("封包信息组合异常 ：{0}", ex);
|
}
|
|
}
|
|
/** 转换字节段为布尔值 */
|
protected void TransBytes(out bool vTof, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vTof = false;
|
if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + BoolLeng) <= vBytes.Length)
|
{
|
vTof = BitConverter.ToBoolean(vBytes, _readIndex);
|
_readIndex += BoolLeng;
|
}
|
else
|
{
|
Debug.LogError("(line:130) 字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为布尔值异常：{0}", ex);
|
vTof = false;
|
}
|
|
}
|
|
/** 转换字节段为字节 */
|
protected void TransBytes(out byte vbyte, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vbyte = 0;
|
if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + ByteLeng) <= vBytes.Length)
|
{
|
vbyte = vBytes[_readIndex];
|
_readIndex += ByteLeng;
|
}
|
else
|
{
|
DebugEx.LogError("(line:189) 字节包数据量不足");
|
}
|
}
|
else
|
{
|
DebugEx.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为字节异常：{0}", ex);
|
vbyte = 0;
|
}
|
|
}
|
|
/** 转换字节段为短整型 */
|
protected void TransBytes(out short vShort, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vShort = 0;
|
if (vNetDataType == NetDataType.WORD)
|
{
|
if ((_readIndex + ShortLeng) <= vBytes.Length)
|
{
|
vShort = BitConverter.ToInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
else
|
{
|
Debug.LogError(" 字节包数据量不足");
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + ByteLeng) <= vBytes.Length)
|
{
|
byte vTheByte = vBytes[_readIndex];
|
byte[] vTempBytes = new byte[2];
|
vTempBytes[0] = vTheByte;
|
if (vTheByte > 127)
|
vTempBytes[1] = 0xFF;
|
vShort = BitConverter.ToInt16(vTempBytes, 0);
|
// DesignDebug.NetLog("vShort:" + vShort);
|
_readIndex += ByteLeng;
|
}
|
else
|
{
|
Debug.LogError(" 字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为短整型异常：{0}", ex);
|
vShort = 0;
|
}
|
|
}
|
|
/** 转换字节段为短整型 */
|
protected void TransBytes(out ushort vShort, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vShort = 0;
|
if (vNetDataType == NetDataType.WORD)
|
{
|
if ((_readIndex + ShortLeng) <= vBytes.Length)
|
{
|
vShort = BitConverter.ToUInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
else
|
{
|
Debug.LogError("字节包数据量不足");
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + ByteLeng) <= vBytes.Length)
|
{
|
vShort = (ushort)vBytes[_readIndex];
|
_readIndex += ByteLeng;
|
}
|
else
|
{
|
Debug.LogError("字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为短整型异常：{0}", ex);
|
vShort = 0;
|
}
|
|
}
|
|
/** 转换字节段为整型 */
|
protected void TransBytes(out int vInt, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vInt = 0;
|
if (vNetDataType == NetDataType.DWORD || vNetDataType == NetDataType.Int)
|
{
|
if ((_readIndex + IntLeng) <= vBytes.Length)
|
{
|
vInt = BitConverter.ToInt32(vBytes, _readIndex);
|
_readIndex += IntLeng;
|
}
|
else
|
{
|
Debug.LogError("字节包数据量不足");
|
}
|
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
vInt = (int)vBytes[_readIndex];
|
_readIndex += 1;
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为整型异常：{0}", ex);
|
vInt = 0;
|
}
|
|
}
|
|
/** 转换字节段为整型 */
|
protected void TransBytes(out uint vInt, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vInt = 0;
|
if (vNetDataType == NetDataType.DWORD || vNetDataType == NetDataType.Int)
|
{
|
if ((_readIndex + IntLeng) <= vBytes.Length)
|
{
|
vInt = BitConverter.ToUInt32(vBytes, _readIndex);
|
_readIndex += IntLeng;
|
}
|
else
|
{
|
Debug.LogError("(line:228) 字节包数据量不足");
|
}
|
}
|
else if (vNetDataType == NetDataType.WORD)
|
{
|
if ((_readIndex + ShortLeng) <= vBytes.Length)
|
{
|
vInt = (uint)BitConverter.ToUInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
else
|
{
|
Debug.LogError("(line:238) 字节包数据量不足");
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
vInt = (uint)vBytes[_readIndex];
|
_readIndex += 1;
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为整型异常：{0}", ex);
|
vInt = 0;
|
}
|
|
}
|
|
protected void TransBytes(out byte[] bytes, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out bytes, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out byte[] bytes, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out bytes, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out byte[] bytes, byte[] vBytes, NetDataType vNetDataType, short vLeng)
|
{
|
TransBytes(out bytes, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out byte[] bytes, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out bytes, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out byte[] bytes, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
bytes = new byte[vLeng];
|
if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + ByteLeng) <= vBytes.Length)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
bytes[i] = vBytes[_readIndex];
|
_readIndex += ByteLeng;
|
}
|
}
|
else
|
{
|
Debug.LogError("字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为字节数组异常：{0}", ex);
|
bytes = null;
|
}
|
|
}
|
|
protected void TransBytes(out ushort[] uShorts, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out uShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out ushort[] uShorts, byte[] vBytes, NetDataType vNetDataType, short vLeng)
|
{
|
TransBytes(out uShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out ushort[] uShorts, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out uShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out ushort[] uShorts, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out uShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out ushort[] uShorts, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
uShorts = new ushort[vLeng];
|
if (vNetDataType == NetDataType.WORD)
|
{
|
if ((_readIndex + ShortLeng) <= vBytes.Length)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
uShorts[i] = BitConverter.ToUInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
}
|
else
|
{
|
Debug.LogError("(line:179) 字节包数据量不足");
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
if ((_readIndex + ByteLeng) <= vBytes.Length)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
uShorts[i] = (ushort)vBytes[_readIndex];
|
_readIndex += ByteLeng;
|
}
|
}
|
else
|
{
|
Debug.LogError("(line:189) 字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为短整型数组异常：{0}", ex);
|
uShorts = null;
|
}
|
|
}
|
|
/** 转换字节段为短整型数组 */
|
protected void TransBytes(out short[] vShorts, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out vShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为短整型数组 */
|
protected void TransBytes(out short[] vShorts, byte[] vBytes, NetDataType vNetDataType, short vLeng)
|
{
|
TransBytes(out vShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out short[] vShorts, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out vShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out short[] vShorts, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out vShorts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为短整型数组 */
|
protected void TransBytes(out short[] vShorts, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
vShorts = new short[vLeng];
|
if (vLeng > 0)
|
{
|
if (vNetDataType == NetDataType.WORD)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
vShorts[i] = (short)BitConverter.ToInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
byte vTheByte;
|
byte[] vTempBytes;
|
for (int i = 0; i < vLeng; i++)
|
{
|
vTheByte = vBytes[i];
|
vTempBytes = new byte[2];
|
vTempBytes[0] = vTheByte;
|
if (vTheByte > 127)
|
vTempBytes[1] = 0xFF;
|
vShorts[i] = BitConverter.ToInt16(vTempBytes, 0);
|
_readIndex += ByteLeng;
|
}
|
}
|
else
|
{
|
DebugEx.LogError("请指定正确的数据源类型");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为短整型数组异常：{0}", ex);
|
vShorts = null;
|
}
|
|
}
|
|
/** 转换字节段为整型数组 */
|
protected void TransBytes(out int[] vInts, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out vInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为整型数组 */
|
protected void TransBytes(out int[] vInts, byte[] vBytes, NetDataType vNetDataType, short vLeng)
|
{
|
TransBytes(out vInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为整型数组 */
|
protected void TransBytes(out int[] vInts, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out vInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为整型数组 */
|
protected void TransBytes(out int[] vInts, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out vInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为整型数组 */
|
protected void TransBytes(out int[] vInts, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
vInts = new int[vLeng];
|
if (vLeng > 0)
|
{
|
if (vNetDataType == NetDataType.DWORD || vNetDataType == NetDataType.Int)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
vInts[i] = (int)BitConverter.ToInt32(vBytes, _readIndex);
|
_readIndex += IntLeng;
|
}
|
}
|
else if (vNetDataType == NetDataType.WORD)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
vInts[i] = (int)BitConverter.ToInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
vInts[i] = (int)vBytes[i];
|
_readIndex += ByteLeng;
|
}
|
}
|
else
|
{
|
DebugEx.LogError("请指定正确的数据源类型");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为整型数组异常：{0}", ex);
|
vInts = null;
|
}
|
|
}
|
|
protected void TransBytes(out uint[] uInts, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out uInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out uint[] uInts, byte[] vBytes, NetDataType vNetDataType, short vLeng)
|
{
|
TransBytes(out uInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out uint[] uInts, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out uInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out uint[] uInts, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out uInts, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
protected void TransBytes(out uint[] uInts, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
uInts = new uint[vLeng];
|
if (vLeng > 0)
|
{
|
if (vNetDataType == NetDataType.DWORD || vNetDataType == NetDataType.Int)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
uInts[i] = (uint)BitConverter.ToUInt32(vBytes, _readIndex);
|
_readIndex += IntLeng;
|
}
|
}
|
else if (vNetDataType == NetDataType.WORD)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
uInts[i] = (uint)BitConverter.ToUInt16(vBytes, _readIndex);
|
_readIndex += ShortLeng;
|
}
|
}
|
else if (vNetDataType == NetDataType.BYTE)
|
{
|
for (int i = 0; i < vLeng; i++)
|
{
|
uInts[i] = (uint)vBytes[i];
|
_readIndex += ByteLeng;
|
}
|
}
|
else
|
{
|
DebugEx.LogError("请指定正确的数据源类型");
|
}
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为无符号整型数组异常：{0}", ex);
|
uInts = null;
|
}
|
|
}
|
|
/** 转换字节段为Double型数据 */
|
protected void TransBytes(out double vDouble, byte[] vBytes, NetDataType vNetDataType)
|
{
|
try
|
{
|
vDouble = 0;
|
if (vNetDataType == NetDataType.Double)
|
{
|
if ((_readIndex + DoubleLeng) <= vBytes.Length)
|
{
|
vDouble = BitConverter.ToDouble(vBytes, _readIndex);
|
_readIndex += DoubleLeng;
|
}
|
else
|
{
|
Debug.LogError("(line:341) 字节包数据量不足");
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为Double型数据异常：{0}", ex);
|
vDouble = 0;
|
}
|
|
}
|
|
protected void TransBytes(out string vStr, byte[] vBytes, NetDataType vNetDataType, byte vLeng)
|
{
|
TransBytes(out vStr, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为字符串 */
|
protected void TransBytes(out string vStr, byte[] vBytes, NetDataType vNetDataType, ushort vLeng)
|
{
|
TransBytes(out vStr, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为字符串 */
|
protected void TransBytes(out string vStr, byte[] vBytes, NetDataType vNetDataType, uint vLeng)
|
{
|
TransBytes(out vStr, vBytes, vNetDataType, (int)vLeng);
|
}
|
|
/** 转换字节段为字符串 */
|
protected void TransBytes(out string vStr, byte[] vBytes, NetDataType vNetDataType, int vLeng)
|
{
|
try
|
{
|
vStr = "";
|
if (vLeng == 0)
|
return;
|
if (vNetDataType == NetDataType.Chars)
|
{
|
if ((_readIndex + vLeng) <= vBytes.Length)
|
{
|
vStr = StrEncoding.GetString(vBytes, _readIndex, vLeng);
|
_readIndex += vLeng;
|
}
|
else
|
{
|
Debug.LogErrorFormat("(line:365) 字节包数据量不足: _readIndex {0}, vLeng {1}, vBytes.Length {2}", _readIndex, vLeng, vBytes.Length);
|
}
|
}
|
else
|
{
|
Debug.LogError("请指定正确的数据源类型");
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogFormat("转换字节段为字符串异常：{0}", ex);
|
vStr = string.Empty;
|
}
|
|
}
|
|
/** 转换布尔值为字节 */
|
protected void WriteBytes(bool vTof, NetDataType vType)
|
{
|
this.WriteBytes(BitConverter.GetBytes(vTof));
|
}
|
|
/** 转换短整型为字节 */
|
protected void WriteBytes(short vShort, NetDataType vType)
|
{
|
this.WriteBytes((int)vShort, vType);
|
}
|
|
/** 以固定的字节长度转短整型数值数组为字节 */
|
protected void WriteBytes(short[] vShorts, NetDataType vType, int vLockLeng)
|
{
|
this.WriteBytes(ShortsToInts(vShorts), vType, vLockLeng);
|
}
|
|
/** 以固定的字节长度转短整型数值数组为字节 */
|
protected void WriteBytes(ushort[] uShorts, NetDataType vType, int vLockLeng)
|
{
|
this.WriteBytes(UShortsToInts(uShorts), vType, vLockLeng);
|
}
|
|
/** 以固定的字节长度转字节数组为字节 */
|
protected void WriteBytes(byte[] bytes, NetDataType vType, int vLockLeng)
|
{
|
this.WriteBytes(BytesToInts(bytes), vType, vLockLeng);
|
}
|
|
/** 转短整型数值数组为字节 */
|
protected void WriteBytes(short[] vShorts, NetDataType vType, StrWriteLen vWriteLen)
|
{
|
this.WriteBytes(ShortsToInts(vShorts), vType, vWriteLen);
|
}
|
|
/** 无符号短整数组转整型数组 */
|
private int[] UShortsToInts(ushort[] uShorts)
|
{
|
try
|
{
|
int l = uShorts.Length;
|
int[] vInts = new int[l];
|
int i;
|
for (i = 0; i < l; i++)
|
vInts[i] = (int)uShorts[i];
|
return vInts;
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
return null;
|
}
|
}
|
|
/** 短整数组转整型数组 */
|
private int[] ShortsToInts(short[] vShorts)
|
{
|
try
|
{
|
int l = vShorts.Length;
|
int[] vInts = new int[l];
|
int i;
|
for (i = 0; i < l; i++)
|
vInts[i] = (int)vShorts[i];
|
return vInts;
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
return null;
|
}
|
}
|
|
/** 字节数组转整型数组 */
|
private int[] BytesToInts(byte[] bytes)
|
{
|
try
|
{
|
if (bytes != null)
|
{
|
int l = bytes.Length;
|
int[] vInts = new int[l];
|
int i;
|
for (i = 0; i < l; i++)
|
vInts[i] = (int)bytes[i];
|
return vInts;
|
}
|
else
|
{
|
int[] vInts = new int[0];
|
return vInts;
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
return null;
|
}
|
}
|
|
/** 转换整型为字节 */
|
protected void WriteBytes(int vInt, NetDataType vType)
|
{
|
try
|
{
|
byte[] vRst;
|
if (vType == NetDataType.WORD)
|
vRst = BitConverter.GetBytes((short)vInt);
|
else if (vType == NetDataType.BYTE)
|
{
|
vRst = new byte[1];
|
vRst[0] = (byte)(vInt & 0xFF); // BitConverter.GetBytes ((byte)vInt);
|
}
|
else
|
vRst = BitConverter.GetBytes((int)vInt);
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
}
|
|
protected void WriteBytes(uint[] vInts, NetDataType vType, int vLockLeng)
|
{
|
try
|
{
|
if (vInts.Length != vLockLeng)
|
Array.Resize(ref vInts, vLockLeng);
|
this.WriteBytes(vInts, vType);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
|
}
|
|
/** 约束数组长度并转为字节段，不写入长度 */
|
protected void WriteBytes(int[] vInts, NetDataType vType, int vLockLeng)
|
{
|
try
|
{
|
if (vInts.Length != vLockLeng)
|
Array.Resize(ref vInts, vLockLeng);
|
this.WriteBytes(vInts, vType);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
}
|
|
/** 整型数组转为字节段，以指定的数据类型写入长度 */
|
protected void WriteBytes(int[] vInts, NetDataType vType, StrWriteLen vWriteLen)
|
{
|
try
|
{
|
if (vWriteLen == StrWriteLen.BYTE)
|
this.WriteBytes(new Byte[] { (byte)vInts.Length });
|
else if (vWriteLen == StrWriteLen.WORD)
|
this.WriteBytes(BitConverter.GetBytes((short)vInts.Length));
|
else
|
this.WriteBytes(BitConverter.GetBytes((int)vInts.Length));
|
this.WriteBytes(vInts, vType);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
}
|
|
/** 转整型数值数组为字节 */
|
private void WriteBytes(uint[] vInts, NetDataType vType)
|
{
|
try
|
{
|
int l = vInts.Length;
|
byte[] vRst;
|
int i;
|
int vBytesLen;
|
if (vType == NetDataType.BYTE)
|
{
|
vBytesLen = l;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((byte)vInts[i]), 0, vRst, i, 1);
|
}
|
else if (vType == NetDataType.WORD)
|
{
|
vBytesLen = l * 2;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((short)vInts[i]), 0, vRst, i * 2, 2);
|
}
|
else
|
{
|
vBytesLen = l * 4;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((int)vInts[i]), 0, vRst, i * 4, 4);
|
}
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
|
}
|
|
/** 转整型数值数组为字节 */
|
private void WriteBytes(int[] vInts, NetDataType vType)
|
{
|
try
|
{
|
int l = vInts.Length;
|
byte[] vRst;
|
int i;
|
int vBytesLen;
|
if (vType == NetDataType.BYTE)
|
{
|
vBytesLen = l;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((byte)vInts[i]), 0, vRst, i, 1);
|
}
|
else if (vType == NetDataType.WORD)
|
{
|
vBytesLen = l * 2;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((short)vInts[i]), 0, vRst, i * 2, 2);
|
}
|
else
|
{
|
vBytesLen = l * 4;
|
vRst = new byte[vBytesLen];
|
for (i = 0; i < l; i++)
|
Array.Copy(BitConverter.GetBytes((int)vInts[i]), 0, vRst, i * 4, 4);
|
}
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
|
}
|
|
/** 转换双精度数值为字节段 */
|
protected void WriteBytes(uint vuint, NetDataType vType)
|
{
|
try
|
{
|
byte[] vRst;
|
vRst = BitConverter.GetBytes(vuint);
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
}
|
|
/** 转换字符串为字节段，byte量定长型，不写入长度 */
|
protected void WriteBytes(string vStr, NetDataType vType, int vShortLen)
|
{
|
if (vStr == null)
|
{
|
vStr = string.Empty;
|
}
|
try
|
{
|
byte[] vRst = StrEncoding.GetBytes(vStr);
|
if (vRst.Length != vShortLen)
|
Array.Resize(ref vRst, vShortLen);
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
|
}
|
|
/** 转换字符串为字节段，动长型,前置写入长度 */
|
protected void WriteBytes(string vStr, NetDataType vType, StrWriteLen vWriteLen)
|
{
|
try
|
{
|
byte[] vRst = StrEncoding.GetBytes(vStr);
|
if (vWriteLen == StrWriteLen.BYTE)
|
this.WriteBytes(new Byte[] { (byte)vRst.Length });
|
else if (vWriteLen == StrWriteLen.WORD)
|
this.WriteBytes(BitConverter.GetBytes((short)vRst.Length));
|
else
|
this.WriteBytes(BitConverter.GetBytes((int)vRst.Length));
|
this.WriteBytes(vRst);
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
|
}
|
|
/** 写入一段字节数据 */
|
private void WriteBytes(byte[] vBytes)
|
{
|
try
|
{
|
Array.Resize(ref _writedBytes, _writeIndex + vBytes.Length);
|
vBytes.CopyTo(_writedBytes, _writeIndex);
|
_writeIndex = _writedBytes.Length;
|
}
|
catch (Exception ex)
|
{
|
Debug.Log(ex);
|
}
|
}
|
|
}
|
