@anov/3d-ability 0.0.142 → 0.0.144

package/dist/business/SplitBuilding/index.js

@@ -1,384 +1,593 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { Vector3 } from '@anov/3d-core';
 import ObjectLayer from "../Base/ObjectLayer";
 import { EBuildingSplitType, EDirection } from "./type";
-class BuildingSplit extends ObjectLayer {
-  constructor(building) {
-    super();
-    _defineProperty(this, "floorGroups", new Map());
-    _defineProperty(this, "sortedFloorLevels", []);
-    _defineProperty(this, "aboveGroundFloorCount", 0);
-    _defineProperty(this, "undergroundFloorCount", 0);
-    _defineProperty(this, "hasRoof", false);
-    _defineProperty(this, "currentAnimation", {
+var BuildingSplit = /*#__PURE__*/function (_ObjectLayer) {
+  _inherits(BuildingSplit, _ObjectLayer);
+  var _super = _createSuper(BuildingSplit);
+  function BuildingSplit(building) {
+    var _this;
+    _classCallCheck(this, BuildingSplit);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "floorGroups", new Map());
+    _defineProperty(_assertThisInitialized(_this), "sortedFloorLevels", []);
+    _defineProperty(_assertThisInitialized(_this), "aboveGroundFloorCount", 0);
+    _defineProperty(_assertThisInitialized(_this), "undergroundFloorCount", 0);
+    _defineProperty(_assertThisInitialized(_this), "hasRoof", false);
+    _defineProperty(_assertThisInitialized(_this), "currentAnimation", {
       timer: null
     });
-    _defineProperty(this, "_building", void 0);
-    this._building = building;
-    this.init();
-  }
-  get building() {
-    return this._building;
+    _defineProperty(_assertThisInitialized(_this), "_building", void 0);
+    _this._building = building;
+    _this.init();
+    return _this;
   }
+  _createClass(BuildingSplit, [{
+    key: "building",
+    get: function get() {
+      return this._building;
+    }
 
-  /**
-   * 初始化建筑拆分器
-   * @param building 建筑模型
-   */
-  init() {
-    this.floorGroups = new Map();
-    this.sortedFloorLevels = [];
-    this.aboveGroundFloorCount = 0;
-    this.undergroundFloorCount = 0;
-    this.hasRoof = false;
+    /**
+     * 初始化建筑拆分器
+     * @param building 建筑模型
+     */
+  }, {
+    key: "init",
+    value: function init() {
+      this.floorGroups = new Map();
+      this.sortedFloorLevels = [];
+      this.aboveGroundFloorCount = 0;
+      this.undergroundFloorCount = 0;
+      this.hasRoof = false;
 
-    // 解析所有楼层
-    this.parseFloors();
+      // 解析所有楼层
+      this.parseFloors();
 
-    // 排序楼层编号从低到高
-    this.sortedFloorLevels = Array.from(this.floorGroups.values()).map(group => group.level).sort((a, b) => a - b);
-  }
+      // 排序楼层编号从低到高
+      this.sortedFloorLevels = Array.from(this.floorGroups.values()).map(function (group) {
+        return group.level;
+      }).sort(function (a, b) {
+        return a - b;
+      });
+    }
 
-  /**
-   * 解析建筑模型中的楼层
-   */
-  parseFloors() {
-    this.building.traverse(object => {
-      if (object.type === 'Mesh' || object.type === 'Group') {
-        const name = object.name;
-        // 检查是否为屋顶
-        if (name.startsWith('Roof')) {
-          this.addToFloorGroup('Roof', {
-            mesh: object,
-            originalPosition: object.position.clone(),
-            originalVisibility: object.visible
-          });
-          this.hasRoof = true;
-          return;
-        }
+    /**
+     * 解析建筑模型中的楼层
+     */
+  }, {
+    key: "parseFloors",
+    value: function parseFloors() {
+      var _this2 = this;
+      this.building.traverse(function (object) {
+        if (object.type === 'Mesh' || object.type === 'Group') {
+          var name = object.name;
+          // 检查是否为屋顶
+          if (name.startsWith('Roof')) {
+            _this2.addToFloorGroup('Roof', {
+              mesh: object,
+              originalPosition: object.position.clone(),
+              originalVisibility: object.visible
+            });
+            _this2.hasRoof = true;
+            return;
+          }
 
-        // 提取楼层前缀
-        let prefix = null;
-        let level = 0;
-        let isUnderground = false;
-        if (name.startsWith('F') && name.length >= 3) {
-          // 地上楼层
-          const floorNum = parseInt(name.substring(1, 3));
-          if (!isNaN(floorNum)) {
-            prefix = `F${name.substring(1, 3)}`;
-            level = floorNum;
-            isUnderground = false;
-            this.aboveGroundFloorCount = Math.max(this.aboveGroundFloorCount, floorNum);
+          // 提取楼层前缀
+          var prefix = null;
+          var level = 0;
+          var isUnderground = false;
+          if (name.startsWith('F') && name.length >= 3) {
+            // 地上楼层
+            var floorNum = parseInt(name.substring(1, 3));
+            if (!isNaN(floorNum)) {
+              prefix = "F".concat(name.substring(1, 3));
+              level = floorNum;
+              isUnderground = false;
+              _this2.aboveGroundFloorCount = Math.max(_this2.aboveGroundFloorCount, floorNum);
+            }
+          } else if (name.startsWith('B') && name.length >= 3) {
+            // 地下楼层
+            var _floorNum = parseInt(name.substring(1, 3));
+            if (!isNaN(_floorNum)) {
+              prefix = "B".concat(name.substring(1, 3));
+              level = -_floorNum;
+              isUnderground = true;
+              _this2.undergroundFloorCount = Math.max(_this2.undergroundFloorCount, _floorNum);
+            }
           }
-        } else if (name.startsWith('B') && name.length >= 3) {
-          // 地下楼层
-          const floorNum = parseInt(name.substring(1, 3));
-          if (!isNaN(floorNum)) {
-            prefix = `B${name.substring(1, 3)}`;
-            level = -floorNum;
-            isUnderground = true;
-            this.undergroundFloorCount = Math.max(this.undergroundFloorCount, floorNum);
+          if (prefix) {
+            _this2.addToFloorGroup(prefix, {
+              mesh: object,
+              originalPosition: object.position.clone(),
+              originalVisibility: object.visible
+            }, level, isUnderground);
           }
         }
-        if (prefix) {
-          this.addToFloorGroup(prefix, {
-            mesh: object,
-            originalPosition: object.position.clone(),
-            originalVisibility: object.visible
-          }, level, isUnderground);
-        }
-      }
-    });
-  }
-
-  /**
-   * 将组件添加到对应楼层分组
-   */
-  addToFloorGroup(prefix, component, level = this.aboveGroundFloorCount + 1, isUnderground = false) {
-    var _this$floorGroups$get;
-    if (!this.floorGroups.has(prefix)) {
-      this.floorGroups.set(prefix, {
-        level,
-        isUnderground,
-        isRoof: prefix === 'Roof',
-        components: []
       });
     }
-    (_this$floorGroups$get = this.floorGroups.get(prefix)) === null || _this$floorGroups$get === void 0 || _this$floorGroups$get.components.push(component);
-  }
 
-  /**
-   * 拆分楼层
-   * @param options 拆分选项
-   * @returns 成功或错误信息
-   */
-  split(options) {
-    const {
-      floor,
-      animation
-    } = options;
-    const animOption = animation || {
-      type: EBuildingSplitType.Move,
-      duration: 1000
-    };
-
-    // 取消当前动画
-    if (this.currentAnimation.timer !== null) {
-      window.clearTimeout(this.currentAnimation.timer);
-      this.currentAnimation.timer = null;
+    /**
+     * 将组件添加到对应楼层分组
+     */
+  }, {
+    key: "addToFloorGroup",
+    value: function addToFloorGroup(prefix, component) {
+      var _this$floorGroups$get;
+      var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.aboveGroundFloorCount + 1;
+      var isUnderground = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+      if (!this.floorGroups.has(prefix)) {
+        this.floorGroups.set(prefix, {
+          level: level,
+          isUnderground: isUnderground,
+          isRoof: prefix === 'Roof',
+          components: []
+        });
+      }
+      (_this$floorGroups$get = this.floorGroups.get(prefix)) === null || _this$floorGroups$get === void 0 || _this$floorGroups$get.components.push(component);
     }
 
-    // 处理 floor = 0 的情况：恢复完整状态
-    if (floor === 0) {
-      this.resetBuilding();
-      return {
-        success: true
+    /**
+     * 拆分楼层
+     * @param options 拆分选项
+     * @returns 成功或错误信息
+     */
+  }, {
+    key: "split",
+    value: function split(options) {
+      var floor = options.floor,
+        animation = options.animation;
+      var animOption = animation || {
+        type: EBuildingSplitType.Move,
+        duration: 1000
       };
-    }
 
-    // 验证楼层参数
-    if (floor > 0 && floor > this.aboveGroundFloorCount) {
-      return {
-        success: false,
-        message: `地上楼层数超出范围，最大楼层为 ${this.aboveGroundFloorCount}`
-      };
-    }
-    if (floor < 0 && Math.abs(floor) > this.undergroundFloorCount) {
+      // 取消当前动画
+      if (this.currentAnimation.timer !== null) {
+        window.clearTimeout(this.currentAnimation.timer);
+        this.currentAnimation.timer = null;
+      }
+
+      // 处理 floor = 0 的情况：恢复完整状态
+      if (floor === 0) {
+        this.resetBuilding();
+        return {
+          success: true
+        };
+      }
+
+      // 验证楼层参数
+      if (floor > 0 && floor > this.aboveGroundFloorCount) {
+        return {
+          success: false,
+          message: "\u5730\u4E0A\u697C\u5C42\u6570\u8D85\u51FA\u8303\u56F4\uFF0C\u6700\u5927\u697C\u5C42\u4E3A ".concat(this.aboveGroundFloorCount)
+        };
+      }
+      if (floor < 0 && Math.abs(floor) > this.undergroundFloorCount) {
+        return {
+          success: false,
+          message: "\u5730\u4E0B\u697C\u5C42\u6570\u8D85\u51FA\u8303\u56F4\uFF0C\u6700\u5927\u5730\u4E0B\u697C\u5C42\u4E3A ".concat(this.undergroundFloorCount)
+        };
+      }
+
+      // 执行拆分操作
+      switch (animOption.type) {
+        case EBuildingSplitType.Hide:
+          this.hideAboveFloors(floor);
+          break;
+        case EBuildingSplitType.Move:
+          this.moveAboveFloorsDirection(floor, animOption);
+          break;
+        case EBuildingSplitType.Solo:
+          this.showSoloFloor(floor);
+          break;
+      }
       return {
-        success: false,
-        message: `地下楼层数超出范围，最大地下楼层为 ${this.undergroundFloorCount}`
+        success: true
       };
     }
 
-    // 执行拆分操作
-    switch (animOption.type) {
-      case EBuildingSplitType.Hide:
-        this.hideAboveFloors(floor);
-        break;
-      case EBuildingSplitType.Move:
-        this.moveAboveFloorsDirection(floor, animOption);
-        break;
-      case EBuildingSplitType.Solo:
-        this.showSoloFloor(floor);
-        break;
-    }
-    return {
-      success: true
-    };
-  }
+    /**
+     * 隐藏指定楼层以上的楼层
+     * @param targetFloor 目标楼层
+     */
+  }, {
+    key: "hideAboveFloors",
+    value: function hideAboveFloors(targetFloor) {
+      var _iterator = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var floorGroup = _step.value;
+          var floorLevel = floorGroup.level;
 
-  /**
-   * 隐藏指定楼层以上的楼层
-   * @param targetFloor 目标楼层
-   */
-  hideAboveFloors(targetFloor) {
-    for (const floorGroup of this.floorGroups.values()) {
-      const floorLevel = floorGroup.level;
+          // 重置所有楼层组件位置
+          var _iterator2 = _createForOfIteratorHelper(floorGroup.components),
+            _step2;
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var component = _step2.value;
+              component.mesh.position.copy(component.originalPosition);
+            }
 
-      // 重置所有楼层组件位置
-      for (const component of floorGroup.components) component.mesh.position.copy(component.originalPosition);
-
-      // 设置可见性
-      const shouldBeVisible = floorLevel <= targetFloor;
-      for (const component of floorGroup.components) component.mesh.visible = shouldBeVisible;
+            // 设置可见性
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+          var shouldBeVisible = floorLevel <= targetFloor;
+          var _iterator3 = _createForOfIteratorHelper(floorGroup.components),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var _component = _step3.value;
+              _component.mesh.visible = shouldBeVisible;
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
     }
-  }
 
-  /**
-   * 将指定楼层以上的楼层整体上移
-   * @param targetFloor 目标楼层
-   * @param animation 动画选项
-   */
-  moveAboveFloorsUp(targetFloor, animation) {
-    const distance = 10;
-    const duration = animation.duration;
+    /**
+     * 将指定楼层以上的楼层整体上移
+     * @param targetFloor 目标楼层
+     * @param animation 动画选项
+     */
+  }, {
+    key: "moveAboveFloorsUp",
+    value: function moveAboveFloorsUp(targetFloor, animation) {
+      var distance = 10;
+      var duration = animation.duration;
 
-    // 重置所有楼层可见性
-    for (const floorGroup of this.floorGroups.values()) {
-      for (const component of floorGroup.components) component.mesh.visible = true;
-    }
+      // 重置所有楼层可见性
+      var _iterator4 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var floorGroup = _step4.value;
+          var _iterator6 = _createForOfIteratorHelper(floorGroup.components),
+            _step6;
+          try {
+            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+              var component = _step6.value;
+              component.mesh.visible = true;
+            }
+          } catch (err) {
+            _iterator6.e(err);
+          } finally {
+            _iterator6.f();
+          }
+        }
 
-    // 计算起始位置和目标位置
-    const startPositions = new Map();
-    const targetPositions = new Map();
-    for (const floorGroup of this.floorGroups.values()) {
-      const floorLevel = floorGroup.level;
-      for (const component of floorGroup.components) {
-        startPositions.set(component.mesh, component.mesh.position.clone());
-        if (floorLevel > targetFloor) {
-          // 上方楼层需要上移
-          const targetPos = component.originalPosition.clone();
-          targetPos.y += distance;
-          targetPositions.set(component.mesh, targetPos);
-        } else {
-          // 其他楼层保持原位
-          targetPositions.set(component.mesh, component.originalPosition.clone());
+        // 计算起始位置和目标位置
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      var startPositions = new Map();
+      var targetPositions = new Map();
+      var _iterator5 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _floorGroup = _step5.value;
+          var floorLevel = _floorGroup.level;
+          var _iterator7 = _createForOfIteratorHelper(_floorGroup.components),
+            _step7;
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var _component2 = _step7.value;
+              startPositions.set(_component2.mesh, _component2.mesh.position.clone());
+              if (floorLevel > targetFloor) {
+                // 上方楼层需要上移
+                var targetPos = _component2.originalPosition.clone();
+                targetPos.y += distance;
+                targetPositions.set(_component2.mesh, targetPos);
+              } else {
+                // 其他楼层保持原位
+                targetPositions.set(_component2.mesh, _component2.originalPosition.clone());
+              }
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
         }
+
+        // 执行动画
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
       }
+      this.animatePositions(startPositions, targetPositions, duration);
     }
 
-    // 执行动画
-    this.animatePositions(startPositions, targetPositions, duration);
-  }
-
-  /**
-   * 将指定楼层以上的楼层向指定方向移动
-   * @param targetFloor 目标楼层
-   * @param animation 动画选项
-   */
-  moveAboveFloorsDirection(targetFloor, animation) {
-    const {
-      direction = [10, 10, 0]
-    } = animation.rule || {};
-    const duration = animation.duration;
+    /**
+     * 将指定楼层以上的楼层向指定方向移动
+     * @param targetFloor 目标楼层
+     * @param animation 动画选项
+     */
+  }, {
+    key: "moveAboveFloorsDirection",
+    value: function moveAboveFloorsDirection(targetFloor, animation) {
+      var _ref = animation.rule || {},
+        _ref$direction = _ref.direction,
+        direction = _ref$direction === void 0 ? [10, 10, 0] : _ref$direction;
+      var duration = animation.duration;
 
-    // 重置所有楼层可见性
-    for (const floorGroup of this.floorGroups.values()) {
-      for (const component of floorGroup.components) component.mesh.visible = true;
-    }
+      // 重置所有楼层可见性
+      var _iterator8 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var floorGroup = _step8.value;
+          var _iterator10 = _createForOfIteratorHelper(floorGroup.components),
+            _step10;
+          try {
+            for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
+              var component = _step10.value;
+              component.mesh.visible = true;
+            }
+          } catch (err) {
+            _iterator10.e(err);
+          } finally {
+            _iterator10.f();
+          }
+        }
 
-    // 计算起始位置和目标位置
-    const startPositions = new Map();
-    const targetPositions = new Map();
-    for (const floorGroup of this.floorGroups.values()) {
-      const floorLevel = floorGroup.level;
-      for (const component of floorGroup.components) {
-        startPositions.set(component.mesh, component.mesh.position.clone());
-        if (floorLevel > targetFloor) {
-          // 上方楼层需要移动
-          const targetPos = component.originalPosition.clone().add(new Vector3().fromArray(direction));
-          targetPositions.set(component.mesh, targetPos);
-        } else {
-          // 其他楼层保持原位
-          targetPositions.set(component.mesh, component.originalPosition.clone());
+        // 计算起始位置和目标位置
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+      var startPositions = new Map();
+      var targetPositions = new Map();
+      var _iterator9 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step9;
+      try {
+        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+          var _floorGroup2 = _step9.value;
+          var floorLevel = _floorGroup2.level;
+          var _iterator11 = _createForOfIteratorHelper(_floorGroup2.components),
+            _step11;
+          try {
+            for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
+              var _component3 = _step11.value;
+              startPositions.set(_component3.mesh, _component3.mesh.position.clone());
+              if (floorLevel > targetFloor) {
+                // 上方楼层需要移动
+                var targetPos = _component3.originalPosition.clone().add(new Vector3().fromArray(direction));
+                targetPositions.set(_component3.mesh, targetPos);
+              } else {
+                // 其他楼层保持原位
+                targetPositions.set(_component3.mesh, _component3.originalPosition.clone());
+              }
+            }
+          } catch (err) {
+            _iterator11.e(err);
+          } finally {
+            _iterator11.f();
+          }
         }
+
+        // 执行动画
+      } catch (err) {
+        _iterator9.e(err);
+      } finally {
+        _iterator9.f();
       }
+      this.animatePositions(startPositions, targetPositions, duration);
     }
 
-    // 执行动画
-    this.animatePositions(startPositions, targetPositions, duration);
-  }
-
-  /**
-   * 计算方向向量
-   * 规则：往右方(X)、前方(Z)是正、往左方(X)、后方(Z)是负数
-   * @param direction 方向枚举
-   * @param distance 移动距离
-   * @returns Vector3 方向向量
-   */
-  getDirectionVector(direction, distance) {
-    const vector = new Vector3(0, 0, 0);
-    const coefficient = 0.7071; // cos(45°) ≈ 0.7071
-    switch (direction) {
-      case EDirection.Right:
-        vector.set(distance, 0, 0);
-        break;
-      case EDirection.Left:
-        vector.set(-distance, 0, 0);
-        break;
-      case EDirection.Front:
-        vector.set(0, 0, distance);
-        break;
-      case EDirection.Back:
-        vector.set(0, 0, -distance);
-        break;
-      case EDirection.Right_Front:
-        vector.set(distance * coefficient, distance * coefficient, distance * coefficient);
-        break;
-      case EDirection.Left_Front:
-        vector.set(-distance * coefficient, distance * coefficient, distance * coefficient);
-        break;
-      case EDirection.Right_Back:
-        vector.set(distance * coefficient, distance * coefficient, -distance * coefficient);
-        break;
-      case EDirection.Left_Back:
-        vector.set(-distance * coefficient, distance * coefficient, -distance * coefficient);
-        break;
-      default:
-        // 默认向右移动
-        vector.set(distance, 0, 0);
+    /**
+     * 计算方向向量
+     * 规则：往右方(X)、前方(Z)是正、往左方(X)、后方(Z)是负数
+     * @param direction 方向枚举
+     * @param distance 移动距离
+     * @returns Vector3 方向向量
+     */
+  }, {
+    key: "getDirectionVector",
+    value: function getDirectionVector(direction, distance) {
+      var vector = new Vector3(0, 0, 0);
+      var coefficient = 0.7071; // cos(45°) ≈ 0.7071
+      switch (direction) {
+        case EDirection.Right:
+          vector.set(distance, 0, 0);
+          break;
+        case EDirection.Left:
+          vector.set(-distance, 0, 0);
+          break;
+        case EDirection.Front:
+          vector.set(0, 0, distance);
+          break;
+        case EDirection.Back:
+          vector.set(0, 0, -distance);
+          break;
+        case EDirection.Right_Front:
+          vector.set(distance * coefficient, distance * coefficient, distance * coefficient);
+          break;
+        case EDirection.Left_Front:
+          vector.set(-distance * coefficient, distance * coefficient, distance * coefficient);
+          break;
+        case EDirection.Right_Back:
+          vector.set(distance * coefficient, distance * coefficient, -distance * coefficient);
+          break;
+        case EDirection.Left_Back:
+          vector.set(-distance * coefficient, distance * coefficient, -distance * coefficient);
+          break;
+        default:
+          // 默认向右移动
+          vector.set(distance, 0, 0);
+      }
+      return vector;
     }
-    return vector;
-  }
 
-  /**
-   * 只显示指定楼层
-   * @param targetFloor 目标楼层
-   */
-  showSoloFloor(targetFloor) {
-    for (const floorGroup of this.floorGroups.values()) {
-      const floorLevel = floorGroup.level;
+    /**
+     * 只显示指定楼层
+     * @param targetFloor 目标楼层
+     */
+  }, {
+    key: "showSoloFloor",
+    value: function showSoloFloor(targetFloor) {
+      var _iterator12 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step12;
+      try {
+        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
+          var floorGroup = _step12.value;
+          var floorLevel = floorGroup.level;
 
-      // 重置所有楼层组件位置
-      for (const component of floorGroup.components) component.mesh.position.copy(component.originalPosition);
+          // 重置所有楼层组件位置
+          var _iterator13 = _createForOfIteratorHelper(floorGroup.components),
+            _step13;
+          try {
+            for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
+              var component = _step13.value;
+              component.mesh.position.copy(component.originalPosition);
+            }
 
-      // 设置可见性
-      const shouldBeVisible = floorLevel === targetFloor;
-      for (const component of floorGroup.components) component.mesh.visible = shouldBeVisible;
+            // 设置可见性
+          } catch (err) {
+            _iterator13.e(err);
+          } finally {
+            _iterator13.f();
+          }
+          var shouldBeVisible = floorLevel === targetFloor;
+          var _iterator14 = _createForOfIteratorHelper(floorGroup.components),
+            _step14;
+          try {
+            for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
+              var _component4 = _step14.value;
+              _component4.mesh.visible = shouldBeVisible;
+            }
+          } catch (err) {
+            _iterator14.e(err);
+          } finally {
+            _iterator14.f();
+          }
+        }
+      } catch (err) {
+        _iterator12.e(err);
+      } finally {
+        _iterator12.f();
+      }
     }
-  }
 
-  /**
-   * 执行位置动画
-   * @param startPositions 起始位置
-   * @param targetPositions 目标位置
-   * @param duration 动画时长
-   */
-  animatePositions(startPositions, targetPositions, duration) {
-    const startTime = performance.now();
-    const animate = () => {
-      const currentTime = performance.now();
-      const elapsed = currentTime - startTime;
-      const progress = Math.min(elapsed / duration, 1);
-      targetPositions.forEach((targetPos, mesh) => {
-        const startPos = startPositions.get(mesh);
-        if (startPos) {
-          // 线性插值计算当前位置
-          mesh.position.lerpVectors(startPos, targetPos, progress);
+    /**
+     * 执行位置动画
+     * @param startPositions 起始位置
+     * @param targetPositions 目标位置
+     * @param duration 动画时长
+     */
+  }, {
+    key: "animatePositions",
+    value: function animatePositions(startPositions, targetPositions, duration) {
+      var _this3 = this;
+      var startTime = performance.now();
+      var animate = function animate() {
+        var currentTime = performance.now();
+        var elapsed = currentTime - startTime;
+        var progress = Math.min(elapsed / duration, 1);
+        targetPositions.forEach(function (targetPos, mesh) {
+          var startPos = startPositions.get(mesh);
+          if (startPos) {
+            // 线性插值计算当前位置
+            mesh.position.lerpVectors(startPos, targetPos, progress);
+          }
+        });
+        if (progress < 1) {
+          requestAnimationFrame(animate);
+        } else {
+          // 动画结束
+          _this3.currentAnimation.timer = null;
         }
-      });
-      if (progress < 1) {
-        requestAnimationFrame(animate);
-      } else {
-        // 动画结束
-        this.currentAnimation.timer = null;
-      }
-    };
-    animate();
+      };
+      animate();
 
-    // 设置超时以确保动画完成
-    this.currentAnimation.timer = window.setTimeout(() => {
-      this.currentAnimation.timer = null;
-    }, duration + 100);
-  }
+      // 设置超时以确保动画完成
+      this.currentAnimation.timer = window.setTimeout(function () {
+        _this3.currentAnimation.timer = null;
+      }, duration + 100);
+    }
 
-  /**
-   * 重置建筑到初始状态
-   */
-  resetBuilding() {
-    for (const floorGroup of this.floorGroups.values()) {
-      for (const component of floorGroup.components) {
-        // 恢复原始位置
-        component.mesh.position.copy(component.originalPosition);
+    /**
+     * 重置建筑到初始状态
+     */
+  }, {
+    key: "resetBuilding",
+    value: function resetBuilding() {
+      var _iterator15 = _createForOfIteratorHelper(this.floorGroups.values()),
+        _step15;
+      try {
+        for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {
+          var floorGroup = _step15.value;
+          var _iterator16 = _createForOfIteratorHelper(floorGroup.components),
+            _step16;
+          try {
+            for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {
+              var component = _step16.value;
+              // 恢复原始位置
+              component.mesh.position.copy(component.originalPosition);
 
-        // 恢复原始可见性
-        component.mesh.visible = component.originalVisibility;
+              // 恢复原始可见性
+              component.mesh.visible = component.originalVisibility;
+            }
+          } catch (err) {
+            _iterator16.e(err);
+          } finally {
+            _iterator16.f();
+          }
+        }
+      } catch (err) {
+        _iterator15.e(err);
+      } finally {
+        _iterator15.f();
       }
     }
-  }
 
-  /**
-   * 获取楼层总数信息
-   */
-  getFloorCounts() {
-    return {
-      aboveGround: this.aboveGroundFloorCount,
-      underground: this.undergroundFloorCount,
-      hasRoof: this.hasRoof
-    };
-  }
-}
+    /**
+     * 获取楼层总数信息
+     */
+  }, {
+    key: "getFloorCounts",
+    value: function getFloorCounts() {
+      return {
+        aboveGround: this.aboveGroundFloorCount,
+        underground: this.undergroundFloorCount,
+        hasRoof: this.hasRoof
+      };
+    }
+  }]);
+  return BuildingSplit;
+}(ObjectLayer);
 export { BuildingSplit, EBuildingSplitType };
 //# sourceMappingURL=index.js.map