@kkarum/framework 2.3.17

package/expand/FWNodeExpand.ts

@@ -0,0 +1,147 @@
+if (!CC_EDITOR) {
+  const component = {
+    dragon_bones: globalThis?.dragonBones?.ArmatureDisplay,
+    graphics: cc.Graphics,
+    label: cc.Label,
+    label_outline: cc.LabelOutline,
+    label_shadow: cc.LabelShadow,
+    light: cc.Light,
+    mask: cc.Mask,
+    particle_system: cc.ParticleSystem,
+    particle_system_3d: cc.ParticleSystem3D,
+    rich_text: cc.RichText,
+    sp_skeleton: globalThis?.sp?.Skeleton,
+    sprite: cc.Sprite,
+    tiled_map: cc.TiledMap,
+    tiled_tile: cc.TiledTile,
+    mesh_renderer: cc.MeshRenderer,
+    skinned_mesh_renderer: cc.SkinnedMeshRenderer,
+    block_input_events: cc.BlockInputEvents,
+    button: cc.Button,
+    canvas: cc.Canvas,
+    edit_box: cc.EditBox,
+    layout: cc.Layout,
+    page_view: cc.PageView,
+    page_view_indicator: cc.PageViewIndicator,
+    progress_bar: cc.ProgressBar,
+    scroll_bar: cc.Scrollbar,
+    scroll_view: cc.ScrollView,
+    slider: cc.Slider,
+    toggle: cc.Toggle,
+    toggle_container: cc.ToggleContainer,
+    video_player: cc.VideoPlayer,
+    web_view: cc.WebView,
+    widget: cc.Widget,
+    box_collider: cc.BoxCollider,
+    circle_collider: cc.CircleCollider,
+    polygon_collider: cc.PolygonCollider,
+    physics_box_collider: cc.PhysicsBoxCollider,
+    box_collider_3d: cc.BoxCollider3D,
+    physics_chain_collider: cc.PhysicsChainCollider,
+    physics_circle_collider: cc.PhysicsCircleCollider,
+    physics_polygon_collider: cc.PhysicsPolygonCollider,
+    sphere_collider_3d: cc.SphereCollider3D,
+    constant_force: cc.ConstantForce,
+    distance_joint: cc.DistanceJoint,
+    motor_joint: cc.MotorJoint,
+    mouse_joint: cc.MouseJoint,
+    prismatic_joint: cc.PrismaticJoint,
+    revolute_joint: cc.RevoluteJoint,
+    rope_joint: cc.RopeJoint,
+    weld_joint: cc.WeldJoint,
+    wheel_joint: cc.WheelJoint,
+    rigid_body: cc.RigidBody,
+    rigid_body_3d: cc.RigidBody3D,
+    animation: cc.Animation,
+    audio_source: cc.AudioSource,
+    camera: cc.Camera,
+    motion_streak: cc.MotionStreak,
+    skeleton_animation: cc.SkeletonAnimation,
+    swan_sub_context_view: cc.SwanSubContextView,
+    wx_sub_context_view: cc.WXSubContextView,
+  };
+
+  Object.defineProperty(cc.Node.prototype, 'node_prototype', {
+    get: function () {
+      if (!this.node_cache) {
+        this.node_cache = {
+          component_map: new Map<string, cc.Component>(),
+          child_map: new Map<string, cc.Node>(),
+          child_update: false,
+        };
+      }
+      return this.node_cache;
+    },
+  });
+
+  Object.defineProperty(cc.Node.prototype, 'child_update', {
+    get: function () {
+      return this.node_prototype.child_update;
+    },
+    set: function () {
+      const target = this;
+      if (this.node_prototype.child_update) {
+        this.node_prototype.child_update = false;
+        this.off(
+          cc.Node.EventType.CHILD_REMOVED,
+          function (node: cc.Node) {
+            return target.node_prototype.child_map.delete(node.name);
+          },
+          this,
+        );
+      }
+      this.on(
+        cc.Node.EventType.CHILD_REMOVED,
+        function (node: cc.Node) {
+          return target.node_prototype.child_map.delete(node.name);
+        },
+        this,
+      );
+    },
+  });
+
+  const find = function (k) {
+    Object.defineProperty(cc.Node.prototype, k, {
+      get: function () {
+        let c = this.node_prototype.component_map.get(k);
+        if (!c) {
+          c = this.getComponent(component[k]);
+          this.node_prototype.component_map.set(k, c);
+        }
+        return c;
+      },
+      set: function () {
+        this.node_prototype.component_map.delete(k);
+      },
+    });
+  };
+
+  for (const k in component) {
+    find(k);
+  }
+
+  cc.Node.prototype.child = function (path: string, autoUpdate: boolean) {
+    const path_ss = path.split('/');
+    let self = this;
+    let t: cc.Node;
+    for (let _i = 0, path_ss_1 = path_ss; _i < path_ss_1.length; _i++) {
+      const path_s = path_ss_1[_i];
+      if (autoUpdate) {
+        self.node_prototype.child_map.delete(path_s);
+        t = self.getChildByName(path_s);
+        self.node_prototype.child_map.set(path_s, t);
+      } else {
+        t = self.node_prototype.child_map.get(path_s);
+        if (!t) {
+          t = self.getChildByName(path_s);
+          self.node_prototype.child_map.set(path_s, t);
+        }
+      }
+      if (!t) {
+        break;
+      }
+      self = t;
+    }
+    return t;
+  };
+}

