/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.value);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.idirection);
stream.writeInt(this.idirectionX);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.mailNum);
stream.writeInt(this.newNum);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
if (this.attributes != null)
{
DIntData[] attributesT = this.attributes;
stream.writeLen(attributesT.Length);
for (int attributesVI = 0, attributesVLen = attributesT.Length; attributesVI < attributesVLen; ++attributesVI)
{
DIntData attributesV = attributesT[attributesVI];
if (attributesV != null)
{
attributesV.writeBytesSimple(stream);
}
else
{
nullObjError("attributesV");
}
}
}
else
{
nullObjError("attributes");
}
if (this.skills != null)
{
DIntData[] skillsT = this.skills;
stream.writeLen(skillsT.Length);
for (int skillsVI = 0, skillsVLen = skillsT.Length; skillsVI < skillsVLen; ++skillsVI)
{
DIntData skillsV = skillsT[skillsVI];
if (skillsV != null)
{
skillsV.writeBytesSimple(stream);
}
else
{
nullObjError("skillsV");
}
}
}
else
{
nullObjError("skills");
}
if (this.buffs != null)
{
DIntData[] buffsT = this.buffs;
stream.writeLen(buffsT.Length);
for (int buffsVI = 0, buffsVLen = buffsT.Length; buffsVI < buffsVLen; ++buffsVI)
{
DIntData buffsV = buffsT[buffsVI];
if (buffsV != null)
{
buffsV.writeBytesSimple(stream);
}
else
{
nullObjError("buffsV");
}
}
}
else
{
nullObjError("buffs");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeByte(this.step);
if (this.attacks != null)
{
DIntData[] attacksT = this.attacks;
stream.writeLen(attacksT.Length);
for (int attacksVI = 0, attacksVLen = attacksT.Length; attacksVI < attacksVLen; ++attacksVI)
{
DIntData attacksV = attacksT[attacksVI];
if (attacksV != null)
{
attacksV.writeBytesSimple(stream);
}
else
{
nullObjError("attacksV");
}
}
}
else
{
nullObjError("attacks");
}
if (this.bullets != null)
{
DIntData[] bulletsT = this.bullets;
stream.writeLen(bulletsT.Length);
for (int bulletsVI = 0, bulletsVLen = bulletsT.Length; bulletsVI < bulletsVLen; ++bulletsVI)
{
DIntData bulletsV = bulletsT[bulletsVI];
if (bulletsV != null)
{
bulletsV.writeBytesSimple(stream);
}
else
{
nullObjError("bulletsV");
}
}
}
else
{
nullObjError("bullets");
}
stream.writeInt(this.time);
if (this.switchType != null)
{
int[] switchTypeT = this.switchType;
stream.writeLen(switchTypeT.Length);
for (int switchTypeVI = 0, switchTypeVLen = switchTypeT.Length; switchTypeVI < switchTypeVLen; ++switchTypeVI)
{
int switchTypeV = switchTypeT[switchTypeVI];
stream.writeInt(switchTypeV);
}
}
else
{
nullObjError("switchType");
}
stream.writeInt(this.motionID);
stream.writeBoolean(this.isStayAir);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.groups != null)
{
stream.writeLen(this.groups.size());
if (!this.groups.isEmpty())
{
PlayerRoleGroupSaveData[] groupsVValues = this.groups.getValues();
for (int groupsVI = groupsVValues.Length - 1; groupsVI >= 0; --groupsVI)
{
PlayerRoleGroupSaveData groupsV = groupsVValues[groupsVI];
if (groupsV != null)
{
if (groupsV != null)
{
stream.writeDataSimpleNotNull(groupsV);
}
else
{
nullObjError("groupsV");
}
}
}
}
}
else
{
nullObjError("groups");
}
stream.writeInt(this.operateNum);
if (this.applyDic != null)
{
stream.writeLen(this.applyDic.size());
if (!this.applyDic.isEmpty())
{
PlayerApplyRoleGroupSelfData[] applyDicVValues = this.applyDic.getValues();
for (int applyDicVI = applyDicVValues.Length - 1; applyDicVI >= 0; --applyDicVI)
{
PlayerApplyRoleGroupSelfData applyDicV = applyDicVValues[applyDicVI];
if (applyDicV != null)
{
if (applyDicV != null)
{
stream.writeDataSimpleNotNull(applyDicV);
}
else
{
nullObjError("applyDicV");
}
}
}
}
}
else
{
nullObjError("applyDic");
}
stream.writeBoolean(this.canInviteInAbs);
if (this.createOperateNums != null)
{
stream.writeLen(this.createOperateNums.size());
if (!this.createOperateNums.isEmpty())
{
long[] createOperateNumsVValues = this.createOperateNums.getValues();
int createOperateNumsVMark = this.createOperateNums.getMark();
int createOperateNumsVStart = this.createOperateNums.getStart();
for (int createOperateNumsVI = 0, createOperateNumsVLen = this.createOperateNums.length(); createOperateNumsVI < createOperateNumsVLen; ++createOperateNumsVI)
{
long createOperateNumsV = createOperateNumsVValues[(createOperateNumsVI + createOperateNumsVStart) & createOperateNumsVMark];
stream.writeLong(createOperateNumsV);
}
}
}
else
{
nullObjError("createOperateNums");
}
if (this.inviteList != null)
{
stream.writeLen(this.inviteList.size());
if (!this.inviteList.isEmpty())
{
InviteRoleGroupReceiveData[] inviteListVValues = this.inviteList.getValues();
for (int inviteListVI = 0, inviteListVLen = this.inviteList.length(); inviteListVI < inviteListVLen; ++inviteListVI)
{
InviteRoleGroupReceiveData inviteListV = inviteListVValues[inviteListVI];
if (inviteListV != null)
{
stream.writeDataSimpleNotNull(inviteListV);
}
else
{
nullObjError("inviteListV");
}
}
}
}
else
{
nullObjError("inviteList");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.workIndex);
stream.writeLong(this.workTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeShort(this.id);
stream.writeUTF(this.showName);
if (this.openConditions != null)
{
int[][] openConditionsT = this.openConditions;
stream.writeLen(openConditionsT.Length);
for (int openConditionsVI = 0, openConditionsVLen = openConditionsT.Length; openConditionsVI < openConditionsVLen; ++openConditionsVI)
{
int[] openConditionsV = openConditionsT[openConditionsVI];
if (openConditionsV != null)
{
int[] openConditionsVT = openConditionsV;
stream.writeLen(openConditionsVT.Length);
for (int openConditionsVVI = 0, openConditionsVVLen = openConditionsVT.Length; openConditionsVVI < openConditionsVVLen; ++openConditionsVVI)
{
int openConditionsVV = openConditionsVT[openConditionsVVI];
stream.writeInt(openConditionsVV);
}
}
else
{
nullObjError("openConditionsV");
}
}
}
else
{
nullObjError("openConditions");
}
if (this.closeConditions != null)
{
int[][] closeConditionsT = this.closeConditions;
stream.writeLen(closeConditionsT.Length);
for (int closeConditionsVI = 0, closeConditionsVLen = closeConditionsT.Length; closeConditionsVI < closeConditionsVLen; ++closeConditionsVI)
{
int[] closeConditionsV = closeConditionsT[closeConditionsVI];
if (closeConditionsV != null)
{
int[] closeConditionsVT = closeConditionsV;
stream.writeLen(closeConditionsVT.Length);
for (int closeConditionsVVI = 0, closeConditionsVVLen = closeConditionsVT.Length; closeConditionsVVI < closeConditionsVVLen; ++closeConditionsVVI)
{
int closeConditionsVV = closeConditionsVT[closeConditionsVVI];
stream.writeInt(closeConditionsVV);
}
}
else
{
nullObjError("closeConditionsV");
}
}
}
else
{
nullObjError("closeConditions");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.singleChannels != null)
{
stream.writeLen(this.singleChannels.size());
if (!this.singleChannels.isEmpty())
{
int singleChannelsKFreeValue = this.singleChannels.getFreeValue();
int[] singleChannelsKKeys = this.singleChannels.getKeys();
ChatChannelData[] singleChannelsVValues = this.singleChannels.getValues();
for (int singleChannelsKI = singleChannelsKKeys.Length - 1; singleChannelsKI >= 0; --singleChannelsKI)
{
int singleChannelsK = singleChannelsKKeys[singleChannelsKI];
if (singleChannelsK != singleChannelsKFreeValue)
{
ChatChannelData singleChannelsV = singleChannelsVValues[singleChannelsKI];
stream.writeInt(singleChannelsK);
if (singleChannelsV != null)
{
stream.writeDataSimpleNotNull(singleChannelsV);
}
else
{
nullObjError("singleChannelsV");
}
}
}
}
}
else
{
nullObjError("singleChannels");
}
if (this.multiChannels != null)
{
stream.writeLen(this.multiChannels.size());
if (!this.multiChannels.isEmpty())
{
int multiChannelsKFreeValue = this.multiChannels.getFreeValue();
int[] multiChannelsKKeys = this.multiChannels.getKeys();
LongObjectMap <ChatChannelData>[] multiChannelsVValues = this.multiChannels.getValues();
for (int multiChannelsKI = multiChannelsKKeys.Length - 1; multiChannelsKI >= 0; --multiChannelsKI)
{
int multiChannelsK = multiChannelsKKeys[multiChannelsKI];
if (multiChannelsK != multiChannelsKFreeValue)
{
LongObjectMap <ChatChannelData> multiChannelsV = multiChannelsVValues[multiChannelsKI];
stream.writeInt(multiChannelsK);
if (multiChannelsV != null)
{
stream.writeLen(multiChannelsV.size());
if (!multiChannelsV.isEmpty())
{
long multiChannelsVKFreeValue = multiChannelsV.getFreeValue();
long[] multiChannelsVKKeys = multiChannelsV.getKeys();
ChatChannelData[] multiChannelsVVValues = multiChannelsV.getValues();
for (int multiChannelsVKI = multiChannelsVKKeys.Length - 1; multiChannelsVKI >= 0; --multiChannelsVKI)
{
long multiChannelsVK = multiChannelsVKKeys[multiChannelsVKI];
if (multiChannelsVK != multiChannelsVKFreeValue)
{
ChatChannelData multiChannelsVV = multiChannelsVVValues[multiChannelsVKI];
stream.writeLong(multiChannelsVK);
if (multiChannelsVV != null)
{
stream.writeDataSimpleNotNull(multiChannelsVV);
}
else
{
nullObjError("multiChannelsVV");
}
}
}
}
}
else
{
nullObjError("multiChannelsV");
}
}
}
}
}
else
{
nullObjError("multiChannels");
}
stream.writeInt(this.chatSendIndex);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.clientTaskInstanceIDIndex);
if (this.accepts != null)
{
stream.writeLen(this.accepts.size());
if (!this.accepts.isEmpty())
{
QuestData[] acceptsVValues = this.accepts.getValues();
for (int acceptsVI = acceptsVValues.Length - 1; acceptsVI >= 0; --acceptsVI)
{
QuestData acceptsV = acceptsVValues[acceptsVI];
if (acceptsV != null)
{
if (acceptsV != null)
{
stream.writeDataFullNotNull(acceptsV);
}
else
{
nullObjError("acceptsV");
}
}
}
}
}
else
{
nullObjError("accepts");
}
if (this.completeLines != null)
{
stream.writeLen(this.completeLines.size());
if (!this.completeLines.isEmpty())
{
int completeLinesKFreeValue = this.completeLines.getFreeValue();
int[] completeLinesKKeys = this.completeLines.getKeys();
int[] completeLinesVValues = this.completeLines.getValues();
for (int completeLinesKI = completeLinesKKeys.Length - 1; completeLinesKI >= 0; --completeLinesKI)
{
int completeLinesK = completeLinesKKeys[completeLinesKI];
if (completeLinesK != completeLinesKFreeValue)
{
int completeLinesV = completeLinesVValues[completeLinesKI];
stream.writeInt(completeLinesK);
stream.writeInt(completeLinesV);
}
}
}
}
else
{
nullObjError("completeLines");
}
if (this.completeIDs != null)
{
stream.writeLen(this.completeIDs.size());
if (!this.completeIDs.isEmpty())
{
int completeIDsVFreeValue = this.completeIDs.getFreeValue();
int[] completeIDsVKeys = this.completeIDs.getKeys();
for (int completeIDsVI = completeIDsVKeys.Length - 1; completeIDsVI >= 0; --completeIDsVI)
{
int completeIDsV = completeIDsVKeys[completeIDsVI];
if (completeIDsV != completeIDsVFreeValue)
{
stream.writeInt(completeIDsV);
}
}
}
}
else
{
nullObjError("completeIDs");
}
if (this.completeQuestsDic != null)
{
stream.writeLen(this.completeQuestsDic.size());
if (!this.completeQuestsDic.isEmpty())
{
QuestCompleteData[] completeQuestsDicVValues = this.completeQuestsDic.getValues();
for (int completeQuestsDicVI = completeQuestsDicVValues.Length - 1; completeQuestsDicVI >= 0; --completeQuestsDicVI)
{
QuestCompleteData completeQuestsDicV = completeQuestsDicVValues[completeQuestsDicVI];
if (completeQuestsDicV != null)
{
if (completeQuestsDicV != null)
{
stream.writeDataFullNotNull(completeQuestsDicV);
}
else
{
nullObjError("completeQuestsDicV");
}
}
}
}
}
else
{
nullObjError("completeQuestsDic");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.instanceID);
if (this.identity != null)
{
stream.writeDataFullNotNull(this.identity);
}
else
{
nullObjError("identity");
}
if (this.normal != null)
{
stream.writeDataFullNotNull(this.normal);
}
else
{
nullObjError("normal");
}
if (this.pos != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.pos);
}
else
{
stream.writeBoolean(false);
}
if (this.avatar != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.avatar);
}
else
{
stream.writeBoolean(false);
}
if (this.move != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.move);
}
else
{
stream.writeBoolean(false);
}
if (this.fight != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.fight);
}
else
{
stream.writeBoolean(false);
}
if (this.fightEx != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.fightEx);
}
else
{
stream.writeBoolean(false);
}
if (this.ai != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.ai);
}
else
{
stream.writeBoolean(false);
}
if (this.func != null)
{
stream.writeBoolean(true);
stream.writeDataFullNotNull(this.func);
}
else
{
stream.writeBoolean(false);
}
stream.endWriteObj();
}
public void writeSplitConfigVersion(BytesWriteStream stream)
{
stream.writeVersion(ShineGlobal.configVersion);
stream.writeInt(splitConfigVersion);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeUTF(this.name);
if (this.groups != null)
{
int[] groupsT = this.groups;
stream.writeLen(groupsT.Length);
for (int groupsVI = 0, groupsVLen = groupsT.Length; groupsVI < groupsVLen; ++groupsVI)
{
int groupsV = groupsT[groupsVI];
stream.writeInt(groupsV);
}
}
else
{
nullObjError("groups");
}
stream.writeInt(this.gainType);
stream.writeInt(this.plusType);
stream.writeInt(this.plusMax);
stream.writeInt(this.keepType);
stream.writeBoolean(this.removeAtDead);
if (this.subNums != null)
{
int[][] subNumsT = this.subNums;
stream.writeLen(subNumsT.Length);
for (int subNumsVI = 0, subNumsVLen = subNumsT.Length; subNumsVI < subNumsVLen; ++subNumsVI)
{
int[] subNumsV = subNumsT[subNumsVI];
if (subNumsV != null)
{
int[] subNumsVT = subNumsV;
stream.writeLen(subNumsVT.Length);
for (int subNumsVVI = 0, subNumsVVLen = subNumsVT.Length; subNumsVVI < subNumsVVLen; ++subNumsVVI)
{
int subNumsVV = subNumsVT[subNumsVVI];
stream.writeInt(subNumsVV);
}
}
else
{
nullObjError("subNumsV");
}
}
}
else
{
nullObjError("subNums");
}
stream.writeInt(this.effect);
stream.writeUTF(this.icon);
stream.writeUTF(this.explain);
if (this.influenceType != null)
{
int[] influenceTypeT = this.influenceType;
stream.writeLen(influenceTypeT.Length);
for (int influenceTypeVI = 0, influenceTypeVLen = influenceTypeT.Length; influenceTypeVI < influenceTypeVLen; ++influenceTypeVI)
{
int influenceTypeV = influenceTypeT[influenceTypeVI];
stream.writeInt(influenceTypeV);
}
}
else
{
nullObjError("influenceType");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.type);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.rank);
stream.writeDouble(this.value);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.booleanDic != null)
{
stream.writeLen(this.booleanDic.size());
if (!this.booleanDic.isEmpty())
{
int booleanDicKFreeValue = this.booleanDic.getFreeValue();
int[] booleanDicKKeys = this.booleanDic.getKeys();
bool[] booleanDicVValues = this.booleanDic.getValues();
for (int booleanDicKI = booleanDicKKeys.Length - 1; booleanDicKI >= 0; --booleanDicKI)
{
int booleanDicK = booleanDicKKeys[booleanDicKI];
if (booleanDicK != booleanDicKFreeValue)
{
bool booleanDicV = booleanDicVValues[booleanDicKI];
stream.writeInt(booleanDicK);
stream.writeBoolean(booleanDicV);
}
}
}
}
else
{
nullObjError("booleanDic");
}
if (this.intDic != null)
{
stream.writeLen(this.intDic.size());
if (!this.intDic.isEmpty())
{
int intDicKFreeValue = this.intDic.getFreeValue();
int[] intDicKKeys = this.intDic.getKeys();
int[] intDicVValues = this.intDic.getValues();
for (int intDicKI = intDicKKeys.Length - 1; intDicKI >= 0; --intDicKI)
{
int intDicK = intDicKKeys[intDicKI];
if (intDicK != intDicKFreeValue)
{
int intDicV = intDicVValues[intDicKI];
stream.writeInt(intDicK);
stream.writeInt(intDicV);
}
}
}
}
else
{
nullObjError("intDic");
}
if (this.longDic != null)
{
stream.writeLen(this.longDic.size());
if (!this.longDic.isEmpty())
{
int longDicKFreeValue = this.longDic.getFreeValue();
int[] longDicKKeys = this.longDic.getKeys();
long[] longDicVValues = this.longDic.getValues();
for (int longDicKI = longDicKKeys.Length - 1; longDicKI >= 0; --longDicKI)
{
int longDicK = longDicKKeys[longDicKI];
if (longDicK != longDicKFreeValue)
{
long longDicV = longDicVValues[longDicKI];
stream.writeInt(longDicK);
stream.writeLong(longDicV);
}
}
}
}
else
{
nullObjError("longDic");
}
if (this.stringDic != null)
{
stream.writeLen(this.stringDic.size());
if (!this.stringDic.isEmpty())
{
string[] stringDicKKeys = this.stringDic.getKeys();
string[] stringDicVValues = this.stringDic.getValues();
for (int stringDicKI = stringDicKKeys.Length - 1; stringDicKI >= 0; --stringDicKI)
{
string stringDicK = stringDicKKeys[stringDicKI];
if (stringDicK != null)
{
string stringDicV = stringDicVValues[stringDicKI];
stream.writeUTF(stringDicK);
stream.writeUTF(stringDicV);
}
}
}
}
else
{
nullObjError("stringDic");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.a);
stream.writeBoolean(this.b);
}