@shijiu/jsview-vue 2.1.25 → 2.1.200

package/utils/JsViewVueWidget/JsvFreeMoveActor/SetAction.ts

@@ -0,0 +1,553 @@
+/*
+ * @Author: donglin.lu@qcast.cn
+ * @Date: 2023-07-18 11:14:00
+ * @LastEditors: donglin.lu@qcast.cn
+ * @Description: file content
+ */
+
+import { ConditionSetBuilder, StateCmdBuilder, CmdPackBuilder, ActionCmdBuilder } from "./ForgeTypeDefine"
+import { ActEventDefine } from "./ForgeTypeDefine"
+import { GroupType_ActionAssoc } from "./ForgeTypeDefine"
+import CallbackManager from "./CallbackManager";
+import ActionRefObject from "./ActionRefObject";
+import ActorState from "./ActorState";
+
+const ConditionCmdCreator = (
+  builderThis: ActorPackBuilder,
+  setCondFunc: Function, // 条件创建处理
+  acts: Array<Object> | null, // 条件达成后的命令列表
+  isFinal: boolean,  // 用于进行结束时清理临时condition
+  callback: Function | null  // 达到条件后的callback
+) => {
+  let commonInfo = ConditionSetBuilder.InitCommonInfo();
+  ConditionSetBuilder.UpdateCommonInfo(commonInfo, GroupType_ActionAssoc);
+
+  // 创建位置条件
+  let conditionSet: Object = setCondFunc(commonInfo);;
+
+  let conditionSubCmds: Array<Object> = acts ? acts : [];
+
+  // 设置达到条件后的callback
+  if (callback) {
+    // callback接受参数为({xPos, yPos, xSpd, ySpd, xAcc, yAcc})
+    conditionSubCmds.push(builderThis._CallbackManager.buildCallbackCmd(callback));
+  }
+
+  if (isFinal) {
+    // 结束时清理临时condition
+    conditionSubCmds.push(StateCmdBuilder.DelActionAssocCondition());
+  }
+
+  // 挂载设置好的Sub command list
+  if (conditionSubCmds.length > 0) {
+    ConditionSetBuilder.SetCmdList(conditionSet, conditionSubCmds);
+  }
+
+  return StateCmdBuilder.NewCondition(conditionSet);
+}
+
+const ActOnActEvent = (
+  builderThis: ActorPackBuilder,
+  jsRefToken: number,
+  eventType: number,
+  acts: Array<Object> | null,
+  isFinal: boolean,
+  callback: Function): Object => {
+  return ConditionCmdCreator(builderThis, (commonInfo: Object) => {
+    return ConditionSetBuilder.OnActEvent(jsRefToken, eventType, commonInfo);
+  }, acts, isFinal, callback)
+}
+
+const ActOnReachPosition = (
+  builderThis: ActorPackBuilder,
+  xPos: number | undefined,
+  yPos: number | undefined,
+  acts: Array<Object> | null,
+  isFinal: boolean,
+  callback: Function | null
+): Object => {
+  return ConditionCmdCreator(builderThis, (commonInfo: Object) => {
+    return ConditionSetBuilder.ReachPosition(xPos, yPos, commonInfo);
+  }, acts, isFinal, callback);
+}
+
+const ActOnGetToSpeed = (
+  builderThis: ActorPackBuilder,
+  xSpeed: number | undefined,
+  ySpeed: number | undefined,
+  acts: Array<Object> | null,
+  isFinal: boolean,
+  callback: Function | null
+): Object => {
+  return ConditionCmdCreator(builderThis, (commonInfo: Object): Object => {
+    return ConditionSetBuilder.ReachSpeed(xSpeed, ySpeed, commonInfo);
+  }, acts, isFinal, callback);
+}
+
+const ActOnGetAcrossSpeed = (
+  builderThis: ActorPackBuilder,
+  xSpeed: number | undefined,
+  ySpeed: number | undefined,
+  acts: Array<Object> | null,
+  isFinal: boolean,
+  callback: Function | null
+): Object => {
+  return ConditionCmdCreator(builderThis, (commonInfo: Object): Object => {
+    return ConditionSetBuilder.AcrossSpeed(xSpeed, ySpeed, commonInfo);
+  }, acts, isFinal, callback);
+}
+
+class ActorPackBuilder {
+  public _CallbackManager: CallbackManager;
+  private _ActionTokenGen: number;
+
+  private _SpeedKeeps: number;
+  private _AccKeeps: number;
+  private _RefObj: ActionRefObject | null;
+  private _CommonInfoValid: boolean;
+
+  constructor(callbackManager: CallbackManager) {
+    this._CallbackManager = callbackManager;
+
+    this._ActionTokenGen = 1; // 自累加的token分发器, 预留0作为无效值判断
+
+    // 下一个Act指令时所保留的状态
+    this._SpeedKeeps = 0;
+    this._AccKeeps = 0;
+    this._RefObj = null;
+    this._CommonInfoValid = false;
+  }
+
+  public updateCommonInfo(
+    xySpdEnables: number,
+    xyAccEnables: number,
+    actRefObj: ActionRefObject | null
+  ) {
+    this._SpeedKeeps = xySpdEnables;
+    this._AccKeeps = xyAccEnables;
+    this._RefObj = actRefObj;
+
+    // 如果有refobj,则分发token
+    this._InitActRefObj(this._RefObj);
+
+    this._CommonInfoValid = true;
+  }
+
+  private _InitActRefObj(refObj: ActionRefObject | null) {
+    if (refObj) {
+      if (refObj.used) {
+        console.warn("Warn: actRef be overrided, old token=" + refObj.token);
+      }
+      refObj.token = this._ActionTokenGen++;
+      refObj.used = false;
+    }
+  }
+
+  private _CheckCommonInfo(): boolean {
+    if (!this._CommonInfoValid) {
+      console.error("Error: must call from new action()");
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * teleportTo 将Actor在下一帧直接传送到目标位置
+   * 注意点: 此过程可以触发所有position的cross条件，但不会触发speed的相关判断，常用于拖拽 + 边界判断
+   * 
+   * @param {int} targetX 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @param {int} targetY 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @return CommandPack(放入run或者then的CmdPackList队列)
+   */
+  public teleportTo(
+    targetX: number | undefined,
+    targetY: number | undefined,
+  ) {
+    if (!this._BasicPreProcess("teleportTo")) {
+      return;
+    }
+
+    return this._TeleportToInner(targetX, targetY, false);
+  }
+
+  /**
+   * teleportOffset 将Actor在下一帧直接传送到目标位置
+   * 注意点: 此过程可以触发所有position的cross条件，但不会触发speed的相关判断，常用于拖拽 + 边界判断
+   * 
+   * @param {int} offsetX 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @param {int} offsetY 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @return CommandPack(放入run或者then的CmdPackList队列)
+   */
+  public teleportOffset(
+    offsetX: number | undefined,
+    offsetY: number | undefined,
+  ) {
+    if (!this._BasicPreProcess("teleportOffset")) {
+      return;
+    }
+
+    return this._TeleportToInner(offsetX, offsetY, true);
+  }
+
+  /**
+   * moveTo 以给定速度移动到目标位置
+   * 
+   * @param {int} targetX 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @param {int} targetY 带符号整数，标识运动的目标位置，相对于Actor当前位置, 如果设置为undefined, 则表示该轴不设目标
+   * @param {double} xSpeed 运行速度，使用时会自动取绝对值，单位(pixel/帧), 
+   *                       undefined时，若targetX设置, 则以另一轴速度反推此速度, 否则不改变该轴速度
+   * @param {double} ySpeed 运行速度，使用时会自动取绝对值，单位(pixel/帧)
+   *                       undefined时，若targetY设置, 则以另一轴速度反推此速度, 否则不改变该轴速度
+   * @param {function} endCallback 参数(x, y) 运动到目标位置后的回调函数, x或者y达到后即回调，以先到为准，回报当前Actor的相对于原始位置的x,y
+   * @return CommandPack(放入run或者then的CmdPackList队列)
+   */
+  public moveTo(
+    targetX: number | undefined,
+    targetY: number | undefined,
+    xSpeed: number | undefined,
+    ySpeed: number | undefined,
+    endCallback: Function | null = null
+  ) {
+    if (!this._BasicPreProcess("moveTo")) {
+      return;
+    }
+
+    // x, y 都没有速度, 无内容
+    if (!xSpeed && !ySpeed) {
+      return null;
+    }
+
+    // 处理步骤备忘:
+    // 1. 构造 command list (cmdList), 加入通过 ActionCmdBuilder 构建的各种改变速度的行为
+    // 2. 构筑结束的条件处理(包含回调和 delActionAssocCondtion 动作), 通过 StateCmdBuilder.NewCondtion 创建并加入 cmdList
+    // 3. 通过 CmdPackBuilder.InitActCmdPack，送入 cmdList 和预设好的keep, 完成commandPack构建
+
+    let cmdList: Array<Object> = [];
+
+    // 设置运动速度
+    cmdList.push(ActionCmdBuilder.SetArrowSpeed(targetX, targetY, xSpeed, ySpeed));
+
+    // 设置达到目标位置的condition
+    cmdList.push(
+      ActOnReachPosition(
+        this,
+        targetX, targetY,
+        [ActionCmdBuilder.StopMovingExact(),
+        this._RefObj ? StateCmdBuilder.FireActEvent(ActEventDefine.ActFinish, this._RefObj.token) : null
+        ],
+        true,
+        endCallback ? (actorState: ActorState) => {
+          endCallback?.(actorState.xPos, actorState.yPos);
+        } : null
+      )
+    );
+
+    //return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, cmdList);
+
+    let c = CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+    return c;
+  }
+
+  /*
+   * altSpeed 调整速度，costTime不为0时为平滑过渡
+   * 参数说明:
+   *      xSpeed      (double) 带符号整数，符号表示方向，标识运动的运行速度，单位(pixel/帧), 可设undefined代表不改变该轴速度
+   *      ySpeed      (double) 带符号整数，符号表示方向，标识运动的运行速度，单位(pixel/帧), 可设undefined代表不改变该轴速度
+   *      spreadFrame    (int) 选填，正整数, 变速需要经历帧数, 若为立即变速，则设置为0，或者不再设置(undefined)
+   *      finishCallback (Function(xSpeed, ySpeed)) 选填，达到目标速度后的回调，当costTime不为0时有效
+   */
+  altSpeed(
+    xSpeed: number | undefined,
+    ySpeed: number | undefined,
+    spreadFrame: number | undefined,
+    finishCallback: Function | null = null
+  ) {
+    if (!this._BasicPreProcess("altSpeed")) {
+      return;
+    }
+
+    // 处理步骤备忘:
+    // 1. 构造 command list (cmdList), 加入通过 ActionCmdBuilder 构建的各种改变速度的行为
+    // 2. 构筑结束的条件处理(包含回调和 delActionAssocCondtion 动作), 通过 StateCmdBuilder.NewCondtion 创建并加入 cmdList
+    // 3. 通过 CmdPackBuilder.InitActCmdPack，送入 cmdList 和预设好的keep, 完成commandPack构建
+
+    let cmdList: Array<Object> = [];
+
+    if (isNaN(spreadFrame as number) || spreadFrame == 0) {
+      // 经历的帧数为0, 即为立即变速
+      cmdList.push(ActionCmdBuilder.SetSpeed(xSpeed, ySpeed));
+      return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+    } else {
+      // 均匀变速逻辑
+      cmdList.push(ActionCmdBuilder.AltSpeed(xSpeed, ySpeed, spreadFrame));
+
+      // 创建结束ConditionSet
+      cmdList.push(
+        ActOnGetToSpeed(
+          this,
+          xSpeed, ySpeed,
+          [ActionCmdBuilder.ResetAcc(0, 0),
+          this._RefObj ? StateCmdBuilder.FireActEvent(ActEventDefine.ActFinish, this._RefObj.token) : null
+          ],
+          true, // isFinal
+          finishCallback ? (actorState: ActorState) => {
+            finishCallback(actorState.xSpd, actorState.ySpd);
+          } : null
+        )
+      )
+
+      return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+    }
+  }
+
+  /*
+   * brakeToPosition 以当前速度开始，减速并停止到目标位置
+   * 参数说明:
+   *      targetX      (int) 带符号整数，目标运动终点位置，如果设置为undefined，标识不以此轴为终点
+   *      targetY      (int) 带符号整数，目标运动终点位置，如果设置为undefined，标识不以此轴为终点
+   *      finishCallback  (Function(x,y)) 运动到目标位置后的回调函数, x或者y达到后即回调，以先到为准，回报当前Actor的相对于原始位置的x,y
+   *      rejectedCallback  (Function()) 当前速度无法达到target位置时，回调此函数，然后放弃改变任何速度和加速度
+   */
+  brakeToPosition(
+    targetX: number | undefined,
+    targetY: number | undefined,
+    finishCallback: Function | null = null,
+    rejectedCallback: Function | null = null
+  ) {
+    // brakeToPosition 的设计
+    // 1. 由native根据当前的速度值和目标位置，计算出正好能停止到目标点的减速度
+    // 2. 监控native发出的内部事件 ActFinish (所以需要 ActionRefObject 的token进行动作对齐)
+    // 3. 当收到 ActFinish, 回调callback，标识动作完成
+    // 特别注意: 存在有可能以当前speed无法到达target的情况，此时由native判断出，
+
+    if (!this._RefObj) {
+      // 此动作的结束由native来判断和决定
+      // 要跟踪native的 ActFinish 事件
+      this._RefObj = { token: 0, used: false };
+      this._InitActRefObj(this._RefObj);
+    }
+
+    if (!this._BasicPreProcess("brakeToPosition")) {
+      return;
+    }
+
+    // 处理步骤备忘:
+    // 1. 构造 command list (cmdList), 加入通过 ActionCmdBuilder 构建的各种改变速度的行为
+    // 2. 构筑结束的条件处理(包含回调和 delActionAssocCondtion 动作), 通过 StateCmdBuilder.NewCondtion 创建并加入 cmdList
+    // 3. 通过 CmdPackBuilder.InitActCmdPack，送入 cmdList 和预设好的keep, 完成commandPack构建
+
+    let cmdList: Array<Object> = [];
+
+    // 通过targetX和targetY以及内部当前的 xSpeed 和 ySpeed 状态，计算 xAcc 和 yAcc, 使运动接近目标位置时停止
+    cmdList.push(ActionCmdBuilder.BrakeToPos(targetX, targetY));
+
+    // 创建结束ConditionSet(ActFinish)
+    cmdList.push(
+      ActOnActEvent(
+        this,
+        this._RefObj.token,
+        ActEventDefine.ActFinish,
+        null,
+        true,
+        (actorState: ActorState) => {
+          finishCallback?.(actorState.xPos, actorState.yPos);
+        }
+      )
+    );
+
+    // 创建结束ConditionSet(ActReject)
+    cmdList.push(
+      ActOnActEvent(
+        this,
+        this._RefObj.token,
+        ActEventDefine.ActReject,
+        null,
+        true,
+        () => {
+          rejectedCallback?.();
+        }
+      )
+    );
+
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+  }
+
+
+  /*
+   * setSpeed 
+   * 调整运行速度，立刻生效
+   * 
+   * 参数说明:
+   *      spdX      (double) x 速度有效值，可正可负, 每帧的posX移动量, 可以传入undefined来决定此值不设置
+   *      spdY      (double) y 速度有效值，可正可负, 每帧的posY移动量, 可以传入undefined来决定此值不设置
+   */
+  setSpeed(
+    spdX: number | undefined,
+    spdY: number | undefined,
+  ) {
+    if (!this._BasicPreProcess("setSpeed")) {
+      return;
+    }
+
+    let cmdList: Array<Object> = [];
+    cmdList.push(ActionCmdBuilder.SetSpeed(spdX, spdY));
+
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+  }
+
+  /*
+   * setSpeed 
+   * 调整运行速度，立刻生效
+   * 
+   * 参数说明:
+   *      spdX      (double) x 速度有效值，可正可负, 每帧的posX移动量, 可以传入undefined来决定此值不设置
+   *      spdY      (double) y 速度有效值，可正可负, 每帧的posY移动量, 可以传入undefined来决定此值不设置
+   */
+  setAccel(
+    accelX: number | undefined,
+    accelY: number | undefined,
+    onRevertX: Function | null = null,
+    onRevertY: Function | null = null
+  ) {
+    if (!this._BasicPreProcess("setAccel")) {
+      return;
+    }
+
+    // 处理步骤备忘:
+    // 1. 构造 command list (cmdList), 加入通过 ActionCmdBuilder 构建的各种改变速度的行为
+    // 2. 构筑结束的条件处理(包含回调和 delActionAssocCondtion 动作), 通过 StateCmdBuilder.NewCondtion 创建并加入 cmdList
+    // 3. 通过 CmdPackBuilder.InitActCmdPack，送入 cmdList 和预设好的keep, 完成commandPack构建
+
+    let cmdList: Array<Object> = [];
+    cmdList.push(ActionCmdBuilder.SetAccel(accelX, accelY));
+
+    // 创建拐点的condition回调
+    this._BuildAccelOnPole(this, cmdList, this._RefObj, onRevertX, onRevertY);
+
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+  }
+
+  /*
+   * setSpdAndAccel 
+   * 同时设置速度和加速度，并提供拐点回调(用于抛物线处理)
+   * 
+   * 参数说明:
+   *      spdX      (double) x 速度有效值，可正可负, 每帧的posX移动量, 可以传入undefined来决定此值不设置
+   *      spdY      (double) y 速度有效值，可正可负, 每帧的posY移动量, 可以传入undefined来决定此值不设置
+   *      accelX    (double) 加速度有效值，可正可负，每帧spdX的调整量，可以传入undefined来决定此值不设置
+   *      accelY    (double) 加速度有效值，可正可负，每帧spdY的调整量，可以传入undefined来决定此值不设置
+   *      onRevertX (function) x速度开始反向运动时，进行回调(例如抛物到达顶点)
+   *      onRevertY (function) y速度开始反向运动时，进行回调(例如抛物到达顶点)
+   */
+  setSpdAndAccel(
+    spdX: number | undefined,
+    spdY: number | undefined,
+    accelX: number | undefined,
+    accelY: number | undefined,
+    onRevertX: Function | null = null,
+    onRevertY: Function | null = null
+  ) {
+    if (!this._BasicPreProcess("setSpdAndAccel")) {
+      return;
+    }
+
+    // 处理步骤备忘:
+    // 1. 构造 command list (cmdList), 加入通过 ActionCmdBuilder 构建的各种改变速度的行为
+    // 2. 构筑结束的条件处理(包含回调和 delActionAssocCondtion 动作), 通过 StateCmdBuilder.NewCondtion 创建并加入 cmdList
+    // 3. 通过 CmdPackBuilder.InitActCmdPack，送入 cmdList 和预设好的keep, 完成commandPack构建
+
+    let cmdList: Array<Object> = [];
+
+    // 设置速度和加速度值
+    cmdList.push(ActionCmdBuilder.SetSpeed(spdX, spdY));
+    cmdList.push(ActionCmdBuilder.SetAccel(accelX, accelY));
+
+    // 创建拐点的condition回调
+    this._BuildAccelOnPole(this, cmdList, this._RefObj, onRevertX, onRevertY);
+
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+  }
+
+  /*
+   * stopMoving
+   * 停止运动
+   *      isExact (boolean) 设置为true时, 如果在positionCondition中会按照condition的位置进行精准停止
+   */
+  stopMoving(
+    isExact: boolean = true
+  ) {
+    if (!this._BasicPreProcess("stopMoving")) {
+      return;
+    }
+
+    let cmdList: Array<Object> = [];
+    cmdList.push(isExact ? ActionCmdBuilder.StopMovingExact() : ActionCmdBuilder.StopMoving());
+
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+  }
+
+  _BuildAccelOnPole(
+    builderThis: ActorPackBuilder,
+    cmdList: Array<Object>,
+    actRefObj: ActionRefObject | null,
+    onRevertX: Function | null,
+    onRevertY: Function | null
+  ) {
+    if (actRefObj || onRevertX || onRevertY) {
+      // RefObj: 外界可能希望了解速度拐点的ActEvent
+      // onRevertX || onRevertY: 通过callback希望了解速度拐点信息
+
+      // X轴拐点检测 newCondition
+      cmdList.push(
+        ActOnGetAcrossSpeed(
+          builderThis,
+          0, undefined,
+          [actRefObj ? StateCmdBuilder.FireActEvent(ActEventDefine.SpeedRevertX, actRefObj.token) : null],
+          false, // isFinal
+          onRevertX ? () => {
+            onRevertX();
+          } : null
+        )
+      )
+
+      // Y轴拐点检测 newCondition
+      cmdList.push(
+        ActOnGetAcrossSpeed(
+          builderThis,
+          undefined, 0,
+          [actRefObj ? StateCmdBuilder.FireActEvent(ActEventDefine.SpeedRevertY, actRefObj.token) : null],
+          false, // isFinal
+          onRevertY ? () => {
+            onRevertY();
+          } : null
+        )
+      )
+    }
+  }
+
+  _BasicPreProcess(procName: string) {
+    // CommonInfo 只能使用一次，规避多次使用问题
+    if (!this._CheckCommonInfo()) {
+      return false;
+    }
+    this._CommonInfoValid = false;
+
+    if (this._RefObj) {
+      this._RefObj.used = true;
+    }
+
+    return true;
+  }
+
+  private _TeleportToInner(x: number | undefined, y: number | undefined, isOffset: boolean = false) {
+    let cmdList: Array<Object> = [];
+
+    // 传送动作
+    cmdList.push(ActionCmdBuilder.TeleportTo(x, y, isOffset));
+
+    let c = CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._RefObj?.token, cmdList);
+    return c;
+  }
+}
+
+export default ActorPackBuilder;

package/utils/JsViewVueWidget/JsvFreeMoveActor/SetCondition.ts

@@ -0,0 +1,138 @@
+/*
+ * @Author: donglin.lu@qcast.cn
+ * @Date: 2023-07-18 11:14:00
+ * @LastEditors: donglin.lu@qcast.cn
+ * @Description: file content
+ */
+
+import ActionRefObject from "./ActionRefObject";
+import CallbackManager from "./CallbackManager";
+import { ConditionSetBuilder, StateCmdBuilder, CmdPackBuilder } from "./ForgeTypeDefine"
+
+const setChildCommnadPackList = (conditionSet: Object, callbackManager: CallbackManager, cmdPackList: Array<Object>) => {
+  for (let i = 0; i < cmdPackList.length; i++) {
+    if (typeof cmdPackList[i] == "function") {
+      // 将回调函数更换为对应CommandPack, 内容为 FireEcho 的 stateCommand
+      cmdPackList[i] = CmdPackBuilder.InitStateCmdPack(callbackManager.buildCallbackCmd(cmdPackList[i] as Function));
+    }
+  }
+
+  // 将此cmdPackList设置给ConditionSet
+  ConditionSetBuilder.SetCmdPackList(conditionSet, cmdPackList);
+}
+
+class ConditionPackBuilder {
+  public _Callbacks: CallbackManager;
+  private _CommonInfo: Object;
+  private _CommonInfoValid: boolean;
+
+  constructor(callbackManager) {
+    this._Callbacks = callbackManager;
+    this._CommonInfo = ConditionSetBuilder.InitCommonInfo();
+    this._CommonInfoValid = false;
+  }
+
+  updateCommandInfo(group: number, multiTimes: boolean, specName: string | null) {
+    ConditionSetBuilder.UpdateCommonInfo(this._CommonInfo, group, multiTimes, specName);
+    this._CommonInfoValid = true;
+  }
+
+  /**
+   * reachPosition
+   * 获取 ReachPosition 的condition
+   * x或y已经处于，或者被越过时触发
+   * 
+   * @param {double} xPosition 位置有效值，可以传入undefined来决定此值不设置
+   * @param {double} yPosition 位置有效值，可以传入undefined来决定此值不设置
+   */
+  reachPosition(xPosition: number | undefined, yPosition: number | undefined): Object | null {
+    // CommonInfo 只能使用一次，规避多次使用问题
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+
+    return this._BuildPack(ConditionSetBuilder.ReachPosition(xPosition, yPosition, this._CommonInfo));
+  }
+
+  /**
+   * AcrossPosition
+   * 获取 AcrossPosition 的condition
+   * x或y被越过时触发
+   * 
+   * @param {double} xPosition 位置有效值，可以传入undefined来决定此值不设置
+   * @param {double} yPosition 位置有效值，可以传入undefined来决定此值不设置
+   */
+  acrossPosition(xPosition: number | undefined, yPosition: number | undefined): Object | null {
+    // CommonInfo 只能使用一次，规避多次使用问题
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+
+    return this._BuildPack(ConditionSetBuilder.AcrossPosition(xPosition, yPosition, this._CommonInfo));
+  }
+
+  /**
+   * OnActEvent
+   * 响应 actRef 关联的 action 所发出的内部状态信息
+   * 
+   * @param {ActionRefObject} actRef 一个进行Action时传给action的空的{}, 内容被action内部填写
+   * @param {ActEventDefine} eventType 监听的事件类型
+   */
+  onActEvent(actRef: ActionRefObject, eventType: number): Object | null {
+    // CommonInfo 只能使用一次，规避多次使用问题
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+
+    if (isNaN(actRef?.token) || isNaN(eventType)) {
+      // 类型不符合
+      console.error("onActEvent params error", actRef, eventType);
+      return null;
+    }
+
+    return this._BuildPack(ConditionSetBuilder.OnActEvent(actRef.token, eventType, this._CommonInfo));
+  }
+
+  /**
+   * OnHitBlock
+   * 监听Actor关联的LayoutView与blocker碰撞的状态
+   * 碰撞发生后，可以 State.revertWithHitBlock 将LayoutView返回到紧贴到碰撞点的状态
+   * 
+   * @param {Number} blkGID 想监听的blocker集群的组ID, 例如所有的跳板横向碰撞面，或者所有的跳板边缘的纵向碰撞面, 0为无效值
+   */
+  OnHitBlock(blkGID: Number) {
+    // CommonInfo 只能使用一次，规避多次使用问题
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+
+    return this._BuildPack(ConditionSetBuilder.OnHitBlock(blkGID, this._CommonInfo));
+  }
+
+  _CheckCommonInfo(): boolean {
+    if (!this._CommonInfoValid) {
+      console.error("Error: must call from new conditoin()");
+      return false;
+    }
+    return true;
+  }
+
+  _BuildPack(conditionSet: Object) {
+    let cmdPack = CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.NewCondition(conditionSet));
+
+    // 追加then处理
+    let callbackManager = this._Callbacks;
+    cmdPack["then"] = (childCmdPackList: Array<Object>) => {
+      setChildCommnadPackList(conditionSet, callbackManager, childCmdPackList);
+      return cmdPack;
+    };
+
+    return cmdPack;
+  }
+}
+
+export default ConditionPackBuilder;