/// <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);
}
/** 写入流 */
public void write(BytesWriteStream stream)
{
stream.writeFloat(agentHeight);
stream.writeFloat(agentRadius);
stream.writeFloat(agentMaxClimb);
stream.writeFloat(agentMaxSlope);
stream.writeFloat(dropHeight);
stream.writeFloat(jumpDistance);
stream.writeFloat(tileSize);
stream.writeFloat(cellSize);
stream.writeFloat(regionMinSize);
stream.writeFloat(edgeMaxError);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.instanceID);
stream.writeInt(this.id);
if (this.args != null)
{
float[] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
float argsV = argsT[argsVI];
stream.writeFloat(argsV);
}
}
else
{
nullObjError("args");
}
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.type);
if (this.args != null)
{
float[] argsT = this.args;
stream.writeLen(argsT.Length);
for (int argsVI = 0, argsVLen = argsT.Length; argsVI < argsVLen; ++argsVI)
{
float argsV = argsT[argsVI];
stream.writeFloat(argsV);
}
}
else
{
nullObjError("args");
}
stream.writeInt(this.motionID);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
base.toWriteBytesFull(stream);
stream.startWriteObj();
stream.writeFloat(this.value);
stream.endWriteObj();
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeFloat(this.radio);
stream.writeInt(this.motionID);
}
/// <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 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);
stream.writeUTF(this.name);
stream.writeInt(this.attackID);
stream.writeFloat(this.maxEnableDistance);
stream.writeBoolean(this.needRecordValue);
stream.writeBoolean(this.keepAtMaxHit);
stream.writeBoolean(this.cantAbsorb);
stream.writeInt(this.hitDelay);
if (this.castOff != null)
{
float[] castOffT = this.castOff;
stream.writeLen(castOffT.Length);
for (int castOffVI = 0, castOffVLen = castOffT.Length; castOffVI < castOffVLen; ++castOffVI)
{
float castOffV = castOffT[castOffVI];
stream.writeFloat(castOffV);
}
}
else
{
nullObjError("castOff");
}
stream.writeInt(this.castPoint);
stream.writeInt(this.effectID);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeBoolean(this.isOnce);
stream.writeBoolean(this.isSME);
stream.writeBoolean(this.isSyncDirection);
stream.writeInt(this.plusMax);
stream.writeUTF(this.source);
stream.writeUTF(this.sound);
stream.writeFloat(this.heightOff);
}
/// <summary>
/// 写入字节流(完整版)
/// </summary>
protected override void toWriteBytesFull(BytesWriteStream stream)
{
stream.startWriteObj();
stream.writeInt(this.index);
stream.writeInt(this.type);
if (this.ints != null)
{
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
{
nullObjError("ints");
}
if (this.floats != null)
{
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
{
nullObjError("floats");
}
stream.endWriteObj();
}
/** 写入流 */
public void write(BytesWriteStream stream)
{
stream.writeInt(originX);
stream.writeInt(originZ);
stream.writeInt(sizeX);
stream.writeInt(sizeZ);
stream.writeFloat(tileSize);
stream.writeVector3(min);
stream.writeVector3(max);
if (terrain != null)
{
stream.writeBoolean(true);
terrain.write(stream);
}
else
{
stream.writeBoolean(false);
}
int len = meshList.size();
SceneRecastMeshData[] values = meshList.getValues();
stream.writeLen(len);
for (int i = 0; i < len; i++)
{
values[i].write(stream);
}
len = objList.size();
SceneRecastObjData[] values2 = objList.getValues();
stream.writeLen(len);
for (int i = 0; i < len; i++)
{
values2[i].write(stream);
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.motionID);
stream.writeInt(this.motionTime);
if (this.bindPoints != null)
{
float[][] bindPointsT = this.bindPoints;
stream.writeLen(bindPointsT.Length);
for (int bindPointsVI = 0, bindPointsVLen = bindPointsT.Length; bindPointsVI < bindPointsVLen; ++bindPointsVI)
{
float[] bindPointsV = bindPointsT[bindPointsVI];
if (bindPointsV != null)
{
float[] bindPointsVT = bindPointsV;
stream.writeLen(bindPointsVT.Length);
for (int bindPointsVVI = 0, bindPointsVVLen = bindPointsVT.Length; bindPointsVVI < bindPointsVVLen; ++bindPointsVVI)
{
float bindPointsVV = bindPointsVT[bindPointsVVI];
stream.writeFloat(bindPointsVV);
}
}
else
{
nullObjError("bindPointsV");
}
}
}
else
{
nullObjError("bindPoints");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
if (this.allowMoveType != null)
{
int[] allowMoveTypeT = this.allowMoveType;
stream.writeLen(allowMoveTypeT.Length);
for (int allowMoveTypeVI = 0, allowMoveTypeVLen = allowMoveTypeT.Length; allowMoveTypeVI < allowMoveTypeVLen; ++allowMoveTypeVI)
{
int allowMoveTypeV = allowMoveTypeT[allowMoveTypeVI];
stream.writeInt(allowMoveTypeV);
}
}
else
{
nullObjError("allowMoveType");
}
stream.writeFloat(this.groundFriction);
}
/// <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.sceneID);
stream.writeInt(this.instanceID);
stream.writeInt(this.type);
if (this.pos != null)
{
float[] posT = this.pos;
stream.writeLen(posT.Length);
for (int posVI = 0, posVLen = posT.Length; posVI < posVLen; ++posVI)
{
float posV = posT[posVI];
stream.writeFloat(posV);
}
}
else
{
nullObjError("pos");
}
stream.writeInt(this.id);
stream.writeInt(this.level);
stream.writeInt(this.force);
stream.writeBoolean(this.isInitAdd);
if (this.iArgs != null)
{
int[] iArgsT = this.iArgs;
stream.writeLen(iArgsT.Length);
for (int iArgsVI = 0, iArgsVLen = iArgsT.Length; iArgsVI < iArgsVLen; ++iArgsVI)
{
int iArgsV = iArgsT[iArgsVI];
stream.writeInt(iArgsV);
}
}
else
{
nullObjError("iArgs");
}
if (this.fArgs != null)
{
float[] fArgsT = this.fArgs;
stream.writeLen(fArgsT.Length);
for (int fArgsVI = 0, fArgsVLen = fArgsT.Length; fArgsVI < fArgsVLen; ++fArgsVI)
{
float fArgsV = fArgsT[fArgsVI];
stream.writeFloat(fArgsV);
}
}
else
{
nullObjError("fArgs");
}
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeInt(this.attackRange);
stream.writeInt(this.modelID);
stream.writeInt(this.effectID);
stream.writeInt(this.vocation);
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.deathKeepTime);
stream.writeInt(this.reviveWaitTime);
stream.writeInt(this.reviveType);
stream.writeBoolean(this.isWanderOnIdle);
stream.writeInt(this.defaultAIMode);
stream.writeInt(this.defaultAICommand);
stream.writeFloat(this.initiativeAttackRadius);
stream.writeFloat(this.passiveAttackRadius);
stream.writeFloat(this.maxPursueRadius);
stream.writeFloat(this.wakeUpCompanionAttackRadius);
stream.writeFloat(this.followRadius);
if (this.attackInfluenceType != null)
{
int[] attackInfluenceTypeT = this.attackInfluenceType;
stream.writeLen(attackInfluenceTypeT.Length);
for (int attackInfluenceTypeVI = 0, attackInfluenceTypeVLen = attackInfluenceTypeT.Length; attackInfluenceTypeVI < attackInfluenceTypeVLen; ++attackInfluenceTypeVI)
{
int attackInfluenceTypeV = attackInfluenceTypeT[attackInfluenceTypeVI];
stream.writeInt(attackInfluenceTypeV);
}
}
else
{
nullObjError("attackInfluenceType");
}
stream.writeInt(this.mapMoveType);
stream.writeFloat(this.walkSpeedRatio);
stream.writeBoolean(this.needDrive);
stream.writeFloat(this.driveAngleSpeed);
stream.writeInt(this.driveAccelerateSpeed);
stream.writeFloat(this.driveTurnRadius);
stream.writeBoolean(this.canDriveTurnAtPivot);
stream.writeBoolean(this.needHateSwitchTarget);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeFloat(this.value);
}
/// <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.driveConditions != null)
{
int[][] driveConditionsT = this.driveConditions;
stream.writeLen(driveConditionsT.Length);
for (int driveConditionsVI = 0, driveConditionsVLen = driveConditionsT.Length; driveConditionsVI < driveConditionsVLen; ++driveConditionsVI)
{
int[] driveConditionsV = driveConditionsT[driveConditionsVI];
if (driveConditionsV != null)
{
int[] driveConditionsVT = driveConditionsV;
stream.writeLen(driveConditionsVT.Length);
for (int driveConditionsVVI = 0, driveConditionsVVLen = driveConditionsVT.Length; driveConditionsVVI < driveConditionsVVLen; ++driveConditionsVVI)
{
int driveConditionsVV = driveConditionsVT[driveConditionsVVI];
stream.writeInt(driveConditionsVV);
}
}
else
{
nullObjError("driveConditionsV");
}
}
}
else
{
nullObjError("driveConditions");
}
if (this.driveActions != null)
{
int[][] driveActionsT = this.driveActions;
stream.writeLen(driveActionsT.Length);
for (int driveActionsVI = 0, driveActionsVLen = driveActionsT.Length; driveActionsVI < driveActionsVLen; ++driveActionsVI)
{
int[] driveActionsV = driveActionsT[driveActionsVI];
if (driveActionsV != null)
{
int[] driveActionsVT = driveActionsV;
stream.writeLen(driveActionsVT.Length);
for (int driveActionsVVI = 0, driveActionsVVLen = driveActionsVT.Length; driveActionsVVI < driveActionsVVLen; ++driveActionsVVI)
{
int driveActionsVV = driveActionsVT[driveActionsVVI];
stream.writeInt(driveActionsVV);
}
}
else
{
nullObjError("driveActionsV");
}
}
}
else
{
nullObjError("driveActions");
}
stream.writeFloat(this.driveOnRadius);
stream.writeInt(this.driverNum);
}
/// <summary>
/// 写入字节流(简版)
/// </summary>
protected override void toWriteBytesSimple(BytesWriteStream stream)
{
base.toWriteBytesSimple(stream);
stream.writeInt(this.id);
stream.writeUTF(this.name);
if (this.operateConditions != null)
{
int[][] operateConditionsT = this.operateConditions;
stream.writeLen(operateConditionsT.Length);
for (int operateConditionsVI = 0, operateConditionsVLen = operateConditionsT.Length; operateConditionsVI < operateConditionsVLen; ++operateConditionsVI)
{
int[] operateConditionsV = operateConditionsT[operateConditionsVI];
if (operateConditionsV != null)
{
int[] operateConditionsVT = operateConditionsV;
stream.writeLen(operateConditionsVT.Length);
for (int operateConditionsVVI = 0, operateConditionsVVLen = operateConditionsVT.Length; operateConditionsVVI < operateConditionsVVLen; ++operateConditionsVVI)
{
int operateConditionsVV = operateConditionsVT[operateConditionsVVI];
stream.writeInt(operateConditionsVV);
}
}
else
{
nullObjError("operateConditionsV");
}
}
}
else
{
nullObjError("operateConditions");
}
if (this.operateActions != null)
{
int[][] operateActionsT = this.operateActions;
stream.writeLen(operateActionsT.Length);
for (int operateActionsVI = 0, operateActionsVLen = operateActionsT.Length; operateActionsVI < operateActionsVLen; ++operateActionsVI)
{
int[] operateActionsV = operateActionsT[operateActionsVI];
if (operateActionsV != null)
{
int[] operateActionsVT = operateActionsV;
stream.writeLen(operateActionsVT.Length);
for (int operateActionsVVI = 0, operateActionsVVLen = operateActionsVT.Length; operateActionsVVI < operateActionsVVLen; ++operateActionsVVI)
{
int operateActionsVV = operateActionsVT[operateActionsVVI];
stream.writeInt(operateActionsVV);
}
}
else
{
nullObjError("operateActionsV");
}
}
}
else
{
nullObjError("operateActions");
}
stream.writeFloat(this.radius);
stream.writeBoolean(this.isOnce);
stream.writeInt(this.modelID);
}