/// <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); }