/// <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)
{
stream.writeInt(this.instanceID);
stream.writeInt(this.id);
stream.writeLong(this.time);
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);
}
if (this.itemList != null)
{
stream.writeBoolean(true);
stream.writeLen(this.itemList.size());
if (!this.itemList.isEmpty())
{
ItemData[] itemListVValues = this.itemList.getValues();
for (int itemListVI = 0, itemListVLen = this.itemList.length(); itemListVI < itemListVLen; ++itemListVI)
{
ItemData itemListV = itemListVValues[itemListVI];
if (itemListV != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(itemListV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
stream.writeBoolean(this.readed);
stream.writeBoolean(this.rewarded);
stream.writeBoolean(this.hasRedPoint);
stream.writeUTF(this.platform);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.equips != null)
{
stream.writeLen(this.equips.size());
if (!this.equips.isEmpty())
{
int equipsKFreeValue = this.equips.getFreeValue();
int[] equipsKKeys = this.equips.getKeys();
ItemData[] equipsVValues = this.equips.getValues();
for (int equipsKI = equipsKKeys.Length - 1; equipsKI >= 0; --equipsKI)
{
int equipsK = equipsKKeys[equipsKI];
if (equipsK != equipsKFreeValue)
{
ItemData equipsV = equipsVValues[equipsKI];
stream.writeInt(equipsK);
if (equipsV != null)
{
stream.writeDataSimpleNotNull(equipsV);
}
else
{
nullObjError("equipsV");
}
}
}
}
}
else
{
nullObjError("equips");
}
if (this.openSlots != null)
{
stream.writeLen(this.openSlots.size());
if (!this.openSlots.isEmpty())
{
int openSlotsVFreeValue = this.openSlots.getFreeValue();
int[] openSlotsVKeys = this.openSlots.getKeys();
for (int openSlotsVI = openSlotsVKeys.Length - 1; openSlotsVI >= 0; --openSlotsVI)
{
int openSlotsV = openSlotsVKeys[openSlotsVI];
if (openSlotsV != openSlotsVFreeValue)
{
stream.writeInt(openSlotsV);
}
}
}
}
else
{
nullObjError("openSlots");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.runningDatas != null)
{
stream.writeLen(this.runningDatas.size());
if (!this.runningDatas.isEmpty())
{
AchievementData[] runningDatasVValues = this.runningDatas.getValues();
for (int runningDatasVI = runningDatasVValues.Length - 1; runningDatasVI >= 0; --runningDatasVI)
{
AchievementData runningDatasV = runningDatasVValues[runningDatasVI];
if (runningDatasV != null)
{
if (runningDatasV != null)
{
stream.writeDataSimpleNotNull(runningDatasV);
}
else
{
nullObjError("runningDatasV");
}
}
}
}
}
else
{
nullObjError("runningDatas");
}
if (this.completeDatas != null)
{
stream.writeLen(this.completeDatas.size());
if (!this.completeDatas.isEmpty())
{
AchievementCompleteData[] completeDatasVValues = this.completeDatas.getValues();
for (int completeDatasVI = completeDatasVValues.Length - 1; completeDatasVI >= 0; --completeDatasVI)
{
AchievementCompleteData completeDatasV = completeDatasVValues[completeDatasVI];
if (completeDatasV != null)
{
if (completeDatasV != null)
{
stream.writeDataSimpleNotNull(completeDatasV);
}
else
{
nullObjError("completeDatasV");
}
}
}
}
}
else
{
nullObjError("completeDatas");
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
if (this.workExecuteRecordDic != null)
{
stream.writeLen(this.workExecuteRecordDic.size());
if (!this.workExecuteRecordDic.isEmpty())
{
int workExecuteRecordDicKFreeValue = this.workExecuteRecordDic.getFreeValue();
int[] workExecuteRecordDicKKeys = this.workExecuteRecordDic.getKeys();
LongLongMap[] workExecuteRecordDicVValues = this.workExecuteRecordDic.getValues();
for (int workExecuteRecordDicKI = workExecuteRecordDicKKeys.Length - 1; workExecuteRecordDicKI >= 0; --workExecuteRecordDicKI)
{
int workExecuteRecordDicK = workExecuteRecordDicKKeys[workExecuteRecordDicKI];
if (workExecuteRecordDicK != workExecuteRecordDicKFreeValue)
{
LongLongMap workExecuteRecordDicV = workExecuteRecordDicVValues[workExecuteRecordDicKI];
stream.writeInt(workExecuteRecordDicK);
if (workExecuteRecordDicV != null)
{
stream.writeLen(workExecuteRecordDicV.size());
if (!workExecuteRecordDicV.isEmpty())
{
long workExecuteRecordDicVKFreeValue = workExecuteRecordDicV.getFreeValue();
long[] workExecuteRecordDicVKKeys = workExecuteRecordDicV.getKeys();
long[] workExecuteRecordDicVVValues = workExecuteRecordDicV.getValues();
for (int workExecuteRecordDicVKI = workExecuteRecordDicVKKeys.Length - 1; workExecuteRecordDicVKI >= 0; --workExecuteRecordDicVKI)
{
long workExecuteRecordDicVK = workExecuteRecordDicVKKeys[workExecuteRecordDicVKI];
if (workExecuteRecordDicVK != workExecuteRecordDicVKFreeValue)
{
long workExecuteRecordDicVV = workExecuteRecordDicVVValues[workExecuteRecordDicVKI];
stream.writeLong(workExecuteRecordDicVK);
stream.writeLong(workExecuteRecordDicVV);
}
}
}
}
else
{
nullObjError("workExecuteRecordDicV");
}
}
}
}
}
else
{
nullObjError("workExecuteRecordDic");
}
stream.endWriteObj();
}
/// <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.args != null)
{
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
{
nullObjError("args");
}
stream.writeInt(this.needNum);
stream.writeInt(this.initNum);
if (this.conditions != null)
{
int[][] conditionsT = this.conditions;
stream.writeLen(conditionsT.Length);
for (int conditionsVI = 0, conditionsVLen = conditionsT.Length; conditionsVI < conditionsVLen; ++conditionsVI)
{
int[] conditionsV = conditionsT[conditionsVI];
if (conditionsV != null)
{
int[] conditionsVT = conditionsV;
stream.writeLen(conditionsVT.Length);
for (int conditionsVVI = 0, conditionsVVLen = conditionsVT.Length; conditionsVVI < conditionsVVLen; ++conditionsVVI)
{
int conditionsVV = conditionsVT[conditionsVVI];
stream.writeInt(conditionsVV);
}
}
else
{
nullObjError("conditionsV");
}
}
}
else
{
nullObjError("conditions");
}
stream.writeUTF(this.explain);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
if (this.origin != null)
{
int[] originT = this.origin;
stream.writeLen(originT.Length);
for (int originVI = 0, originVLen = originT.Length; originVI < originVLen; ++originVI)
{
int originV = originT[originVI];
stream.writeInt(originV);
}
}
else
{
nullObjError("origin");
}
if (this.size != null)
{
int[] sizeT = this.size;
stream.writeLen(sizeT.Length);
for (int sizeVI = 0, sizeVLen = sizeT.Length; sizeVI < sizeVLen; ++sizeVI)
{
int sizeV = sizeT[sizeVI];
stream.writeInt(sizeV);
}
}
else
{
nullObjError("size");
}
stream.writeUTF(this.source);
if (this.sourceExList != null)
{
string[] sourceExListT = this.sourceExList;
stream.writeLen(sourceExListT.Length);
for (int sourceExListVI = 0, sourceExListVLen = sourceExListT.Length; sourceExListVI < sourceExListVLen; ++sourceExListVI)
{
string sourceExListV = sourceExListT[sourceExListVI];
stream.writeUTF(sourceExListV);
}
}
else
{
nullObjError("sourceExList");
}
stream.writeUTF(this.music);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
if (this.posDir != null)
{
stream.writeBoolean(true);
this.posDir.writeBytesFull(stream);
}
else
{
stream.writeBoolean(false);
}
stream.writeInt(this.type);
if (this.ints != null)
{
stream.writeBoolean(true);
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
{
stream.writeBoolean(false);
}
if (this.floats != null)
{
stream.writeBoolean(true);
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
{
stream.writeBoolean(false);
}
stream.endWriteObj();
}
/// <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 toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
if (this.attributes != null)
{
stream.writeLen(this.attributes.size());
if (!this.attributes.isEmpty())
{
int attributesKFreeValue = this.attributes.getFreeValue();
int[] attributesKKeys = this.attributes.getKeys();
int[] attributesVValues = this.attributes.getValues();
for (int attributesKI = attributesKKeys.Length - 1; attributesKI >= 0; --attributesKI)
{
int attributesK = attributesKKeys[attributesKI];
if (attributesK != attributesKFreeValue)
{
int attributesV = attributesVValues[attributesKI];
stream.writeInt(attributesK);
stream.writeInt(attributesV);
}
}
}
}
else
{
nullObjError("attributes");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
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");
}
stream.endWriteObj();
}
/// <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.taskID);
if (this.pres != null)
{
int[] presT = this.pres;
stream.writeLen(presT.Length);
for (int presVI = 0, presVLen = presT.Length; presVI < presVLen; ++presVI)
{
int presV = presT[presVI];
stream.writeInt(presV);
}
}
else
{
nullObjError("pres");
}
stream.writeInt(this.rewardID);
stream.writeUTF(this.explain);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
if (this.petDic != null)
{
stream.writeLen(this.petDic.size());
if (!this.petDic.isEmpty())
{
PetUseData[] petDicVValues = this.petDic.getValues();
for (int petDicVI = petDicVValues.Length - 1; petDicVI >= 0; --petDicVI)
{
PetUseData petDicV = petDicVValues[petDicVI];
if (petDicV != null)
{
if (petDicV != null)
{
stream.writeDataFullNotNull(petDicV);
}
else
{
nullObjError("petDicV");
}
}
}
}
}
else
{
nullObjError("petDic");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.instanceID);
if (this.items != null)
{
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.writeDataFullNotNull(itemsV);
}
else
{
nullObjError("itemsV");
}
}
}
}
else
{
nullObjError("items");
}
stream.writeLong(this.removeTime);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
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);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.index);
if (this.list != null)
{
stream.writeLen(this.list.size());
if (!this.list.isEmpty())
{
ClientOfflineWorkData[] listVValues = this.list.getValues();
for (int listVI = 0, listVLen = this.list.length(); listVI < listVLen; ++listVI)
{
ClientOfflineWorkData listV = listVValues[listVI];
if (listV != null)
{
stream.writeDataFullNotNull(listV);
}
else
{
nullObjError("listV");
}
}
}
}
else
{
nullObjError("list");
}
stream.writeInt(this.clientRandomSeedIndex);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
stream.writeInt(this.id);
if (this.args != null)
{
TriggerObjData[] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
TriggerObjData argsV = argsT[argsVI];
if (argsV != null)
{
stream.writeDataFullNotNull(argsV);
}
else
{
nullObjError("argsV");
}
}
}
else
{
nullObjError("args");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.conditions != null)
{
stream.writeBoolean(true);
AuctionQueryConditionData[] conditionsT = this.conditions;
stream.writeLen(conditionsT.Length);
for (int conditionsVI = 0, conditionsVLen = conditionsT.Length; conditionsVI < conditionsVLen; ++conditionsVI)
{
AuctionQueryConditionData conditionsV = conditionsT[conditionsVI];
if (conditionsV != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(conditionsV);
}
else
{
stream.writeBoolean(false);
}
}
}
else
{
stream.writeBoolean(false);
}
stream.writeInt(this.page);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(daysV);
}
else
{
nullObjError("daysV");
}
}
}
}
else
{
nullObjError("days");
}
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
if (this.funcList != null)
{
TriggerFuncData[] funcListT = this.funcList;
stream.writeLen(funcListT.Length);
for (int funcListVI = 0, funcListVLen = funcListT.Length; funcListVI < funcListVLen; ++funcListVI)
{
TriggerFuncData funcListV = funcListT[funcListVI];
if (funcListV != null)
{
stream.writeDataFullNotNull(funcListV);
}
else
{
nullObjError("funcListV");
}
}
}
else
{
nullObjError("funcList");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.fightUnitID);
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.writeBoolean(this.canAutoBuild);
}
/// <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);
if (this.posDir != null)
{
stream.writeBoolean(true);
this.posDir.writeBytesSimple(stream);
}
else
{
stream.writeBoolean(false);
}
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.writeBoolean(this.isAssist);
stream.writeBoolean(this.isNecessary);
if (this.areaIDList != null)
{
stream.writeLen(this.areaIDList.size());
if (!this.areaIDList.isEmpty())
{
int[] areaIDListVValues = this.areaIDList.getValues();
for (int areaIDListVI = 0, areaIDListVLen = this.areaIDList.length(); areaIDListVI < areaIDListVLen; ++areaIDListVI)
{
int areaIDListV = areaIDListVValues[areaIDListVI];
stream.writeInt(areaIDListV);
}
}
}
else
{
nullObjError("areaIDList");
}
stream.writeInt(this.countryID);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
stream.writeLong(this.playerID);
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);
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
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.writeDataSimpleNotNull(itemsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
stream.writeInt(this.gridNum);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.index);
if(this.commands!=null)
{
stream.writeBoolean(true);
stream.writeLen(this.commands.size());
if(!this.commands.isEmpty())
{
FrameSyncCommandData[] commandsVValues=this.commands.getValues();
for(int commandsVI=0,commandsVLen=this.commands.length();commandsVI<commandsVLen;++commandsVI)
{
FrameSyncCommandData commandsV=commandsVValues[commandsVI];
if(commandsV!=null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(commandsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
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.cd);
stream.writeInt(this.keepType);
}