/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeShort(this.id);
stream.writeBoolean(this.needPageTool);
stream.writeInt(this.eachPageShowNum);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
if (this.bringCDs != null)
{
int[] bringCDsT = this.bringCDs;
stream.writeLen(bringCDsT.Length);
for (int bringCDsVI = 0, bringCDsVLen = bringCDsT.Length; bringCDsVI < bringCDsVLen; ++bringCDsVI)
{
int bringCDsV = bringCDsT[bringCDsVI];
stream.writeInt(bringCDsV);
}
}
else
{
nullObjError("bringCDs");
}
if (this.cost != null)
{
DIntData[] costT = this.cost;
stream.writeLen(costT.Length);
for (int costVI = 0, costVLen = costT.Length; costVI < costVLen; ++costVI)
{
DIntData costV = costT[costVI];
if (costV != null)
{
costV.writeBytesSimple(stream);
}
else
{
nullObjError("costV");
}
}
}
else
{
nullObjError("cost");
}
stream.writeFloat(this.useDistance);
stream.writeInt(this.useDistanceVar);
stream.writeInt(this.singBarID);
stream.writeInt(this.lastTime);
stream.writeUTF(this.explain);
}
/// <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 toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
if (this.timeUpActions != null)
{
int[][] timeUpActionsT = this.timeUpActions;
stream.writeLen(timeUpActionsT.Length);
for (int timeUpActionsVI = 0, timeUpActionsVLen = timeUpActionsT.Length; timeUpActionsVI < timeUpActionsVLen; ++timeUpActionsVI)
{
int[] timeUpActionsV = timeUpActionsT[timeUpActionsVI];
if (timeUpActionsV != null)
{
int[] timeUpActionsVT = timeUpActionsV;
stream.writeLen(timeUpActionsVT.Length);
for (int timeUpActionsVVI = 0, timeUpActionsVVLen = timeUpActionsVT.Length; timeUpActionsVVI < timeUpActionsVVLen; ++timeUpActionsVVI)
{
int timeUpActionsVV = timeUpActionsVT[timeUpActionsVVI];
stream.writeInt(timeUpActionsVV);
}
}
else
{
nullObjError("timeUpActionsV");
}
}
}
else
{
nullObjError("timeUpActions");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
stream.writeInt(this.scope);
if (this.scopeArgs != null)
{
float[] scopeArgsT = this.scopeArgs;
stream.writeLen(scopeArgsT.Length);
for (int scopeArgsVI = 0, scopeArgsVLen = scopeArgsT.Length; scopeArgsVI < scopeArgsVLen; ++scopeArgsVI)
{
float scopeArgsV = scopeArgsT[scopeArgsVI];
stream.writeFloat(scopeArgsV);
}
}
else
{
nullObjError("scopeArgs");
}
if (this.bullet != null)
{
this.bullet.writeBytesSimple(stream);
}
else
{
nullObjError("bullet");
}
if (this.damages != null)
{
int[][] damagesT = this.damages;
stream.writeLen(damagesT.Length);
for (int damagesVI = 0, damagesVLen = damagesT.Length; damagesVI < damagesVLen; ++damagesVI)
{
int[] damagesV = damagesT[damagesVI];
if (damagesV != null)
{
int[] damagesVT = damagesV;
stream.writeLen(damagesVT.Length);
for (int damagesVVI = 0, damagesVVLen = damagesVT.Length; damagesVVI < damagesVVLen; ++damagesVVI)
{
int damagesVV = damagesVT[damagesVVI];
stream.writeInt(damagesVV);
}
}
else
{
nullObjError("damagesV");
}
}
}
else
{
nullObjError("damages");
}
stream.writeInt(this.addBuffProbID);
if (this.addBuffs != null)
{
DIntData[] addBuffsT = this.addBuffs;
stream.writeLen(addBuffsT.Length);
for (int addBuffsVI = 0, addBuffsVLen = addBuffsT.Length; addBuffsVI < addBuffsVLen; ++addBuffsVI)
{
DIntData addBuffsV = addBuffsT[addBuffsVI];
if (addBuffsV != null)
{
addBuffsV.writeBytesSimple(stream);
}
else
{
nullObjError("addBuffsV");
}
}
}
else
{
nullObjError("addBuffs");
}
if (this.momentActions != null)
{
int[][] momentActionsT = this.momentActions;
stream.writeLen(momentActionsT.Length);
for (int momentActionsVI = 0, momentActionsVLen = momentActionsT.Length; momentActionsVI < momentActionsVLen; ++momentActionsVI)
{
int[] momentActionsV = momentActionsT[momentActionsVI];
if (momentActionsV != null)
{
int[] momentActionsVT = momentActionsV;
stream.writeLen(momentActionsVT.Length);
for (int momentActionsVVI = 0, momentActionsVVLen = momentActionsVT.Length; momentActionsVVI < momentActionsVVLen; ++momentActionsVVI)
{
int momentActionsVV = momentActionsVT[momentActionsVVI];
stream.writeInt(momentActionsVV);
}
}
else
{
nullObjError("momentActionsV");
}
}
}
else
{
nullObjError("momentActions");
}
stream.writeInt(this.spasticityValue);
stream.writeInt(this.attackBlowForce);
stream.writeInt(this.attackPushForce);
stream.writeInt(this.attackLiePushForce);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeShort(this.id);
stream.writeUTF(this.startTime);
stream.writeUTF(this.endTime);
stream.writeUTF(this.resetTime);
stream.writeUTF(this.canSeeTime);
stream.writeUTF(this.cantSeeTime);
if (this.enableConditions != null)
{
int[][] enableConditionsT = this.enableConditions;
stream.writeLen(enableConditionsT.Length);
for (int enableConditionsVI = 0, enableConditionsVLen = enableConditionsT.Length; enableConditionsVI < enableConditionsVLen; ++enableConditionsVI)
{
int[] enableConditionsV = enableConditionsT[enableConditionsVI];
if (enableConditionsV != null)
{
int[] enableConditionsVT = enableConditionsV;
stream.writeLen(enableConditionsVT.Length);
for (int enableConditionsVVI = 0, enableConditionsVVLen = enableConditionsVT.Length; enableConditionsVVI < enableConditionsVVLen; ++enableConditionsVVI)
{
int enableConditionsVV = enableConditionsVT[enableConditionsVVI];
stream.writeInt(enableConditionsVV);
}
}
else
{
nullObjError("enableConditionsV");
}
}
}
else
{
nullObjError("enableConditions");
}
if (this.invalidConditions != null)
{
int[][] invalidConditionsT = this.invalidConditions;
stream.writeLen(invalidConditionsT.Length);
for (int invalidConditionsVI = 0, invalidConditionsVLen = invalidConditionsT.Length; invalidConditionsVI < invalidConditionsVLen; ++invalidConditionsVI)
{
int[] invalidConditionsV = invalidConditionsT[invalidConditionsVI];
if (invalidConditionsV != null)
{
int[] invalidConditionsVT = invalidConditionsV;
stream.writeLen(invalidConditionsVT.Length);
for (int invalidConditionsVVI = 0, invalidConditionsVVLen = invalidConditionsVT.Length; invalidConditionsVVI < invalidConditionsVVLen; ++invalidConditionsVVI)
{
int invalidConditionsVV = invalidConditionsVT[invalidConditionsVVI];
stream.writeInt(invalidConditionsVV);
}
}
else
{
nullObjError("invalidConditionsV");
}
}
}
else
{
nullObjError("invalidConditions");
}
if (this.joinConditions != null)
{
int[][] joinConditionsT = this.joinConditions;
stream.writeLen(joinConditionsT.Length);
for (int joinConditionsVI = 0, joinConditionsVLen = joinConditionsT.Length; joinConditionsVI < joinConditionsVLen; ++joinConditionsVI)
{
int[] joinConditionsV = joinConditionsT[joinConditionsVI];
if (joinConditionsV != null)
{
int[] joinConditionsVT = joinConditionsV;
stream.writeLen(joinConditionsVT.Length);
for (int joinConditionsVVI = 0, joinConditionsVVLen = joinConditionsVT.Length; joinConditionsVVI < joinConditionsVVLen; ++joinConditionsVVI)
{
int joinConditionsVV = joinConditionsVT[joinConditionsVVI];
stream.writeInt(joinConditionsVV);
}
}
else
{
nullObjError("joinConditionsV");
}
}
}
else
{
nullObjError("joinConditions");
}
stream.writeInt(this.joinCount);
stream.writeInt(this.rewardOnce);
stream.writeInt(this.rewardComplete);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
stream.writeInt(this.costID);
if (this.useRoleAttributes != null)
{
DIntData[] useRoleAttributesT = this.useRoleAttributes;
stream.writeLen(useRoleAttributesT.Length);
for (int useRoleAttributesVI = 0, useRoleAttributesVLen = useRoleAttributesT.Length; useRoleAttributesVI < useRoleAttributesVLen; ++useRoleAttributesVI)
{
DIntData useRoleAttributesV = useRoleAttributesT[useRoleAttributesVI];
if (useRoleAttributesV != null)
{
useRoleAttributesV.writeBytesSimple(stream);
}
else
{
nullObjError("useRoleAttributesV");
}
}
}
else
{
nullObjError("useRoleAttributes");
}
if (this.addRoleAttributes != null)
{
DIntData[] addRoleAttributesT = this.addRoleAttributes;
stream.writeLen(addRoleAttributesT.Length);
for (int addRoleAttributesVI = 0, addRoleAttributesVLen = addRoleAttributesT.Length; addRoleAttributesVI < addRoleAttributesVLen; ++addRoleAttributesVI)
{
DIntData addRoleAttributesV = addRoleAttributesT[addRoleAttributesVI];
if (addRoleAttributesV != null)
{
addRoleAttributesV.writeBytesSimple(stream);
}
else
{
nullObjError("addRoleAttributesV");
}
}
}
else
{
nullObjError("addRoleAttributes");
}
if (this.addActions != null)
{
int[][] addActionsT = this.addActions;
stream.writeLen(addActionsT.Length);
for (int addActionsVI = 0, addActionsVLen = addActionsT.Length; addActionsVI < addActionsVLen; ++addActionsVI)
{
int[] addActionsV = addActionsT[addActionsVI];
if (addActionsV != null)
{
int[] addActionsVT = addActionsV;
stream.writeLen(addActionsVT.Length);
for (int addActionsVVI = 0, addActionsVVLen = addActionsVT.Length; addActionsVVI < addActionsVVLen; ++addActionsVVI)
{
int addActionsVV = addActionsVT[addActionsVVI];
stream.writeInt(addActionsVV);
}
}
else
{
nullObjError("addActionsV");
}
}
}
else
{
nullObjError("addActions");
}
stream.writeInt(this.buildTime);
stream.writeInt(this.levelUpTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeShort(this.level);
if (this.actions != null)
{
int[][] actionsT = this.actions;
stream.writeLen(actionsT.Length);
for (int actionsVI = 0, actionsVLen = actionsT.Length; actionsVI < actionsVLen; ++actionsVI)
{
int[] actionsV = actionsT[actionsVI];
if (actionsV != null)
{
int[] actionsVT = actionsV;
stream.writeLen(actionsVT.Length);
for (int actionsVVI = 0, actionsVVLen = actionsVT.Length; actionsVVI < actionsVVLen; ++actionsVVI)
{
int actionsVV = actionsVT[actionsVVI];
stream.writeInt(actionsVV);
}
}
else
{
nullObjError("actionsV");
}
}
}
else
{
nullObjError("actions");
}
stream.writeInt(this.lastTime);
stream.writeShort(this.lastNum);
if (this.overActions != null)
{
int[][] overActionsT = this.overActions;
stream.writeLen(overActionsT.Length);
for (int overActionsVI = 0, overActionsVLen = overActionsT.Length; overActionsVI < overActionsVLen; ++overActionsVI)
{
int[] overActionsV = overActionsT[overActionsVI];
if (overActionsV != null)
{
int[] overActionsVT = overActionsV;
stream.writeLen(overActionsVT.Length);
for (int overActionsVVI = 0, overActionsVVLen = overActionsVT.Length; overActionsVVI < overActionsVVLen; ++overActionsVVI)
{
int overActionsVV = overActionsVT[overActionsVVI];
stream.writeInt(overActionsVV);
}
}
else
{
nullObjError("overActionsV");
}
}
}
else
{
nullObjError("overActions");
}
if (this.plusMaxActions != null)
{
int[][] plusMaxActionsT = this.plusMaxActions;
stream.writeLen(plusMaxActionsT.Length);
for (int plusMaxActionsVI = 0, plusMaxActionsVLen = plusMaxActionsT.Length; plusMaxActionsVI < plusMaxActionsVLen; ++plusMaxActionsVI)
{
int[] plusMaxActionsV = plusMaxActionsT[plusMaxActionsVI];
if (plusMaxActionsV != null)
{
int[] plusMaxActionsVT = plusMaxActionsV;
stream.writeLen(plusMaxActionsVT.Length);
for (int plusMaxActionsVVI = 0, plusMaxActionsVVLen = plusMaxActionsVT.Length; plusMaxActionsVVI < plusMaxActionsVVLen; ++plusMaxActionsVVI)
{
int plusMaxActionsVV = plusMaxActionsVT[plusMaxActionsVVI];
stream.writeInt(plusMaxActionsVV);
}
}
else
{
nullObjError("plusMaxActionsV");
}
}
}
else
{
nullObjError("plusMaxActions");
}
}
/// <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.writeShort(this.switchID);
}
/// <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");
}
}