@shijiu/jsview-vue 2.2.35 → 2.2.201

package/utils/JsViewVueWidget/JsvFreeMoveActor/ActorControl.ts

@@ -12,74 +12,36 @@ import ActionRefObject from "./ActionRefObject";
 import { RunFreeMoveCmdPacks, FreeMoveAnimClass, FinishRenderBreak } from "./ForgeTypeDefine"
 import { NexusNode, newNexus } from "./NexusNode";
 
+interface CmdListCreator {
+  (builders: BuilderFactory): Array<Object>;
+}
 
-class ActorControl {
-  private _BindView: any;
-  private _BindAnim: any;
-  private _Callbacks: CallbackManager;
-  private _SelfNexusRecv: NexusNode;
-
+class BuilderFactory {
   private _SharedQuickConditionPackBuilder: ConditionPackBuilder;
   private _SharedQuickActionPackBuilder: ActionPackBuilder;
   private _StatePackBuilder: StatePackBuilder;
+  private _Callbacks: CallbackManager;
+  private _SelfNexusRecv: NexusNode;
+  private _OwnerControl: ActorControl;
 
-  constructor() {
-    this._BindView = null;
-    this._BindAnim = null;
-    this._Callbacks = new CallbackManager();
-    this._SelfNexusRecv = newNexus();
-    this._SharedQuickConditionPackBuilder = new ConditionPackBuilder(this._Callbacks, this._SelfNexusRecv);
+  constructor(owner: ActorControl, callbackManager: CallbackManager, selfNexusRecv: NexusNode) {
+    this._OwnerControl = owner;
+    this._Callbacks = callbackManager;
+    this._SelfNexusRecv = selfNexusRecv;
+
+    this._SharedQuickConditionPackBuilder = new ConditionPackBuilder(this._Callbacks, this._SelfNexusRecv, this);
     this._SharedQuickActionPackBuilder = new ActionPackBuilder(this._Callbacks, this._SelfNexusRecv);
     this._StatePackBuilder = new StatePackBuilder();
   }
 
-  // debugGetAnimId() {
-  //   return this._BindAnim?.AnimNativeId;
-  // }
-
-  bindForgeView(bindView: any, instantActive: boolean) {
-    this._BindView = bindView;
-
-    if (instantActive) {
-      this._EnsureAnim();
-    }
-  }
-
-  /** 
-   * run 执行编排好的intent集合
-   *
-   * @param {Array} cmdPackList 内容来自 Condition(), State(), Action() 这些工厂类创建的Command pack
-   */
-  run(cmdPackList: Array<Object>) {
-    if ((window as any).JsView) {
-      this._WrappedRun(cmdPackList);
-    } else {
-      // Browser场景DomProxy需要onReady调用
-      let that = this;
-      this._BindView.RegisterOnProxyReady(() => {
-        that._WrappedRun(cmdPackList);
-      })
-    }
-  }
-
-  _WrappedRun(cmdPackList: Array<Object>) {
-    this._EnsureAnim();
-
-    if (!(cmdPackList instanceof Array)) {
-      console.error("params error");
-      return;
-    }
-
-    RunFreeMoveCmdPacks(this._BindView, cmdPackList);
-  }
-
   /**
    * Condition
    * 获取创建 ConditionPack 的工厂对象
    * ConditionPack对应支持 .then(cmdPackList), 可传入同 Run 的处理队列
    * 可用方法见 ./SetCondition.js
    * @param {int} group 可选参数，默认为0, 有效值为0~3, 对应默认组, 1组, 2组, 3组, 便于remove时，按组进行清理
-   * @param {boolean} multiTimes 可选参数，默认为false, 是否要多次执行, 若为单次，则执行后condition作废
+   * @param {boolean} multiTimes 可选参数，默认为false, 是否要多次执行, 
+   *                      若为单次, 当group未设定时自动作废，当group设定时，不作废但改为deactive状态
    * @param {string} specName 可选参数，默认null, 命名condition, 用于指定名字进行active/deactive动作的场景
    * @param {boolean} shoudRenderBreak 可选参数，默认false, 关联的回调是否会发起RenderBreak
    * @return {ConditionPackBuilder} ConditionPack 的工厂对象
@@ -94,7 +56,7 @@ class ActorControl {
     let builder: ConditionPackBuilder = this._SharedQuickConditionPackBuilder;
     if (builder.isInUsing()) {
       // 用于加速的builder被占用了，为了防止状态问题，使用新建builder
-      builder = new ConditionPackBuilder(this._Callbacks, this._SelfNexusRecv);
+      builder = new ConditionPackBuilder(this._Callbacks, this._SelfNexusRecv, this);
     }
     builder.updateCommandInfo(group, multiTimes, specName, shoudRenderBreak);
     return builder;
@@ -139,12 +101,143 @@ class ActorControl {
   state(): StatePackBuilder {
     return this._StatePackBuilder;
   }
+}
+
+class ActorControl {
+  private _BindView: any;
+  private _BindAnim: any;
+  private _Callbacks: CallbackManager;
+  private _SelfNexusRecv: NexusNode;
+  private _SizeMode: Boolean = false;
+
+  private _CondCycleStartList: Array<Function> | undefined = undefined;
+  private _CondCycleEndList: Array<Function> | undefined = undefined;
+  private _Builders: BuilderFactory;
+
+  constructor() {
+    this._BindView = null;
+    this._BindAnim = null;
+    this._Callbacks = new CallbackManager();
+    this._SelfNexusRecv = newNexus();
+    this._Builders = new BuilderFactory(this, this._Callbacks, this._SelfNexusRecv);
+  }
+
+  asSizeMode() {
+    if (this._BindAnim != null) {
+      console.error("error: asSizeMode should call before bindForgeView");
+    } else {
+      this._SizeMode = true;
+    }
+  }
+
+  // debugGetAnimId() {
+  //   return this._BindAnim?.AnimNativeId;
+  // }
+
+  bindForgeView(bindView: any, instantActive: boolean) {
+    this._BindView = bindView;
+
+    if (instantActive) {
+      this._EnsureAnim();
+    }
+  }
+
+  /**
+   * run 执行编排好的intent集合
+   *
+   * @param {CmdListCreator} commandsCreator 
+   *                         命令指令队列创建回调
+   *                         此回调返回值为一个数组，数组内容内容来自 Condition(), State(), Action() 
+   *                         这些工厂类创建的Command pack
+   */
+  run(commandsCreator: CmdListCreator | undefined) {
+    if (commandsCreator) {
+      let cmdPackList = commandsCreator(this._Builders);
+      if ((window as any).JsView) {
+        this._WrappedRun(cmdPackList);
+      } else {
+        // Browser场景DomProxy需要onReady调用
+        let that = this;
+        this._BindView.RegisterOnProxyReady(() => {
+          that._WrappedRun(cmdPackList);
+        })
+      }
+    }
+  }
+
+  _WrappedRun(cmdPackList: Array<Object>) {
+    this._EnsureAnim();
+
+    if (!(cmdPackList instanceof Array)) {
+      console.error("params error");
+      return;
+    }
+
+    RunFreeMoveCmdPacks(this._BindView, cmdPackList);
+  }
+
+  getBindedAnim() {
+    this._EnsureAnim();
+    return this._BindAnim;
+  }
+
+  getBindedView() {
+    this._EnsureAnim();
+    return this._BindView;
+  }
+
+  /**
+   * addCondCycleListener
+   * 追加 cond cycle listener，可以根据start和end来进行callback时序排序
+   * 
+   * @param {Function} startCycleCallback   开始执行一帧的js回调(condition的callback)
+   * @param {Function} endCycleCallback  执行一帧的js回调完毕
+   */
+  addCondCycleListener(startCycleCallback: Function, endCycleCallback: Function) {
+    if (startCycleCallback) {
+      if (!this._CondCycleStartList) {
+        this._CondCycleStartList = new Array();
+      }
+      this._CondCycleStartList!.push(startCycleCallback);
+    }
+
+    if (endCycleCallback) {
+      if (!this._CondCycleEndList) {
+        this._CondCycleEndList = new Array();
+      }
+      this._CondCycleEndList!.push(endCycleCallback);
+    }
+  }
+
+  removeCondCycleListener(startCycleCallback: Function, endCycleCallback: Function) {
+    if (startCycleCallback && this._CondCycleStartList) {
+      for (let i = 0; i < this._CondCycleStartList.length; i++) {
+        if (this._CondCycleStartList[i] == startCycleCallback) {
+          this._CondCycleStartList.splice(i, 1);
+          break;
+        }
+      }
+    }
+    if (endCycleCallback && this._CondCycleEndList) {
+      for (let i = 0; i < this._CondCycleEndList.length; i++) {
+        if (this._CondCycleEndList[i] == endCycleCallback) {
+          this._CondCycleEndList.splice(i, 1);
+          break;
+        }
+      }
+    }
+  }
 
   _OnEchoEvent(retJson: string) {
     // 遇到layout后仍然会因为新broadcast有动作时，一帧中可能会有多次回调
     let retJsonObject: any = JSON.parse(retJson);
     let echoRetList: Array<any> = retJsonObject["retList"];
     if (echoRetList) {
+      if (this._CondCycleStartList && this._CondCycleStartList.length > 0) {
+        for (let startCb of this._CondCycleStartList) {
+          startCb();
+        }
+      }
       for (let echoRet of echoRetList) {
         let renderBreakId = echoRet["rbTkn"];
         if (renderBreakId != 0) {
@@ -153,12 +246,20 @@ class ActorControl {
         }
         this._Callbacks.invokeCallback(echoRet["eTkn"], retJsonObject, echoRet["cds"], echoRet["ncds"]);
       }
+      if (this._CondCycleEndList && this._CondCycleEndList.length > 0) {
+        for (let endCb of this._CondCycleEndList) {
+          endCb();
+        }
+      }
     }
   }
 
   _EnsureAnim() {
     if (!this._BindAnim) {
-      this._BindAnim = new FreeMoveAnimClass(this._OnEchoEvent.bind(this), this._SelfNexusRecv.token);
+      this._BindAnim = new FreeMoveAnimClass(
+        this._OnEchoEvent.bind(this),
+        this._SelfNexusRecv.token,
+        this._SizeMode);
       this._BindView.StartAnimation(this._BindAnim);
     }
   }

package/utils/JsViewVueWidget/JsvFreeMoveActor/ActorState.ts

@@ -1,6 +1,6 @@
 export default class ActorState {
-    public xPos: number;
-    public yPos: number;
-    public xSpd: number;
-    public ySpd: number;
+    public xPos: number = 0;
+    public yPos: number = 0;
+    public xSpd: number = 0;
+    public ySpd: number = 0;
 }

package/utils/JsViewVueWidget/JsvFreeMoveActor/CallbackManager.ts

@@ -8,9 +8,9 @@
 import { StateCmdBuilder } from "./ForgeTypeDefine"
 
 class CallbackInfo {
-  public funcRef: Function; // 回调函数
-  public times: number; // 回调的次数
-  public once: boolean; // 是否单次回调就销毁
+  public funcRef!: Function; // 回调函数
+  public times: number = 0; // 回调的次数
+  public once: boolean = false; // 是否单次回调就销毁
 }
 
 class CallbackManager {
@@ -49,9 +49,9 @@ class CallbackManager {
     }
   }
 
-  public invokeCallback(id: string, actorState: Object, 
-    customDataStr: string | null | undefined, 
-    nexusCustomDataStr:string | null | undefined) {
+  public invokeCallback(id: string, actorState: Object,
+    customDataStr: string | null | undefined,
+    nexusCustomDataStr: string | null | undefined) {
     let callbackObj = this._CallbackMap.get(id);
     if (callbackObj) {
       if (callbackObj.once) {

package/utils/JsViewVueWidget/JsvFreeMoveActor/ForgeTypeDefine.ts

@@ -5,7 +5,7 @@
  * @Description: file content
  */
 
-import { Forge } from "@shijiu/jsview/dom/jsv-forge-define";
+import { Forge } from "@shijiu/jsview/dom/jsv-forge-define.mjs";
 
 // 此文件声明来自engine-js的api和类型声明
 

package/utils/JsViewVueWidget/JsvFreeMoveActor/FreeMoveActor.vue

@@ -7,16 +7,43 @@
 
 <!--
  * 【模块 export 内容】
- * JsvFreeMoveActor：单轴(X 或 Y)运动控制控件，可控制完成单方向的匀速运动和变速运动（抛物运动），
- *               若想进行X和Y轴同时的运动，可以通过运动分解后的两个JsvActorMove进行组合来实现
- *      props说明:
+ * JsvFreeMoveActor/JsvFreeMoveDiv：
+ *          帧动画控制组件，通过control
+ *              .action()  单一运动指令，新指令发生时会冲掉旧指令  
+ *              .condition()  条件设置，有时间维度，X/Y维度
+ *              .state()  状态调整指令
  *
+ *      props说明:
+ *          class: String, 等同于div的class设置(目前未实装，后续支持...)
+ *          style: Object, 等同于div的style设置
+ *                 特别注意: 在sizeMode模式下，非hidden，控制的是background/image的展示区域，
+ *                 overflow:hidden时，控制的是剪切区域，展示区域保持最初的width/height
+ *          sizeMode: Boolean, 从控制div左上角坐标的模式改为改为通过div矩形宽高
+ *                    (指令控制右下角坐标，实现对[0,0]->[右下角x,y]的矩形的宽高调整，另外，不支持负坐标)
+ *      expose说明:
+ *          control: Object 控制器句柄，具体参考 ActorControl
 -->
 <script setup>
 import ActControl from "./ActorControl.ts";
 import { shallowRef, onMounted } from "vue";
 
 const props = defineProps({
+  // div的style设置,
+  // 其中top, left会作用于父节点，其余内容作用于子节点
+  // width和height在size模式下为初始尺寸
+  // 例如backgroundColor/backgroundImage/overflowHidden
+  style: {
+    type: Object,
+    default: {},
+  },
+
+  // 动画转而控制width/height，而不是x,y
+  sizeMode: {
+    default: false,
+    type: Boolean,
+  },
+
+  // Deprecated
   // 设置给父节点，动画节点必须top/left为0, 以保证PC端模拟通过style直接获取当前位置信息的逻辑能通过
   top: {
     default: 0,
@@ -27,7 +54,9 @@ const props = defineProps({
     type: Number,
   },
 
-  // 设置给实际的动画节点
+  // Deprecated
+  // 设置给实际的动画节点, 在size模式下为初始尺寸
+  // 可能会被style.width, style.height替代
   width: {
     default: 0,
     type: Number,
@@ -40,9 +69,13 @@ const props = defineProps({
 
 let mainDivRef = shallowRef(null);
 let controller = new ActControl();
+if (props.sizeMode) {
+  // 启用size模式
+  controller.asSizeMode();
+}
 
 onMounted(() => {
-  controller.bindForgeView(mainDivRef.value.jsvGetProxyView());
+  controller.bindForgeView(mainDivRef.value.jsvGetProxyView(true));
 });
 
 defineExpose({
@@ -53,17 +86,18 @@ defineExpose({
 <template>
   <div
     :style="{
-      top: props.top,
-      left: props.left,
+      top: props.style.top ? props.style.top : props.top,
+      left: props.style.left ? props.style.left : props.left,
     }"
   >
     <div
       ref="mainDivRef"
       :style="{
-        top: 0,
-        left: 0,
         width: props.width,
         height: props.height,
+        ...props.style,
+        top: 0,
+        left: 0,
       }"
     >
       <slot></slot>

package/utils/JsViewVueWidget/JsvFreeMoveActor/SetAction.ts

@@ -479,6 +479,39 @@ class ActorPackBuilder {
     return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._NexusRecv?.token, cmdList);
   }
 
+  /**
+   * ackMovementSync
+   * 只能放在 movementSync 的then中，用于将Sync同步信息按比例转化成
+   * (注意): 如果触发链条上有自己发出的信息，则将不再产生动作，规避循环触发
+   * 
+   * @param {int} horizontalStart  横向运动识别区域的0%对应位置, 可以为负
+   * @param {int} horizontalEnd  横向运动识别区域的100%对应位置, 可以为负，可以小于start
+   * @param {int} verticalStart  纵向运动识别区域的0%对应位置, 可以为负
+   * @param {int} verticalEnd  纵向运动识别区域的100%对应位置, 可以为负，可以小于end
+   * @param {int} xyEnable  x,y是否都触发, 0b01对应x, 0b10对应y, 可以或运算在一起
+   * @param {int} syncType 换算公式: 
+   *                        1: 正比公式:selfPercent = givenPercent  
+   *                        2: 反比公式:selfPercent = (1 - givenPercent)
+   */
+  ackMovementSync(
+    horizontalStart: number, horizontalEnd: number,
+    verticalStart: number, verticalEnd: number,
+    xyEnable: number, syncType: number) {
+
+    if (!this._BasicPreProcess("ackMovementSync")) {
+      return;
+    }
+
+    let cmdList: Array<Object> = [];
+    cmdList.push(ActionCmdBuilder.AckMovementSync(
+      horizontalStart,
+      horizontalEnd,
+      verticalStart,
+      verticalEnd,
+      xyEnable, syncType));
+    return CmdPackBuilder.InitActCmdPack(this._SpeedKeeps, this._AccKeeps, this._NexusRecv?.token, cmdList);
+  }
+
   _BuildAccelOnPole(
     builderThis: ActorPackBuilder,
     cmdList: Array<Object>,

package/utils/JsViewVueWidget/JsvFreeMoveActor/SetCondition.ts

@@ -31,12 +31,14 @@ class ConditionPackBuilder {
   private _CommonInfo: Object;
   private _CommonInfoValid: boolean;
   private _ContorlSlefNexus: NexusNode;
+  private _BuildersFactory: any;
 
-  constructor(callbackManager: CallbackManager, selfNexus: NexusNode) {
+  constructor(callbackManager: CallbackManager, selfNexus: NexusNode, buildersFactory: any) {
     this._Callbacks = callbackManager;
     this._CommonInfo = ConditionSetBuilder.InitCommonInfo();
     this._CommonInfoValid = false;
     this._ContorlSlefNexus = selfNexus;
+    this._BuildersFactory = buildersFactory;
   }
 
   isInUsing() {
@@ -88,7 +90,7 @@ class ConditionPackBuilder {
     return this._BuildPack(ConditionSetBuilder.WallPosition(direction, xPosition, yPosition, this._CommonInfo));
   }
 
-  boxPosition(left: UNumber, top: UNumber, right: UNumber, bottom: UNumber): object | null {
+  boxPosition(left: UNumber, top: UNumber, right: UNumber, bottom: UNumber): any {
     if (!this._CheckCommonInfo()) {
       return null;
     }
@@ -143,7 +145,7 @@ class ConditionPackBuilder {
    * @param {NexusNode} nexusRecv 由 FreeMoveFunc.newNexus() 创建, 作为通讯句柄，类似电话号，被fireNexusEvent调用
    * @param {number} detailEventType 监听的事件类型, 类比与分机号，和fireNexusEvent发出的id约定, 自定义内容要求1000以上
    */
-  onNexusEvent(nexusRecv: NexusNode, detailEventType: number): Object | null {
+  onNexusEvent(nexusRecv: NexusNode, detailEventType: number) {
     // CommonInfo 只能使用一次，规避多次使用问题
     if (!this._CheckCommonInfo()) {
       return null;
@@ -179,6 +181,7 @@ class ConditionPackBuilder {
   /**
    * onNextTick
    * 用于对一些Condition激活进行延迟，例如teleportTo处理后延迟激活 OnHitBlock 动作，规避teleportTo处理直接触发OnHitBlocker
+   * 特别场景: onNextTick(0) 可用于充当前帧命令执行完毕的回调，相当于为命令执行完毕做一个callback
    * 
    */
   onNextTick(tickGap: number = 1) {
@@ -187,8 +190,8 @@ class ConditionPackBuilder {
       return null;
     }
     this._CommonInfoValid = false;
-    if (tickGap <= 0) {
-      tickGap = 1;
+    if (tickGap < 0) {
+      tickGap = 0;
     }
 
     return this._BuildPack(ConditionSetBuilder.OnNextTick(tickGap, this._CommonInfo));
@@ -277,6 +280,11 @@ class ConditionPackBuilder {
     return this._BuildPack(ConditionSetBuilder.OnFlingDrop(this._CommonInfo, this._ContorlSlefNexus.token));
   }
 
+  /**
+   * touchCount
+   * 当touchDown时，Count会++，用于解决多次touchDown引发的时序问题
+   * 当native的count计数等于给定的参数设定的count时，触发condition
+   */
   touchCount(count: number) {
     if (!this._CheckCommonInfo()) {
       return null;
@@ -285,6 +293,50 @@ class ConditionPackBuilder {
     return this._BuildPack(ConditionSetBuilder.TouchCount(this._CommonInfo, count));
   }
 
+  /**
+   * onMovement
+   * 当FreeMove块移动时，移动了给定的距离值后触发条件, 给定的距离值由sensitivity定义
+   * 
+   * @param {float} xSensitivity x轴的敏感度设置，表示移动了多少像素时就触发条件, 最小值为1
+   * @param {float} ySensitivity y轴的敏感度设置，表示移动了多少像素时就触发条件, undefined时等于xSensitivity
+   * @param {int} xyEnables x,y两轴哪个生效, 0b1 为x, 0b10 为y, 默认为都enable
+   */
+  onMovement(xSensitivity: number,
+    ySensitivity: number | undefined = undefined,
+    xyEnables: number | undefined = undefined) {
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+
+    if (!xSensitivity || xSensitivity < 1) {
+      xSensitivity = 1;
+    }
+
+    if (typeof ySensitivity == "undefined") {
+      ySensitivity = xSensitivity;
+      xyEnables = 0b11;
+    }
+
+    if (typeof xyEnables == "undefined") {
+      xyEnables = 0b11;
+    }
+
+    return this._BuildPack(ConditionSetBuilder.OnMovement(
+      this._CommonInfo,
+      xSensitivity, ySensitivity, xyEnables));
+  }
+
+  movementSync(nexusRef: NexusNode) {
+    if (!this._CheckCommonInfo()) {
+      return null;
+    }
+    this._CommonInfoValid = false;
+    return this._BuildPack(ConditionSetBuilder.MovementSyncNexus(this._CommonInfo,
+      nexusRef?.token ? nexusRef.token : 0,
+    ));
+  }
+
   _CheckCommonInfo(): boolean {
     if (!this._CommonInfoValid) {
       console.error("Error: must call from new conditoin()");
@@ -298,10 +350,19 @@ class ConditionPackBuilder {
 
     // 追加then处理
     let callbackManager = this._Callbacks;
-    cmdPack["then"] = (childCmdPackList: Array<Object>) => {
-      setChildCommnadPackList(conditionSet, callbackManager, childCmdPackList);
+    cmdPack["then"] = (creatorOrArray: Function | Array<Object> | undefined) => {
+      if (creatorOrArray) {
+        let childCmdPackList: Array<Object>;
+        if (typeof creatorOrArray == "function") {
+          childCmdPackList = creatorOrArray(this._BuildersFactory);
+        } else {
+          childCmdPackList = creatorOrArray;
+        }
+        setChildCommnadPackList(conditionSet, callbackManager, childCmdPackList);
+        return cmdPack;
+      }
       return cmdPack;
-    };
+    }
 
     return cmdPack;
   }

package/utils/JsViewVueWidget/JsvFreeMoveActor/SetState.ts

@@ -1,6 +1,7 @@
 
 import { StateCmdBuilder, CmdPackBuilder } from "./ForgeTypeDefine"
 import { NexusNode } from "./NexusNode";
+import ActorControl from "./ActorControl";
 
 class StatePackBuilder {
   constructor() {
@@ -99,6 +100,65 @@ class StatePackBuilder {
   fireNexusEvent(nexusRecv: NexusNode, detailEventType: number) {
     return CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.FireNexusEvent(detailEventType, nexusRecv.token));
   }
+
+  /**
+   * setTouchAttractChild
+   * 
+   * 绑定一个子view中的FreeMoveDiv
+   * 当Touch触控到本div时，这个子div会立刻移动到手指按下的位置，并接受焦点
+   * 
+   * @param {ActorControl} otherFreeMoveControl 其他FreeMoveDiv的control对象
+   */
+  setTouchAttractChild(otherFreeMoveControl: ActorControl) {
+    if (otherFreeMoveControl) {
+      let animRef = otherFreeMoveControl.getBindedAnim();
+      return CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.SetTouchAttractChild(animRef));
+    } else {
+      return CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.SetTouchAttractChild(null));
+    }
+  }
+
+  /**
+   * startMovementSync
+   * 
+   * 发出进度同步信号(可以一个FreeMove绑定多个信号发生器，但目前场景估计只需要一个发生器即可)
+   * 计算当前freeMove的postion和运动识别区域的比值
+   * xPercent = (xPos - horizontalStart) / (horizontalEnd - horizontalStart)
+   * yPercent = (yPos - verticalStart) / (verticalEnd - verticalStart)
+   * x和y可以为负数，也可能>100%
+   * 
+   * 当多次调用时，nexusRef相同时，则为更新运动识别区域，nexusRef不同时则为新建信号发起器
+   * 
+   * @param {NexusNode} nexusRef  绑定的nexus句柄，接受者用这个句柄来进行监听
+   * @param {int} horizontalStart  横向运动识别区域的0%对应位置, 可以为负
+   * @param {int} horizontalEnd  横向运动识别区域的100%对应位置, 可以为负，可以小于start
+   * @param {int} verticalStart  纵向运动识别区域的0%对应位置, 可以为负
+   * @param {int} verticalEnd  纵向运动识别区域的100%对应位置, 可以为负，可以小于end
+   * @param {int} xyEnable  x,y是否都触发, 0b01对应x, 0b10对应y, 可以或运算在一起
+   */
+  startMovementSync(nexusRef: NexusNode,
+    horizontalStart: number, horizontalEnd: number,
+    verticalStart: number, verticalEnd: number,
+    xyEnable: number) {
+
+    return CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.StartMovementSync(
+      nexusRef?.token ? nexusRef.token : 0,
+      horizontalStart,
+      horizontalEnd,
+      verticalStart,
+      verticalEnd,
+      xyEnable));
+  }
+
+  /*
+   * stopMovementSync
+   * 
+   * 停止由startMovementSync发起的的同步信号
+   * 目前阶段，为关闭所有的信号发起器
+   */
+  stopMovementSync() {
+    return CmdPackBuilder.InitStateCmdPack(StateCmdBuilder.StopMovementSync());
+  }
 }
 
 export default StatePackBuilder;