protected override void toWriteBytesFull(BytesWriteStream stream)
{
if (!_g2)
{
_m2 = instance.Type.GetMethod("toWriteBytesFull", 1);
_g2 = true;
}
if (_m2 != null && !_b2)
{
_b2 = true;
_p1[0] = stream;
appdomain.Invoke(_m2, instance, _p1);
_p1[0] = null;
_b2 = false;
}
else
{
base.toWriteBytesFull(stream);
}
}
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (!_g4)
{
_m4 = instance.Type.GetMethod("toWriteBytesSimple", 1);
_g4 = true;
}
if (_m4 != null && !_b4)
{
_b4 = true;
_p1[0] = stream;
appdomain.Invoke(_m4, instance, _p1);
_p1[0] = null;
_b4 = false;
}
else
{
base.toWriteBytesSimple(stream);
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
stream.writeInt(this.bulletID);
stream.writeInt(this.bulletLevel);
if (this.target != null)
{
stream.writeDataFullNotNull(this.target);
}
else
{
nullObjError("target");
}
stream.endWriteObj();
}
protected override void doWriteBytesSimple(BytesWriteStream stream)
{
if (!_g7)
{
_m7 = instance.Type.GetMethod("doWriteBytesSimple", 1);
_g7 = true;
}
if (_m7 != null && !_b7)
{
_b7 = true;
_p1[0] = stream;
appdomain.Invoke(_m7, instance, _p1);
_p1[0] = null;
_b7 = false;
}
else
{
base.doWriteBytesSimple(stream);
}
}
protected override void doWriteToStream(BytesWriteStream stream)
{
if (!_g6)
{
_m6 = instance.Type.GetMethod("doWriteToStream", 1);
_g6 = true;
}
if (_m6 != null && !_b6)
{
_b6 = true;
_p1[0] = stream;
appdomain.Invoke(_m6, instance, _p1);
_p1[0] = null;
_b6 = false;
}
else
{
base.doWriteToStream(stream);
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
if (this.data != null)
{
stream.writeDataFullNotNull(this.data);
}
else
{
nullObjError("data");
}
stream.writeLong(this.time);
stream.writeInt(this.result);
stream.writeLong(this.disableTime);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.index);
stream.writeInt(this.type);
if (this.ints != null)
{
int[] intsT = this.ints;
stream.writeLen(intsT.Length);
for (int intsVI = 0, intsVLen = intsT.Length; intsVI < intsVLen; ++intsVI)
{
int intsV = intsT[intsVI];
stream.writeInt(intsV);
}
}
else
{
nullObjError("ints");
}
if (this.floats != null)
{
float[] floatsT = this.floats;
stream.writeLen(floatsT.Length);
for (int floatsVI = 0, floatsVLen = floatsT.Length; floatsVI < floatsVLen; ++floatsVI)
{
float floatsV = floatsT[floatsVI];
stream.writeFloat(floatsV);
}
}
else
{
nullObjError("floats");
}
stream.endWriteObj();
}
/** 写入流 */
public void write(BytesWriteStream stream)
{
stream.writeInt(originX);
stream.writeInt(originZ);
stream.writeInt(sizeX);
stream.writeInt(sizeZ);
stream.writeFloat(tileSize);
stream.writeVector3(min);
stream.writeVector3(max);
if (terrain != null)
{
stream.writeBoolean(true);
terrain.write(stream);
}
else
{
stream.writeBoolean(false);
}
int len = meshList.size();
SceneRecastMeshData[] values = meshList.getValues();
stream.writeLen(len);
for (int i = 0; i < len; i++)
{
values[i].write(stream);
}
len = objList.size();
SceneRecastObjData[] values2 = objList.getValues();
stream.writeLen(len);
for (int i = 0; i < len; i++)
{
values2[i].write(stream);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.id);
if (this.args != null)
{
stream.writeBoolean(true);
string[] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
string argsV = argsT[argsVI];
stream.writeUTF(argsV);
}
}
else
{
stream.writeBoolean(false);
}
stream.writeLong(this.logTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.id);
stream.writeInt(this.num);
stream.writeBoolean(this.isBind);
stream.writeLong(this.disableTime);
if (this.identity != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.identity);
}
else
{
stream.writeBoolean(false);
}
stream.writeBoolean(this.hasRedPoint);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeUTF(this.name);
stream.writeInt(this.attackID);
stream.writeFloat(this.maxEnableDistance);
stream.writeBoolean(this.needRecordValue);
stream.writeBoolean(this.keepAtMaxHit);
stream.writeBoolean(this.cantAbsorb);
stream.writeInt(this.hitDelay);
if (this.castOff != null)
{
float[] castOffT = this.castOff;
stream.writeLen(castOffT.Length);
for (int castOffVI = 0, castOffVLen = castOffT.Length; castOffVI < castOffVLen; ++castOffVI)
{
float castOffV = castOffT[castOffVI];
stream.writeFloat(castOffV);
}
}
else
{
nullObjError("castOff");
}
stream.writeInt(this.castPoint);
stream.writeInt(this.effectID);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.dic != null)
{
stream.writeLen(this.dic.size());
if (!this.dic.isEmpty())
{
long dicKFreeValue = this.dic.getFreeValue();
long[] dicKKeys = this.dic.getKeys();
RoleSocialPoolData[] dicVValues = this.dic.getValues();
for (int dicKI = dicKKeys.Length - 1; dicKI >= 0; --dicKI)
{
long dicK = dicKKeys[dicKI];
if (dicK != dicKFreeValue)
{
RoleSocialPoolData dicV = dicVValues[dicKI];
stream.writeLong(dicK);
if (dicV != null)
{
stream.writeDataSimpleNotNull(dicV);
}
else
{
nullObjError("dicV");
}
}
}
}
}
else
{
nullObjError("dic");
}
stream.writeLong(this.nextCutTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.drivers != null)
{
stream.writeLen(this.drivers.size());
if (!this.drivers.isEmpty())
{
int[] driversVValues = this.drivers.getValues();
for (int driversVI = 0, driversVLen = this.drivers.length(); driversVI < driversVLen; ++driversVI)
{
int driversV = driversVValues[driversVI];
stream.writeInt(driversV);
}
}
}
else
{
nullObjError("drivers");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeUTF(this.name);
stream.writeUTF(this.showName);
if (this.formula != null)
{
int[] formulaT = this.formula;
stream.writeLen(formulaT.Length);
for (int formulaVI = 0, formulaVLen = formulaT.Length; formulaVI < formulaVLen; ++formulaVI)
{
int formulaV = formulaT[formulaVI];
stream.writeInt(formulaV);
}
}
else
{
nullObjError("formula");
}
stream.writeBoolean(this.isPercent);
stream.writeInt(this.increaseID);
stream.writeInt(this.currentMaxID);
stream.writeBoolean(this.isCurrentDefaultFull);
stream.writeBoolean(this.canOverMax);
stream.writeInt(this.sendSelfType);
stream.writeBoolean(this.isSimpleUnitNeed);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeUTF(this.name);
stream.writeInt(this.num);
stream.writeBoolean(this.canChangeName);
stream.writeBoolean(this.canChangeNotice);
stream.writeBoolean(this.canHandleApply);
stream.writeInt(this.canSetTitle);
stream.writeInt(this.canKickTitle);
stream.writeBoolean(this.canChangeApplyInAbs);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.type);
if (this.args != null)
{
stream.writeBoolean(true);
int[] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
int argsV = argsT[argsVI];
stream.writeInt(argsV);
}
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.motionID);
stream.writeInt(this.motionTime);
if (this.bindPoints != null)
{
float[][] bindPointsT = this.bindPoints;
stream.writeLen(bindPointsT.Length);
for (int bindPointsVI = 0, bindPointsVLen = bindPointsT.Length; bindPointsVI < bindPointsVLen; ++bindPointsVI)
{
float[] bindPointsV = bindPointsT[bindPointsVI];
if (bindPointsV != null)
{
float[] bindPointsVT = bindPointsV;
stream.writeLen(bindPointsVT.Length);
for (int bindPointsVVI = 0, bindPointsVVLen = bindPointsVT.Length; bindPointsVVI < bindPointsVVLen; ++bindPointsVVI)
{
float bindPointsVV = bindPointsVT[bindPointsVVI];
stream.writeFloat(bindPointsVV);
}
}
else
{
nullObjError("bindPointsV");
}
}
}
else
{
nullObjError("bindPoints");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeByte(this.step);
stream.writeShort(this.level);
if (this.frameActions != null)
{
int[][] frameActionsT = this.frameActions;
stream.writeLen(frameActionsT.Length);
for (int frameActionsVI = 0, frameActionsVLen = frameActionsT.Length; frameActionsVI < frameActionsVLen; ++frameActionsVI)
{
int[] frameActionsV = frameActionsT[frameActionsVI];
if (frameActionsV != null)
{
int[] frameActionsVT = frameActionsV;
stream.writeLen(frameActionsVT.Length);
for (int frameActionsVVI = 0, frameActionsVVLen = frameActionsVT.Length; frameActionsVVI < frameActionsVVLen; ++frameActionsVVI)
{
int frameActionsVV = frameActionsVT[frameActionsVVI];
stream.writeInt(frameActionsVV);
}
}
else
{
nullObjError("frameActionsV");
}
}
}
else
{
nullObjError("frameActions");
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeLong(this.groupID);
stream.writeLong(this.exp);
if (this.members != null)
{
stream.writeLen(this.members.size());
if (!this.members.isEmpty())
{
PlayerRoleGroupMemberData[] membersVValues = this.members.getValues();
for (int membersVI = membersVValues.Length - 1; membersVI >= 0; --membersVI)
{
PlayerRoleGroupMemberData membersV = membersVValues[membersVI];
if (membersV != null)
{
if (membersV != null)
{
stream.writeDataFullNotNull(membersV);
}
else
{
nullObjError("membersV");
}
}
}
}
}
else
{
nullObjError("members");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
if (this.allowMoveType != null)
{
int[] allowMoveTypeT = this.allowMoveType;
stream.writeLen(allowMoveTypeT.Length);
for (int allowMoveTypeVI = 0, allowMoveTypeVLen = allowMoveTypeT.Length; allowMoveTypeVI < allowMoveTypeVLen; ++allowMoveTypeVI)
{
int allowMoveTypeV = allowMoveTypeT[allowMoveTypeVI];
stream.writeInt(allowMoveTypeV);
}
}
else
{
nullObjError("allowMoveType");
}
stream.writeFloat(this.groundFriction);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.nowPos != null)
{
stream.writeBoolean(true);
this.nowPos.writeBytesSimple(stream);
}
else
{
stream.writeBoolean(false);
}
if (this.data != null)
{
stream.writeDataSimpleNotNull(this.data);
}
else
{
nullObjError("data");
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
if (this.data != null)
{
stream.writeDataFullNotNull(this.data);
}
else
{
nullObjError("data");
}
stream.writeLong(this.userID);
stream.writeUTF(this.ip);
stream.writeBoolean(this.isAdult);
stream.writeInt(this.areaID);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeLong(this.instanceID);
stream.writeLong(this.playerID);
if (this.data != null)
{
stream.writeDataFullNotNull(this.data);
}
else
{
nullObjError("data");
}
stream.writeLong(this.sellTime);
stream.writeInt(this.price);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.inviter != null)
{
stream.writeDataSimpleNotNull(this.inviter);
}
else
{
nullObjError("inviter");
}
if (this.simpleData != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.simpleData);
}
else
{
stream.writeBoolean(false);
}
stream.writeLong(this.time);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.type);
stream.writeUTF(this.text);
if (this.elements != null)
{
stream.writeBoolean(true);
stream.writeLen(this.elements.size());
if (!this.elements.isEmpty())
{
ChatElementData[] elementsVValues = this.elements.getValues();
for (int elementsVI = 0, elementsVLen = this.elements.length(); elementsVI < elementsVLen; ++elementsVI)
{
ChatElementData elementsV = elementsVValues[elementsVI];
if (elementsV != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(elementsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.id);
stream.writeInt(this.price);
if (this.days != null)
{
stream.writeLen(this.days.size());
if (!this.days.isEmpty())
{
CountData[] daysVValues = this.days.getValues();
int daysVMark = this.days.getMark();
int daysVStart = this.days.getStart();
for (int daysVI = 0, daysVLen = this.days.length(); daysVI < daysVLen; ++daysVI)
{
CountData daysV = daysVValues[(daysVI + daysVStart) & daysVMark];
if (daysV != null)
{
stream.writeDataFullNotNull(daysV);
}
else
{
nullObjError("daysV");
}
}
}
}
else
{
nullObjError("days");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.roleGroupSimpleDataDic != null)
{
stream.writeLen(this.roleGroupSimpleDataDic.size());
if (!this.roleGroupSimpleDataDic.isEmpty())
{
long roleGroupSimpleDataDicKFreeValue = this.roleGroupSimpleDataDic.getFreeValue();
long[] roleGroupSimpleDataDicKKeys = this.roleGroupSimpleDataDic.getKeys();
RoleGroupSimpleData[] roleGroupSimpleDataDicVValues = this.roleGroupSimpleDataDic.getValues();
for (int roleGroupSimpleDataDicKI = roleGroupSimpleDataDicKKeys.Length - 1; roleGroupSimpleDataDicKI >= 0; --roleGroupSimpleDataDicKI)
{
long roleGroupSimpleDataDicK = roleGroupSimpleDataDicKKeys[roleGroupSimpleDataDicKI];
if (roleGroupSimpleDataDicK != roleGroupSimpleDataDicKFreeValue)
{
RoleGroupSimpleData roleGroupSimpleDataDicV = roleGroupSimpleDataDicVValues[roleGroupSimpleDataDicKI];
stream.writeLong(roleGroupSimpleDataDicK);
if (roleGroupSimpleDataDicV != null)
{
stream.writeDataSimpleNotNull(roleGroupSimpleDataDicV);
}
else
{
nullObjError("roleGroupSimpleDataDicV");
}
}
}
}
}
else
{
nullObjError("roleGroupSimpleDataDic");
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
if (this.items != null)
{
stream.writeBoolean(true);
stream.writeLen(this.items.size());
if (!this.items.isEmpty())
{
ItemData[] itemsVValues = this.items.getValues();
for (int itemsVI = 0, itemsVLen = this.items.length(); itemsVI < itemsVLen; ++itemsVI)
{
ItemData itemsV = itemsVValues[itemsVI];
if (itemsV != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(itemsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
stream.writeInt(this.gridNum);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.attackID);
stream.writeInt(this.attackLevel);
if (this.targetData != null)
{
stream.writeDataSimpleNotNull(this.targetData);
}
else
{
nullObjError("targetData");
}
if (this.targets != null)
{
stream.writeLen(this.targets.size());
if (!this.targets.isEmpty())
{
int[] targetsVValues = this.targets.getValues();
for (int targetsVI = 0, targetsVLen = this.targets.length(); targetsVI < targetsVLen; ++targetsVI)
{
int targetsV = targetsVValues[targetsVI];
stream.writeInt(targetsV);
}
}
}
else
{
nullObjError("targets");
}
stream.writeBoolean(this.isBulletFirstHit);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.type);
if (this.pos != null)
{
stream.writeBoolean(true);
this.pos.writeBytesSimple(stream);
}
else
{
stream.writeBoolean(false);
}
if (this.dir != null)
{
this.dir.writeBytesSimple(stream);
}
else
{
nullObjError("dir");
}
if (this.realDir != null)
{
stream.writeBoolean(true);
this.realDir.writeBytesSimple(stream);
}
else
{
stream.writeBoolean(false);
}
stream.writeInt(this.realSpeedRatio);
}
