/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeLong(this.playerID);
if (this.showData != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.showData);
}
else
{
stream.writeBoolean(false);
}
if (this.attribute != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.attribute);
}
else
{
stream.writeBoolean(false);
}
if (this.force != null)
{
stream.writeDataSimpleNotNull(this.force);
}
else
{
nullObjError("force");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.showData != null)
{
stream.writeDataSimpleNotNull(this.showData);
}
else
{
nullObjError("showData");
}
stream.writeBoolean(this.isOnline);
stream.writeLong(this.lastOnlineTime);
if (this.location != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.location);
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.id);
if (this.cache != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.cache);
}
else
{
stream.writeBoolean(false);
}
if (this.equips != null)
{
stream.writeDataSimpleNotNull(this.equips);
}
else
{
nullObjError("equips");
}
stream.writeInt(this.mIndex);
}
/// <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 toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.instanceID);
if (this.identity != null)
{
stream.writeDataSimpleNotNull(this.identity);
}
else
{
nullObjError("identity");
}
if (this.pos != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.pos);
}
else
{
stream.writeBoolean(false);
}
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");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(elementsV);
}
else
{
stream.writeBoolean(false);
}
}
}
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.value != null)
{
stream.writeLen(this.value.size());
if (!this.value.isEmpty())
{
TriggerObjData[] valueVValues = this.value.getValues();
for (int valueVI = 0, valueVLen = this.value.length(); valueVI < valueVLen; ++valueVI)
{
TriggerObjData valueV = valueVValues[valueVI];
if (valueV != null)
{
stream.writeDataSimpleNotNull(valueV);
}
else
{
nullObjError("valueV");
}
}
}
}
else
{
nullObjError("value");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.itemRecords != null)
{
stream.writeLen(this.itemRecords.size());
if (!this.itemRecords.isEmpty())
{
AuctionItemRecordData[] itemRecordsVValues = this.itemRecords.getValues();
for (int itemRecordsVI = itemRecordsVValues.Length - 1; itemRecordsVI >= 0; --itemRecordsVI)
{
AuctionItemRecordData itemRecordsV = itemRecordsVValues[itemRecordsVI];
if (itemRecordsV != null)
{
if (itemRecordsV != null)
{
stream.writeDataSimpleNotNull(itemRecordsV);
}
else
{
nullObjError("itemRecordsV");
}
}
}
}
}
else
{
nullObjError("itemRecords");
}
}
/// <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)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.version);
if (this.list != null)
{
stream.writeLen(this.list.size());
if (!this.list.isEmpty())
{
RankData[] listVValues = this.list.getValues();
for (int listVI = 0, listVLen = this.list.length(); listVI < listVLen; ++listVI)
{
RankData listV = listVValues[listVI];
if (listV != null)
{
stream.writeDataSimpleNotNull(listV);
}
else
{
nullObjError("listV");
}
}
}
}
else
{
nullObjError("list");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
if (this.records != null)
{
stream.writeLen(this.records.size());
if (!this.records.isEmpty())
{
ClientOfflineWorkData[] recordsVValues = this.records.getValues();
for (int recordsVI = 0, recordsVLen = this.records.length(); recordsVI < recordsVLen; ++recordsVI)
{
ClientOfflineWorkData recordsV = recordsVValues[recordsVI];
if (recordsV != null)
{
stream.writeDataSimpleNotNull(recordsV);
}
else
{
nullObjError("recordsV");
}
}
}
}
else
{
nullObjError("records");
}
stream.writeInt(this.clientRandomSeedIndex);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.datas != null)
{
stream.writeLen(this.datas.size());
if (!this.datas.isEmpty())
{
ActivityData[] datasVValues = this.datas.getValues();
for (int datasVI = datasVValues.Length - 1; datasVI >= 0; --datasVI)
{
ActivityData datasV = datasVValues[datasVI];
if (datasV != null)
{
if (datasV != null)
{
stream.writeDataSimpleNotNull(datasV);
}
else
{
nullObjError("datasV");
}
}
}
}
}
else
{
nullObjError("datas");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.signedPlayers != null)
{
stream.writeBoolean(true);
RoleShowData[] signedPlayersT = this.signedPlayers;
stream.writeLen(signedPlayersT.Length);
for (int signedPlayersVI = 0, signedPlayersVLen = signedPlayersT.Length; signedPlayersVI < signedPlayersVLen; ++signedPlayersVI)
{
RoleShowData signedPlayersV = signedPlayersT[signedPlayersVI];
if (signedPlayersV != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(signedPlayersV);
}
else
{
stream.writeBoolean(false);
}
}
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.skillID);
if (this.targetData != null)
{
stream.writeDataSimpleNotNull(this.targetData);
}
else
{
nullObjError("targetData");
}
if (this.posDir != null)
{
this.posDir.writeBytesSimple(stream);
}
else
{
nullObjError("posDir");
}
stream.writeBoolean(this.isSuspend);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
stream.writeInt(this.id);
if (this.tasks != null)
{
TaskData[] tasksT = this.tasks;
stream.writeLen(tasksT.Length);
for (int tasksVI = 0, tasksVLen = tasksT.Length; tasksVI < tasksVLen; ++tasksVI)
{
TaskData tasksV = tasksT[tasksVI];
if (tasksV != null)
{
stream.writeDataSimpleNotNull(tasksV);
}
else
{
nullObjError("tasksV");
}
}
}
else
{
nullObjError("tasks");
}
stream.writeBoolean(this.isFailed);
stream.writeLong(this.enableTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
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.writeDataSimpleNotNull(argsV);
}
else
{
nullObjError("argsV");
}
}
}
else
{
nullObjError("args");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(membersV);
}
else
{
nullObjError("membersV");
}
}
}
}
}
else
{
nullObjError("members");
}
}
/// <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)
{
if (this.queue != null)
{
stream.writeLen(this.queue.size());
if (!this.queue.isEmpty())
{
RoleChatData[] queueVValues = this.queue.getValues();
int queueVMark = this.queue.getMark();
int queueVStart = this.queue.getStart();
for (int queueVI = 0, queueVLen = this.queue.length(); queueVI < queueVLen; ++queueVI)
{
RoleChatData queueV = queueVValues[(queueVI + queueVStart) & queueVMark];
if (queueV != null)
{
stream.writeDataSimpleNotNull(queueV);
}
else
{
nullObjError("queueV");
}
}
}
}
else
{
nullObjError("queue");
}
}
/// <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 toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(listV);
}
else
{
nullObjError("listV");
}
}
}
}
else
{
nullObjError("list");
}
stream.writeInt(this.clientRandomSeedIndex);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(itemsV);
}
else
{
nullObjError("itemsV");
}
}
}
}
else
{
nullObjError("items");
}
stream.writeLong(this.removeTime);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
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.writeDataSimpleNotNull(petDicV);
}
else
{
nullObjError("petDicV");
}
}
}
}
}
else
{
nullObjError("petDic");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
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.writeDataSimpleNotNull(funcListV);
}
else
{
nullObjError("funcListV");
}
}
}
else
{
nullObjError("funcList");
}
}
/// <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)
{
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)
{
if (this.info != null)
{
stream.writeDataSimpleNotNull(this.info);
}
else
{
nullObjError("info");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.identity != null)
{
stream.writeDataSimpleNotNull(this.identity);
}
else
{
nullObjError("identity");
}
if (this.avatar != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.avatar);
}
else
{
stream.writeBoolean(false);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
if (this.hero != null)
{
stream.writeBoolean(true);
stream.writeDataSimpleNotNull(this.hero);
}
else
{
stream.writeBoolean(false);
}
}