/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.type);
if (this.args != null)
{
int[][] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
int[] argsV = argsT[argsVI];
if (argsV != null)
{
int[] argsVT = argsV;
stream.writeLen(argsVT.Length);
for (int argsVVI = 0, argsVVLen = argsVT.Length; argsVVI < argsVVLen; ++argsVVI)
{
int argsVV = argsVT[argsVVI];
stream.writeInt(argsVV);
}
}
else
{
nullObjError("argsV");
}
}
}
else
{
nullObjError("args");
}
stream.writeInt(this.seedType);
if (this.showItems != null)
{
DIntData[] showItemsT = this.showItems;
stream.writeLen(showItemsT.Length);
for (int showItemsVI = 0, showItemsVLen = showItemsT.Length; showItemsVI < showItemsVLen; ++showItemsVI)
{
DIntData showItemsV = showItemsT[showItemsVI];
if (showItemsV != null)
{
showItemsV.writeBytesSimple(stream);
}
else
{
nullObjError("showItemsV");
}
}
}
else
{
nullObjError("showItems");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.vocation);
if (this.currency != null)
{
DIntData[] currencyT = this.currency;
stream.writeLen(currencyT.Length);
for (int currencyVI = 0, currencyVLen = currencyT.Length; currencyVI < currencyVLen; ++currencyVI)
{
DIntData currencyV = currencyT[currencyVI];
if (currencyV != null)
{
currencyV.writeBytesSimple(stream);
}
else
{
nullObjError("currencyV");
}
}
}
else
{
nullObjError("currency");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.modelID);
if (this.parts != null)
{
DIntData[] partsT = this.parts;
stream.writeLen(partsT.Length);
for (int partsVI = 0, partsVLen = partsT.Length; partsVI < partsVLen; ++partsVI)
{
DIntData partsV = partsT[partsVI];
if (partsV != null)
{
partsV.writeBytesSimple(stream);
}
else
{
nullObjError("partsV");
}
}
}
else
{
nullObjError("parts");
}
stream.writeInt(this.proirity);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.itemID);
stream.writeBoolean(this.isBind);
if (this.dintArgs != null)
{
DIntData[] dintArgsT = this.dintArgs;
stream.writeLen(dintArgsT.Length);
for (int dintArgsVI = 0, dintArgsVLen = dintArgsT.Length; dintArgsVI < dintArgsVLen; ++dintArgsVI)
{
DIntData dintArgsV = dintArgsT[dintArgsVI];
if (dintArgsV != null)
{
dintArgsV.writeBytesSimple(stream);
}
else
{
nullObjError("dintArgsV");
}
}
}
else
{
nullObjError("dintArgs");
}
}
/// <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);
if (this.currency != null)
{
DIntData[] currencyT = this.currency;
stream.writeLen(currencyT.Length);
for (int currencyVI = 0, currencyVLen = currencyT.Length; currencyVI < currencyVLen; ++currencyVI)
{
DIntData currencyV = currencyT[currencyVI];
if (currencyV != null)
{
currencyV.writeBytesSimple(stream);
}
else
{
nullObjError("currencyV");
}
}
}
else
{
nullObjError("currency");
}
if (this.items != null)
{
DIntData[] itemsT = this.items;
stream.writeLen(itemsT.Length);
for (int itemsVI = 0, itemsVLen = itemsT.Length; itemsVI < itemsVLen; ++itemsVI)
{
DIntData itemsV = itemsT[itemsVI];
if (itemsV != null)
{
itemsV.writeBytesSimple(stream);
}
else
{
nullObjError("itemsV");
}
}
}
else
{
nullObjError("items");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
if (this.showParts != null)
{
DIntData[] showPartsT = this.showParts;
stream.writeLen(showPartsT.Length);
for (int showPartsVI = 0, showPartsVLen = showPartsT.Length; showPartsVI < showPartsVLen; ++showPartsVI)
{
DIntData showPartsV = showPartsT[showPartsVI];
if (showPartsV != null)
{
showPartsV.writeBytesSimple(stream);
}
else
{
nullObjError("showPartsV");
}
}
}
else
{
nullObjError("showParts");
}
stream.writeUTF(this.source);
stream.writeFloat(this.collideRadius);
if (this.defaultHitRect != null)
{
float[] defaultHitRectT = this.defaultHitRect;
stream.writeLen(defaultHitRectT.Length);
for (int defaultHitRectVI = 0, defaultHitRectVLen = defaultHitRectT.Length; defaultHitRectVI < defaultHitRectVLen; ++defaultHitRectVI)
{
float defaultHitRectV = defaultHitRectT[defaultHitRectVI];
stream.writeFloat(defaultHitRectV);
}
}
else
{
nullObjError("defaultHitRect");
}
stream.writeFloat(this.height);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.instanceID);
stream.writeBoolean(this.isHit);
stream.writeBoolean(this.isCrit);
if (this.damages != null)
{
stream.writeLen(this.damages.size());
if (!this.damages.isEmpty())
{
DIntData[] damagesVValues = this.damages.getValues();
for (int damagesVI = 0, damagesVLen = this.damages.length(); damagesVI < damagesVLen; ++damagesVI)
{
DIntData damagesV = damagesVValues[damagesVI];
if (damagesV != null)
{
damagesV.writeBytesSimple(stream);
}
else
{
nullObjError("damagesV");
}
}
}
}
else
{
nullObjError("damages");
}
stream.writeBoolean(this.isKilled);
stream.writeInt(this.arg);
}
/// <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.writeInt(this.id);
stream.writeUTF(this.name);
stream.writeInt(this.type);
stream.writeInt(this.secondType);
stream.writeInt(this.singlePlusMax);
stream.writeInt(this.totalPlusMax);
stream.writeInt(this.itemLevel);
stream.writeInt(this.limitLevel);
if (this.limitVocations != null)
{
int[] limitVocationsT = this.limitVocations;
stream.writeLen(limitVocationsT.Length);
for (int limitVocationsVI = 0, limitVocationsVLen = limitVocationsT.Length; limitVocationsVI < limitVocationsVLen; ++limitVocationsVI)
{
int limitVocationsV = limitVocationsT[limitVocationsVI];
stream.writeInt(limitVocationsV);
}
}
else
{
nullObjError("limitVocations");
}
stream.writeBoolean(this.bindByGet);
stream.writeBoolean(this.bindByUse);
stream.writeBoolean(this.canTrade);
stream.writeInt(this.sellPrice);
stream.writeBoolean(this.needRedPoint);
stream.writeInt(this.sortIndex);
stream.writeUTF(this.icon);
stream.writeInt(this.fieldItemModelID);
stream.writeUTF(this.explain);
stream.writeUTF(this.enableTime);
stream.writeBoolean(this.isUnique);
if (this.baseAttributes != null)
{
DIntData[] baseAttributesT = this.baseAttributes;
stream.writeLen(baseAttributesT.Length);
for (int baseAttributesVI = 0, baseAttributesVLen = baseAttributesT.Length; baseAttributesVI < baseAttributesVLen; ++baseAttributesVI)
{
DIntData baseAttributesV = baseAttributesT[baseAttributesVI];
if (baseAttributesV != null)
{
baseAttributesV.writeBytesSimple(stream);
}
else
{
nullObjError("baseAttributesV");
}
}
}
else
{
nullObjError("baseAttributes");
}
if (this.equipActions != null)
{
int[][] equipActionsT = this.equipActions;
stream.writeLen(equipActionsT.Length);
for (int equipActionsVI = 0, equipActionsVLen = equipActionsT.Length; equipActionsVI < equipActionsVLen; ++equipActionsVI)
{
int[] equipActionsV = equipActionsT[equipActionsVI];
if (equipActionsV != null)
{
int[] equipActionsVT = equipActionsV;
stream.writeLen(equipActionsVT.Length);
for (int equipActionsVVI = 0, equipActionsVVLen = equipActionsVT.Length; equipActionsVVI < equipActionsVVLen; ++equipActionsVVI)
{
int equipActionsVV = equipActionsVT[equipActionsVVI];
stream.writeInt(equipActionsVV);
}
}
else
{
nullObjError("equipActionsV");
}
}
}
else
{
nullObjError("equipActions");
}
if (this.useConditions != null)
{
int[][] useConditionsT = this.useConditions;
stream.writeLen(useConditionsT.Length);
for (int useConditionsVI = 0, useConditionsVLen = useConditionsT.Length; useConditionsVI < useConditionsVLen; ++useConditionsVI)
{
int[] useConditionsV = useConditionsT[useConditionsVI];
if (useConditionsV != null)
{
int[] useConditionsVT = useConditionsV;
stream.writeLen(useConditionsVT.Length);
for (int useConditionsVVI = 0, useConditionsVVLen = useConditionsVT.Length; useConditionsVVI < useConditionsVVLen; ++useConditionsVVI)
{
int useConditionsVV = useConditionsVT[useConditionsVVI];
stream.writeInt(useConditionsVV);
}
}
else
{
nullObjError("useConditionsV");
}
}
}
else
{
nullObjError("useConditions");
}
if (this.useActions != null)
{
int[][] useActionsT = this.useActions;
stream.writeLen(useActionsT.Length);
for (int useActionsVI = 0, useActionsVLen = useActionsT.Length; useActionsVI < useActionsVLen; ++useActionsVI)
{
int[] useActionsV = useActionsT[useActionsVI];
if (useActionsV != null)
{
int[] useActionsVT = useActionsV;
stream.writeLen(useActionsVT.Length);
for (int useActionsVVI = 0, useActionsVVLen = useActionsVT.Length; useActionsVVI < useActionsVVLen; ++useActionsVVI)
{
int useActionsVV = useActionsVT[useActionsVVI];
stream.writeInt(useActionsVV);
}
}
else
{
nullObjError("useActionsV");
}
}
}
else
{
nullObjError("useActions");
}
stream.writeBoolean(this.passEnterBag);
stream.writeBoolean(this.useCostItemNum);
stream.writeInt(this.progressBarID);
stream.writeInt(this.tradeDefaultPrice);
stream.writeInt(this.tradePriceMin);
stream.writeInt(this.tradePriceMax);
}
/// <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.writeUTF(this.name);
stream.writeInt(this.type);
if (this.tasks != null)
{
int[] tasksT = this.tasks;
stream.writeLen(tasksT.Length);
for (int tasksVI = 0, tasksVLen = tasksT.Length; tasksVI < tasksVLen; ++tasksVI)
{
int tasksV = tasksT[tasksVI];
stream.writeInt(tasksV);
}
}
else
{
nullObjError("tasks");
}
stream.writeInt(this.executeType);
stream.writeInt(this.repeatType);
if (this.questLine != null)
{
this.questLine.writeBytesSimple(stream);
}
else
{
nullObjError("questLine");
}
stream.writeUTF(this.cycleTime);
if (this.preQuests != null)
{
int[] preQuestsT = this.preQuests;
stream.writeLen(preQuestsT.Length);
for (int preQuestsVI = 0, preQuestsVLen = preQuestsT.Length; preQuestsVI < preQuestsVLen; ++preQuestsVI)
{
int preQuestsV = preQuestsT[preQuestsVI];
stream.writeInt(preQuestsV);
}
}
else
{
nullObjError("preQuests");
}
if (this.acceptConditions != null)
{
int[][] acceptConditionsT = this.acceptConditions;
stream.writeLen(acceptConditionsT.Length);
for (int acceptConditionsVI = 0, acceptConditionsVLen = acceptConditionsT.Length; acceptConditionsVI < acceptConditionsVLen; ++acceptConditionsVI)
{
int[] acceptConditionsV = acceptConditionsT[acceptConditionsVI];
if (acceptConditionsV != null)
{
int[] acceptConditionsVT = acceptConditionsV;
stream.writeLen(acceptConditionsVT.Length);
for (int acceptConditionsVVI = 0, acceptConditionsVVLen = acceptConditionsVT.Length; acceptConditionsVVI < acceptConditionsVVLen; ++acceptConditionsVVI)
{
int acceptConditionsVV = acceptConditionsVT[acceptConditionsVVI];
stream.writeInt(acceptConditionsVV);
}
}
else
{
nullObjError("acceptConditionsV");
}
}
}
else
{
nullObjError("acceptConditions");
}
stream.writeInt(this.acceptType);
stream.writeInt(this.acceptNPC);
stream.writeInt(this.commitType);
stream.writeInt(this.commitNPC);
if (this.questItem != null)
{
DIntData[] questItemT = this.questItem;
stream.writeLen(questItemT.Length);
for (int questItemVI = 0, questItemVLen = questItemT.Length; questItemVI < questItemVLen; ++questItemVI)
{
DIntData questItemV = questItemT[questItemVI];
if (questItemV != null)
{
questItemV.writeBytesSimple(stream);
}
else
{
nullObjError("questItemV");
}
}
}
else
{
nullObjError("questItem");
}
if (this.completeActions != null)
{
int[][] completeActionsT = this.completeActions;
stream.writeLen(completeActionsT.Length);
for (int completeActionsVI = 0, completeActionsVLen = completeActionsT.Length; completeActionsVI < completeActionsVLen; ++completeActionsVI)
{
int[] completeActionsV = completeActionsT[completeActionsVI];
if (completeActionsV != null)
{
int[] completeActionsVT = completeActionsV;
stream.writeLen(completeActionsVT.Length);
for (int completeActionsVVI = 0, completeActionsVVLen = completeActionsVT.Length; completeActionsVVI < completeActionsVVLen; ++completeActionsVVI)
{
int completeActionsVV = completeActionsVT[completeActionsVVI];
stream.writeInt(completeActionsVV);
}
}
else
{
nullObjError("completeActionsV");
}
}
}
else
{
nullObjError("completeActions");
}
stream.writeUTF(this.failTime);
stream.writeBoolean(this.canGiveUp);
stream.writeBoolean(this.cantAcceptFailed);
stream.writeInt(this.rewardID);
stream.writeUTF(this.explain);
stream.writeBoolean(this.isDeprecated);
stream.writeBoolean(this.isKeyQuest);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
if (this.currency != null)
{
DIntData[] currencyT = this.currency;
stream.writeLen(currencyT.Length);
for (int currencyVI = 0, currencyVLen = currencyT.Length; currencyVI < currencyVLen; ++currencyVI)
{
DIntData currencyV = currencyT[currencyVI];
if (currencyV != null)
{
currencyV.writeBytesSimple(stream);
}
else
{
nullObjError("currencyV");
}
}
}
else
{
nullObjError("currency");
}
if (this.currencyLevelFormula != null)
{
int[][] currencyLevelFormulaT = this.currencyLevelFormula;
stream.writeLen(currencyLevelFormulaT.Length);
for (int currencyLevelFormulaVI = 0, currencyLevelFormulaVLen = currencyLevelFormulaT.Length; currencyLevelFormulaVI < currencyLevelFormulaVLen; ++currencyLevelFormulaVI)
{
int[] currencyLevelFormulaV = currencyLevelFormulaT[currencyLevelFormulaVI];
if (currencyLevelFormulaV != null)
{
int[] currencyLevelFormulaVT = currencyLevelFormulaV;
stream.writeLen(currencyLevelFormulaVT.Length);
for (int currencyLevelFormulaVVI = 0, currencyLevelFormulaVVLen = currencyLevelFormulaVT.Length; currencyLevelFormulaVVI < currencyLevelFormulaVVLen; ++currencyLevelFormulaVVI)
{
int currencyLevelFormulaVV = currencyLevelFormulaVT[currencyLevelFormulaVVI];
stream.writeInt(currencyLevelFormulaVV);
}
}
else
{
nullObjError("currencyLevelFormulaV");
}
}
}
else
{
nullObjError("currencyLevelFormula");
}
if (this.items != null)
{
DIntData[] itemsT = this.items;
stream.writeLen(itemsT.Length);
for (int itemsVI = 0, itemsVLen = itemsT.Length; itemsVI < itemsVLen; ++itemsVI)
{
DIntData itemsV = itemsT[itemsVI];
if (itemsV != null)
{
itemsV.writeBytesSimple(stream);
}
else
{
nullObjError("itemsV");
}
}
}
else
{
nullObjError("items");
}
stream.writeInt(this.randomListID);
stream.writeLong(this.roleExp);
if (this.roleExpLevelFormula != null)
{
int[] roleExpLevelFormulaT = this.roleExpLevelFormula;
stream.writeLen(roleExpLevelFormulaT.Length);
for (int roleExpLevelFormulaVI = 0, roleExpLevelFormulaVLen = roleExpLevelFormulaT.Length; roleExpLevelFormulaVI < roleExpLevelFormulaVLen; ++roleExpLevelFormulaVI)
{
int roleExpLevelFormulaV = roleExpLevelFormulaT[roleExpLevelFormulaVI];
stream.writeInt(roleExpLevelFormulaV);
}
}
else
{
nullObjError("roleExpLevelFormula");
}
stream.writeInt(this.needGrid);
stream.writeBoolean(this.needLevelAdapter);
}
/// <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);
}