/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.type = stream.readInt();
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesFull(stream);
if (stream.readBoolean())
{
this.realMoveDir = (DirData)stream.createData(DirData.dataID);
this.realMoveDir.readBytesFull(stream);
}
else
{
this.realMoveDir = null;
}
this.realMoveSpeedRatio = stream.readInt();
stream.endReadObj();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
this.type = stream.readInt();
this.targetInstanceID = stream.readInt();
if (stream.readBoolean())
{
this.pos = (PosData)stream.createData(PosData.dataID);
this.pos.readBytesSimple(stream);
}
else
{
this.pos = null;
}
if (stream.readBoolean())
{
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesSimple(stream);
}
else
{
this.dir = null;
}
this.arg = stream.readInt();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
this.pos = (PosData)stream.createData(PosData.dataID);
this.pos.readBytesSimple(stream);
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesSimple(stream);
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
this.level = stream.readShort();
int attributesLen = stream.readLen();
if (this.attributes == null || this.attributes.Length != attributesLen)
{
this.attributes = new DIntData[attributesLen];
}
DIntData[] attributesT = this.attributes;
for (int attributesI = 0; attributesI < attributesLen; ++attributesI)
{
DIntData attributesV;
attributesV = (DIntData)stream.createData(DIntData.dataID);
attributesV.readBytesSimple(stream);
attributesT[attributesI] = attributesV;
}
int skillsLen = stream.readLen();
if (this.skills == null || this.skills.Length != skillsLen)
{
this.skills = new DIntData[skillsLen];
}
DIntData[] skillsT = this.skills;
for (int skillsI = 0; skillsI < skillsLen; ++skillsI)
{
DIntData skillsV;
skillsV = (DIntData)stream.createData(DIntData.dataID);
skillsV.readBytesSimple(stream);
skillsT[skillsI] = skillsV;
}
int buffsLen = stream.readLen();
if (this.buffs == null || this.buffs.Length != buffsLen)
{
this.buffs = new DIntData[buffsLen];
}
DIntData[] buffsT = this.buffs;
for (int buffsI = 0; buffsI < buffsLen; ++buffsI)
{
DIntData buffsV;
buffsV = (DIntData)stream.createData(DIntData.dataID);
buffsV.readBytesSimple(stream);
buffsT[buffsI] = buffsV;
}
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
stream.startReadObj();
this.pos = (PosData)stream.createData(PosData.dataID);
this.pos.readBytesFull(stream);
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesFull(stream);
stream.endReadObj();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.instanceID = stream.readInt();
this.pos = (PosData)stream.createData(PosData.dataID);
this.pos.readBytesSimple(stream);
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesSimple(stream);
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.clientVersion = (ClientVersionData)stream.createData(ClientVersionData.dataID);
this.clientVersion.readBytesSimple(stream);
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
this.modelID = stream.readInt();
int partsLen = stream.readLen();
if (this.parts == null || this.parts.Length != partsLen)
{
this.parts = new DIntData[partsLen];
}
DIntData[] partsT = this.parts;
for (int partsI = 0; partsI < partsLen; ++partsI)
{
DIntData partsV;
partsV = (DIntData)stream.createData(DIntData.dataID);
partsV.readBytesSimple(stream);
partsT[partsI] = partsV;
}
this.proirity = stream.readInt();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
this.instanceID = stream.readInt();
this.isHit = stream.readBoolean();
this.isCrit = stream.readBoolean();
int damagesLen = stream.readLen();
if (this.damages != null)
{
this.damages.clear();
this.damages.ensureCapacity(damagesLen);
}
else
{
this.damages = new SList <DIntData>();
}
SList <DIntData> damagesT = this.damages;
for (int damagesI = damagesLen - 1; damagesI >= 0; --damagesI)
{
DIntData damagesV;
damagesV = (DIntData)stream.createData(DIntData.dataID);
damagesV.readBytesSimple(stream);
damagesT.add(damagesV);
}
this.isKilled = stream.readBoolean();
this.arg = stream.readInt();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
this.itemID = stream.readInt();
this.isBind = stream.readBoolean();
int dintArgsLen = stream.readLen();
if (this.dintArgs == null || this.dintArgs.Length != dintArgsLen)
{
this.dintArgs = new DIntData[dintArgsLen];
}
DIntData[] dintArgsT = this.dintArgs;
for (int dintArgsI = 0; dintArgsI < dintArgsLen; ++dintArgsI)
{
DIntData dintArgsV;
dintArgsV = (DIntData)stream.createData(DIntData.dataID);
dintArgsV.readBytesSimple(stream);
dintArgsT[dintArgsI] = dintArgsV;
}
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
int cdsLen = stream.readLen();
if (this.cds != null)
{
this.cds.clear();
this.cds.ensureCapacity(cdsLen);
}
else
{
this.cds = new SList <CDData>();
}
SList <CDData> cdsT = this.cds;
for (int cdsI = cdsLen - 1; cdsI >= 0; --cdsI)
{
CDData cdsV;
cdsV = (CDData)stream.createData(CDData.dataID);
cdsV.readBytesSimple(stream);
cdsT.add(cdsV);
}
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.type = stream.readInt();
int targetsLen = stream.readLen();
if (this.targets != null)
{
this.targets.clear();
this.targets.ensureCapacity(targetsLen);
}
else
{
this.targets = new SList <PosData>();
}
SList <PosData> targetsT = this.targets;
for (int targetsI = targetsLen - 1; targetsI >= 0; --targetsI)
{
PosData targetsV;
targetsV = (PosData)stream.createData(PosData.dataID);
targetsV.readBytesSimple(stream);
targetsT.add(targetsV);
}
this.moveTime = stream.readInt();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
this.loginInfo = (ClientLoginServerInfoData)stream.readDataSimpleNotNull();
if (stream.readBoolean())
{
this.version = (ClientVersionData)stream.createData(ClientVersionData.dataID);
this.version.readBytesSimple(stream);
}
else
{
this.version = null;
}
if (stream.readBoolean())
{
int areasLen = stream.readLen();
if (this.areas != null)
{
this.areas.clear();
this.areas.ensureCapacity(areasLen);
}
else
{
this.areas = new IntObjectMap <AreaClientData>(areasLen);
}
IntObjectMap <AreaClientData> areasT = this.areas;
for (int areasI = areasLen - 1; areasI >= 0; --areasI)
{
AreaClientData areasV;
if (stream.readBoolean())
{
areasV = (AreaClientData)stream.readDataSimpleNotNull();
}
else
{
areasV = null;
}
areasT.put(areasV.areaID, areasV);
}
}
else
{
this.areas = null;
}
this.lastAreaID = stream.readInt();
if (stream.readBoolean())
{
this.gameInfo = (ClientLoginServerInfoData)stream.readDataSimpleNotNull();
}
else
{
this.gameInfo = null;
}
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.id = stream.readInt();
this.posDir = (PosDirData)stream.createData(PosDirData.dataID);
this.posDir.readBytesFull(stream);
if (stream.readBoolean())
{
int argsLen = stream.readLen();
if (this.args == null || this.args.Length != argsLen)
{
this.args = new int[argsLen];
}
int[] argsT = this.args;
for (int argsI = 0; argsI < argsLen; ++argsI)
{
int argsV;
argsV = stream.readInt();
argsT[argsI] = argsV;
}
}
else
{
this.args = null;
}
this.specialMoveLastTime = stream.readInt();
if (stream.readBoolean())
{
this.baseMovePos = (PosData)stream.createData(PosData.dataID);
this.baseMovePos.readBytesFull(stream);
}
else
{
this.baseMovePos = null;
}
stream.endReadObj();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
stream.startReadObj();
this.keep = (KeepSaveData)stream.createData(KeepSaveData.dataID);
this.keep.readBytesFull(stream);
stream.endReadObj();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.clientVersion = (ClientVersionData)stream.createData(ClientVersionData.dataID);
this.clientVersion.readBytesFull(stream);
stream.endReadObj();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.type = stream.readInt();
this.targetPos = (PosData)stream.createData(PosData.dataID);
this.targetPos.readBytesSimple(stream);
this.moveTime = stream.readInt();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.skillID = stream.readInt();
this.skillLevel = stream.readInt();
this.targetData = (SkillTargetData)stream.readDataSimpleNotNull();
this.posDir = (PosDirData)stream.createData(PosDirData.dataID);
this.posDir.readBytesSimple(stream);
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
int currencyLen = stream.readLen();
if (this.currency == null || this.currency.Length != currencyLen)
{
this.currency = new DIntData[currencyLen];
}
DIntData[] currencyT = this.currency;
for (int currencyI = 0; currencyI < currencyLen; ++currencyI)
{
DIntData currencyV;
currencyV = (DIntData)stream.createData(DIntData.dataID);
currencyV.readBytesSimple(stream);
currencyT[currencyI] = currencyV;
}
int itemsLen = stream.readLen();
if (this.items == null || this.items.Length != itemsLen)
{
this.items = new DIntData[itemsLen];
}
DIntData[] itemsT = this.items;
for (int itemsI = 0; itemsI < itemsLen; ++itemsI)
{
DIntData itemsV;
itemsV = (DIntData)stream.createData(DIntData.dataID);
itemsV.readBytesSimple(stream);
itemsT[itemsI] = itemsV;
}
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
if (stream.readBoolean())
{
this.dir = (DirData)stream.createData(DirData.dataID);
this.dir.readBytesSimple(stream);
}
else
{
this.dir = null;
}
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
this.type = stream.readInt();
int argsLen = stream.readLen();
if (this.args == null || this.args.Length != argsLen)
{
this.args = new int[argsLen][];
}
int[][] argsT = this.args;
for (int argsI = 0; argsI < argsLen; ++argsI)
{
int[] argsV;
int argsVLen = stream.readLen();
argsV = new int[argsVLen];
int[] argsVT = argsV;
for (int argsVI = 0; argsVI < argsVLen; ++argsVI)
{
int argsVV;
argsVV = stream.readInt();
argsVT[argsVI] = argsVV;
}
argsT[argsI] = argsV;
}
this.seedType = stream.readInt();
int showItemsLen = stream.readLen();
if (this.showItems == null || this.showItems.Length != showItemsLen)
{
this.showItems = new DIntData[showItemsLen];
}
DIntData[] showItemsT = this.showItems;
for (int showItemsI = 0; showItemsI < showItemsLen; ++showItemsI)
{
DIntData showItemsV;
showItemsV = (DIntData)stream.createData(DIntData.dataID);
showItemsV.readBytesSimple(stream);
showItemsT[showItemsI] = showItemsV;
}
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
if (stream.readBoolean())
{
this.version = (ClientVersionData)stream.createData(ClientVersionData.dataID);
this.version.readBytesSimple(stream);
}
else
{
this.version = null;
}
this.redirectURL = stream.readUTF();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
this.level = stream.readShort();
int bringCDsLen = stream.readLen();
if (this.bringCDs == null || this.bringCDs.Length != bringCDsLen)
{
this.bringCDs = new int[bringCDsLen];
}
int[] bringCDsT = this.bringCDs;
for (int bringCDsI = 0; bringCDsI < bringCDsLen; ++bringCDsI)
{
int bringCDsV;
bringCDsV = stream.readInt();
bringCDsT[bringCDsI] = bringCDsV;
}
int costLen = stream.readLen();
if (this.cost == null || this.cost.Length != costLen)
{
this.cost = new DIntData[costLen];
}
DIntData[] costT = this.cost;
for (int costI = 0; costI < costLen; ++costI)
{
DIntData costV;
costV = (DIntData)stream.createData(DIntData.dataID);
costV.readBytesSimple(stream);
costT[costI] = costV;
}
this.useDistance = stream.readFloat();
this.useDistanceVar = stream.readInt();
this.singBarID = stream.readInt();
this.lastTime = stream.readInt();
this.explain = stream.readUTF();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.type = stream.readInt();
this.targetPos = (PosData)stream.createData(PosData.dataID);
this.targetPos.readBytesFull(stream);
this.moveTime = stream.readInt();
stream.endReadObj();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
if (stream.readBoolean())
{
this.nowPos = (PosDirData)stream.createData(PosDirData.dataID);
this.nowPos.readBytesSimple(stream);
}
else
{
this.nowPos = null;
}
this.data = (DriveData)stream.readDataSimpleNotNull();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
if (stream.readBoolean())
{
this.shootDir = (DirData)stream.createData(DirData.dataID);
this.shootDir.readBytesFull(stream);
}
else
{
this.shootDir = null;
}
stream.endReadObj();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
stream.startReadObj();
if (stream.readBoolean())
{
this.version = (ClientVersionData)stream.createData(ClientVersionData.dataID);
this.version.readBytesFull(stream);
}
else
{
this.version = null;
}
this.redirectURL = stream.readUTF();
stream.endReadObj();
}
/// <summary>
/// 读取字节流(简版)
/// </summary>
protected override void toReadBytesSimple(BytesReadStream stream)
{
base.toReadBytesSimple(stream);
this.id = stream.readInt();
int showPartsLen = stream.readLen();
if (this.showParts == null || this.showParts.Length != showPartsLen)
{
this.showParts = new DIntData[showPartsLen];
}
DIntData[] showPartsT = this.showParts;
for (int showPartsI = 0; showPartsI < showPartsLen; ++showPartsI)
{
DIntData showPartsV;
showPartsV = (DIntData)stream.createData(DIntData.dataID);
showPartsV.readBytesSimple(stream);
showPartsT[showPartsI] = showPartsV;
}
this.source = stream.readUTF();
this.collideRadius = stream.readFloat();
int defaultHitRectLen = stream.readLen();
if (this.defaultHitRect == null || this.defaultHitRect.Length != defaultHitRectLen)
{
this.defaultHitRect = new float[defaultHitRectLen];
}
float[] defaultHitRectT = this.defaultHitRect;
for (int defaultHitRectI = 0; defaultHitRectI < defaultHitRectLen; ++defaultHitRectI)
{
float defaultHitRectV;
defaultHitRectV = stream.readFloat();
defaultHitRectT[defaultHitRectI] = defaultHitRectV;
}
this.height = stream.readFloat();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
this.posDir = (PosDirData)stream.createData(PosDirData.dataID);
this.posDir.readBytesFull(stream);
this.type = stream.readInt();
int intsLen = stream.readLen();
if (this.ints == null || this.ints.Length != intsLen)
{
this.ints = new int[intsLen];
}
int[] intsT = this.ints;
for (int intsI = 0; intsI < intsLen; ++intsI)
{
int intsV;
intsV = stream.readInt();
intsT[intsI] = intsV;
}
int floatsLen = stream.readLen();
if (this.floats == null || this.floats.Length != floatsLen)
{
this.floats = new float[floatsLen];
}
float[] floatsT = this.floats;
for (int floatsI = 0; floatsI < floatsLen; ++floatsI)
{
float floatsV;
floatsV = stream.readFloat();
floatsT[floatsI] = floatsV;
}
stream.endReadObj();
}
/// <summary>
/// 读取字节流(完整版)
/// </summary>
protected override void toReadBytesFull(BytesReadStream stream)
{
base.toReadBytesFull(stream);
stream.startReadObj();
if (stream.readBoolean())
{
this.nowPos = (PosDirData)stream.createData(PosDirData.dataID);
this.nowPos.readBytesFull(stream);
}
else
{
this.nowPos = null;
}
BaseData dataT = stream.readDataFullNotNull();
if (dataT != null)
{
if (dataT is DriveData)
{
this.data = (DriveData)dataT;
}
else
{
this.data = new DriveData();
if (!(dataT.GetType().IsAssignableFrom(typeof(DriveData))))
{
stream.throwTypeReadError(typeof(DriveData), dataT.GetType());
}
this.data.shadowCopy(dataT);
}
}
else
{
this.data = null;
}
stream.endReadObj();
}