package/expand/FWNodeExpand.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "4398ba04-97b1-4790-8ec8-b15a69460d2e",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand/FWRollingViewNesting.ts

@@ -0,0 +1,195 @@
+const { ccclass, property, menu } = cc._decorator;
+
+interface EventTouch extends cc.Event.EventTouch {
+  simulate?: boolean;
+  mock?: boolean; // 是否为模拟事件
+}
+
+@ccclass
+@menu('CustomComponent/FWRollingViewNesting')
+export default class FWRollingViewNesting extends cc.Component {
+  @property({
+    tooltip: '方向判定阈值(像素)，小于该值不触发方向拦截',
+    min: 3,
+    max: 15,
+  })
+  dirThreshold = 15;
+
+  private scrollView: cc.ScrollView = null;
+  private _isBoundaryV = 0; //为没有开启滚动所以没有边界 1为上边界 2为下边界 3为不滑动;
+  private _isBoundaryH = 0; //为没有开启滚动所以没有边界 1为左边界 2为右边界 3为不滑动；
+
+  protected onEnable(): void {
+    this.scrollView = this.node.getComponent(cc.ScrollView);
+    if (this.scrollView) {
+      (this.scrollView as any).hasNestedViewGroup = (event, captureListeners) => {
+        if (event.eventPhase !== cc.Event.CAPTURING_PHASE) return false;
+        const hasNested = this._processNestedEvent(event, captureListeners);
+        // 只处理 TOUCH_END 和 TOUCH_CANCEL，且没有被嵌套拦截时，通知其他嵌套ViewGroup处理事件
+        if (
+          (event.type === cc.Node.EventType.TOUCH_END ||
+            event.type === cc.Node.EventType.TOUCH_CANCEL) &&
+          !hasNested
+        ) {
+          for (const item of captureListeners) {
+            this.onEnd(event, captureListeners, item);
+          }
+
+          this.onEnd(event, captureListeners, event.target);
+        }
+        return hasNested;
+      };
+    }
+  }
+
+  protected onDisable(): void {
+    this.unscheduleAllCallbacks();
+  }
+
+  private onEnd(event, captureListeners, item) {
+    if (item !== this.node) {
+      const viewGroup = item.getComponent(cc.ViewGroup);
+      if (viewGroup) {
+        if (
+          event.type === cc.Node.EventType.TOUCH_END &&
+          typeof viewGroup._onTouchEnded === 'function'
+        ) {
+          let touch = event.touch;
+          if (viewGroup.content) {
+            if (viewGroup instanceof cc.PageView) {
+              viewGroup['_touchEndPosition'] = touch.getLocation();
+            }
+            viewGroup._handleReleaseLogic(touch);
+          }
+        }
+        if (
+          event.type === cc.Node.EventType.TOUCH_CANCEL &&
+          typeof viewGroup._onTouchCancelled === 'function'
+        ) {
+          if (!event.simulate) {
+            let touch = event.touch;
+            if (viewGroup.content) {
+              if (viewGroup instanceof cc.PageView) {
+                viewGroup['_touchEndPosition'] = touch.getLocation();
+              }
+              viewGroup._handleReleaseLogic(touch);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private _processNestedEvent(event: EventTouch, captureListeners: any[]): boolean {
+    if (!captureListeners) return false;
+
+    for (let i = 0; i < captureListeners.length; ++i) {
+      const item = captureListeners[i];
+      if (this.node === item) {
+        return event.target?.getComponent(cc.ViewGroup)
+          ? this.itemIsView(event.target, event)
+          : false;
+      }
+      if (item.getComponent(cc.ViewGroup)) {
+        return this.itemIsView(item, event);
+      }
+    }
+    return false;
+  }
+
+  itemIsView(target: cc.Node, event: EventTouch): boolean {
+    const scrollView = target.getComponent(cc.ScrollView);
+    if (!scrollView) return false;
+
+    const delta = this._getTouchDelta(event);
+    this._checkBoundary(scrollView);
+
+    return this._shouldIntercept(delta, scrollView);
+  }
+
+  /**
+   * 获取当前触摸的移动距离
+   * @returns {cc.Vec2} 触摸移动的偏移量
+   */
+  private _getTouchDelta(event: EventTouch): cc.Vec2 {
+    if (!event) return cc.v2(0, 0);
+    // 使用事件的起始位置和当前位置计算偏移
+    const startPos = event.getStartLocation ? event.getStartLocation() : cc.v2(0, 0);
+    const currentPos = event.getLocation ? event.getLocation() : cc.v2(0, 0);
+    return currentPos.sub(startPos);
+  }
+  //边界检测
+  private _checkBoundary(scrollView: cc.ScrollView) {
+    const offset = scrollView.getScrollOffset();
+    const maxOffset = scrollView.getMaxScrollOffset();
+
+    // 垂直边界
+    if (!scrollView.vertical) {
+      this._isBoundaryV = 0;
+    } else if (maxOffset.y <= 2) {
+      this._isBoundaryV = 3; //内部不滑动
+    } else if (offset.y <= 10) {
+      this._isBoundaryV = 1; // 顶部边界
+    } else if (offset.y >= maxOffset.y - 10) {
+      this._isBoundaryV = 2; // 底部边界
+    } else {
+      this._isBoundaryV = 0;
+    }
+    // 水平边界
+    if (!scrollView.horizontal) {
+      this._isBoundaryH = 0;
+    } else if (maxOffset.x <= 2) {
+      this._isBoundaryH = 3; //内部不滑动
+    } else if (offset.x >= -10) {
+      this._isBoundaryH = 1; // 左边界
+    } else if (offset.x <= -maxOffset.x + 10) {
+      this._isBoundaryH = 2; // 右边界
+    } else {
+      this._isBoundaryH = 0;
+    }
+
+    // FWLog.response('_isBoundaryV:', this._isBoundaryV);
+    // FWLog.response('_isBoundaryH:', this._isBoundaryH);
+    // console.log('offsetx:%d,offsety:%d', offset.x, offset.y);
+    // console.log('maxOffsetx:%d,maxOffsety:%d', maxOffset.x, maxOffset.y);
+  }
+
+  //方向拦截,边界拦截
+  private _shouldIntercept(delta: cc.Vec2, scrollView: cc.ScrollView): boolean {
+    //console.log('deltax:%d,deltay:%d', delta.x, delta.y);
+    //判断水平方向位移
+    if (scrollView.horizontal && this.scrollView.horizontal) {
+      //同向位移
+      if (Math.abs(delta.x) > this.dirThreshold) {
+        // 左边界且向左滚动，或右边界且向右滚动，交给父级处理
+        if (
+          (this._isBoundaryH === 1 && delta.x > 0) ||
+          (this._isBoundaryH === 2 && delta.x < 0) ||
+          this._isBoundaryH === 3
+        ) {
+          return false;
+        }
+        // 非边界，自己处理
+        return true;
+      }
+    }
+    // 垂直方向拦截
+    if (scrollView.vertical && this.scrollView.vertical) {
+      if (Math.abs(delta.y) > this.dirThreshold) {
+        // 顶部边界且向下滚动，或底部边界且向上滚动，交给父级处理
+        if (
+          (this._isBoundaryV === 1 && delta.y < 0) ||
+          (this._isBoundaryV === 2 && delta.y > 0) ||
+          this._isBoundaryV === 3
+        ) {
+          return false;
+        }
+        // 非边界，自己处理
+        return true;
+      }
+    }
+
+    // 默认不拦截
+    return false;
+  }
+}

package/expand/FWRollingViewNesting.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "3107e3b8-c4c4-41f0-8223-3e85b0b40821",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand/FWTweenExpand.ts

@@ -0,0 +1,44 @@
+cc.ActionInterval.prototype.step = function (dt: number) {
+  if (this.paused) {
+    return;
+  }
+  if (this._firstTick && !this._goto) {
+    this._firstTick = false;
+    this._elapsed = 0;
+  } else {
+    this._elapsed += dt;
+  }
+  let t =
+    this._elapsed / (this._duration > 0.0000001192092896 ? this._duration : 0.0000001192092896);
+  t = 1 > t ? t : 1;
+  this.update(t > 0 ? t : 0);
+  //Compatible with repeat class, Discard after can be deleted (this._repeatMethod)
+  if (this._repeatMethod && this._timesForRepeat > 1 && this.isDone()) {
+    if (!this._repeatForever) {
+      this._timesForRepeat--;
+    }
+    this.startWithTarget(this.target);
+    this.step(this._elapsed - this._duration);
+  }
+};
+
+cc.Tween.prototype.pause = function () {
+  this._finalAction.paused = true;
+};
+
+cc.Tween.prototype.resume = function () {
+  this._finalAction.paused = false;
+};
+
+cc.Tween.prototype.setSpeed = function (speed: number) {
+  this._finalAction._speedMethod = true;
+  this._finalAction._speed = speed;
+};
+
+cc.Tween.prototype.getDuration = function () {
+  return this._finalAction._duration;
+};
+
+cc.Tween.prototype.getElapsed = function () {
+  return this._finalAction._elapsed;
+};

package/expand/FWTweenExpand.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "93bd79eb-6b88-4783-a4c8-37d56fe720b4",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/expand.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "3261d225-82a8-4353-bd88-35178ac39c7a",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/item/FWVirtualListItem.ts

@@ -0,0 +1,141 @@
+import FWVirtualViewComponent from '../component/FWVirtualViewComponent';
+
+const { ccclass, property, disallowMultiple, menu, executionOrder } = cc._decorator;
+
+enum SelectedType {
+  NONE = 0,
+  TOGGLE = 1,
+  SWITCH = 2,
+}
+
+@ccclass
+@disallowMultiple()
+@menu('CustomComponent/FWVirtualListItem')
+@executionOrder(-5001) //先于List
+export default class FWVirtualListItem extends FW.Object {
+  onGet(args: any) {}
+  onPut() {}
+  onInit() {}
+
+  //选择模式
+  @property({
+    type: cc.Enum(SelectedType),
+    tooltip: CC_DEV && '选择模式',
+  })
+  selectedMode: SelectedType = SelectedType.NONE;
+
+  //自适应尺寸
+  @property({
+    tooltip: CC_DEV && '自适应尺寸（宽或高）',
+  })
+  adaptiveSize: boolean = false;
+
+  //按钮组件
+  private _btnCom: any;
+  get btnCom() {
+    if (!this._btnCom) this._btnCom = this.node.getComponent(cc.Button);
+    return this._btnCom;
+  }
+  //依赖的List组件
+  public list: FWVirtualViewComponent;
+  //是否已经注册过事件
+  private _eventReg = false;
+  //序列id
+  public listId: number;
+
+  onLoad() {}
+
+  onDestroy() {
+    this.node.off(cc.Node.EventType.SIZE_CHANGED, this._onSizeChange, this);
+  }
+
+  _registerEvent() {
+    if (!this._eventReg) {
+      if (this.btnCom && (this.list.selectedMode as number) > 0) {
+        this.btnCom.clickEvents.unshift(this.createEvt(this, 'onClickThis'));
+      }
+      if (this.adaptiveSize) {
+        this.node.on(cc.Node.EventType.SIZE_CHANGED, this._onSizeChange, this);
+      }
+      this._eventReg = true;
+    }
+  }
+
+  _onSizeChange() {
+    this.list._onItemAdaptive(this.node);
+  }
+  /**
+   * 创建事件
+   * @param {cc.Component} component 组件脚本
+   * @param {string} handlerName 触发函数名称
+   * @param {cc.Node} node 组件所在node（不传的情况下取component.node）
+   * @returns cc.Component.EventHandler
+   */
+  createEvt(component: cc.Component, handlerName: string, node: cc.Node = null) {
+    if (!component.isValid) return; //有些异步加载的，节点以及销毁了。
+    component['comName'] =
+      component['comName'] ||
+      component.name
+        .match(/\<(.*?)\>/g)
+        .pop()
+        .replace(/\<|>/g, '');
+    let evt = new cc.Component.EventHandler();
+    evt.target = node || component.node;
+    evt.component = component['comName'];
+    evt.handler = handlerName;
+    return evt;
+  }
+
+  showAni(aniType: number, callFunc: Function, del: boolean) {
+    let t: any = this;
+    let tween: cc.Tween;
+    switch (aniType) {
+      case 0: //向上消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { y: t.node.height * 2 });
+        break;
+      case 1: //向右消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { x: t.node.width * 2 });
+        break;
+      case 2: //向下消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { y: t.node.height * -2 });
+        break;
+      case 3: //向左消失
+        tween = cc
+          .tween(t.node)
+          .to(0.2, { scale: 0.7 })
+          .by(0.3, { x: t.node.width * -2 });
+        break;
+      default: //默认：缩小消失
+        tween = cc.tween(t.node).to(0.3, { scale: 0.1 });
+        break;
+    }
+    if (callFunc || del) {
+      tween.call(() => {
+        if (del) {
+          t.list._delSingleItem(t.node);
+          for (let n: number = t.list.displayData.length - 1; n >= 0; n--) {
+            if (t.list.displayData[n].id == t.listId) {
+              t.list.displayData.splice(n, 1);
+              break;
+            }
+          }
+        }
+        callFunc();
+      });
+    }
+    tween.start();
+  }
+
+  onClickThis() {
+    this.list.selectedId = this.listId;
+  }
+}

package/item/FWVirtualListItem.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "32751987-766e-44d4-af5a-4625d46aabf6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/item.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "8c7436d1-86e8-49f9-86ee-e4a41a6010de",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}

package/language/FWLanguage.ts

@@ -0,0 +1,71 @@
+import { FWLodash } from '../utils/FWLodash';
+
+const { ccclass, property, executeInEditMode } = cc._decorator;
+
+@ccclass
+@executeInEditMode
+export default abstract class FWLanguage extends cc.Component {
+  @property
+  protected _language: number = 0;
+
+  @property({
+    type: FWLodash.CCEnum(['请选择语言', ...FW.Entry.languageMgr.getSupportedLanguages()]),
+    displayName: 'language',
+    visible: true,
+    serializable: true,
+  })
+  get language() {
+    return this._language;
+  }
+  set language(value: number) {
+    this._language = value;
+    this.onLanguageChange();
+  }
+  protected refresh() {
+    if (CC_EDITOR) {
+      this.onRefresh();
+      this.refreshInspector();
+    }
+  }
+
+  private refreshInspector() {
+    //@ts-ignore
+    Editor.Utils.refreshSelectedInspector('node', this.node.uuid);
+  }
+
+  protected onLoad(): void {
+    FW.Entry.uiMgr.register({
+      FWEvent: [
+        {
+          eventName: FW.EventDefine.LanguageEvent.LANGUAGE_CHANGE,
+          cb: () => {
+            this._language = FW.Entry.languageMgr.getLanguageIndex();
+            this.onLanguageChange();
+          },
+        },
+      ],
+    });
+  }
+
+  protected onEnable(): void {
+    if (!CC_EDITOR) {
+      this._language = FW.Entry.languageMgr.getLanguageIndex();
+      this.onLanguageChange();
+    }
+  }
+
+  protected onDestroy(): void {
+    FW.Entry.evtMgr.targetOff(this);
+  }
+
+  protected getSupportedLanguages(): string[] {
+    return FW.Entry.languageMgr.getSupportedLanguages();
+  }
+
+  protected getBundles(): string[] {
+    return FW.Entry.languageMgr.getBundles();
+  }
+
+  protected abstract onRefresh?(): void;
+  protected abstract onLanguageChange?(): void;
+}

package/language/FWLanguage.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "cfffdc57-7607-48db-be11-91ba8da0e96c",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}