@anov/3d-ability 0.0.139 → 0.0.141

package/dist/business/SplitBuilding/index.js

@@ -1,593 +1,384 @@
-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";
-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", {
+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", {
       timer: null
     });
-    _defineProperty(_assertThisInitialized(_this), "_building", void 0);
-    _this._building = building;
-    _this.init();
-    return _this;
+    _defineProperty(this, "_building", void 0);
+    this._building = building;
+    this.init();
+  }
+  get building() {
+    return this._building;
   }
-  _createClass(BuildingSplit, [{
-    key: "building",
-    get: function get() {
-      return this._building;
-    }
 
-    /**
-     * 初始化建筑拆分器
-     * @param building 建筑模型
-     */
-  }, {
-    key: "init",
-    value: function init() {
-      this.floorGroups = new Map();
-      this.sortedFloorLevels = [];
-      this.aboveGroundFloorCount = 0;
-      this.undergroundFloorCount = 0;
-      this.hasRoof = false;
+  /**
+   * 初始化建筑拆分器
+   * @param building 建筑模型
+   */
+  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(function (group) {
-        return group.level;
-      }).sort(function (a, b) {
-        return a - b;
-      });
-    }
+    // 排序楼层编号从低到高
+    this.sortedFloorLevels = Array.from(this.floorGroups.values()).map(group => group.level).sort((a, b) => a - b);
+  }
 
-    /**
-     * 解析建筑模型中的楼层
-     */
-  }, {
-    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;
-          }
+  /**
+   * 解析建筑模型中的楼层
+   */
+  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;
+        }
 
-          // 提取楼层前缀
-          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);
-            }
+        // 提取楼层前缀
+        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);
           }
-          if (prefix) {
-            _this2.addToFloorGroup(prefix, {
-              mesh: object,
-              originalPosition: object.position.clone(),
-              originalVisibility: object.visible
-            }, level, isUnderground);
+        } 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) {
+          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);
+  }
 
-    /**
-     * 将组件添加到对应楼层分组
-     */
-  }, {
-    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);
+  /**
+   * 拆分楼层
+   * @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;
     }
 
-    /**
-     * 拆分楼层
-     * @param options 拆分选项
-     * @returns 成功或错误信息
-     */
-  }, {
-    key: "split",
-    value: function split(options) {
-      var floor = options.floor,
-        animation = options.animation;
-      var animOption = animation || {
-        type: EBuildingSplitType.Move,
-        duration: 1000
+    // 处理 floor = 0 的情况：恢复完整状态
+    if (floor === 0) {
+      this.resetBuilding();
+      return {
+        success: true
       };
+    }
 
-      // 取消当前动画
-      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;
-      }
+    // 验证楼层参数
+    if (floor > 0 && floor > this.aboveGroundFloorCount) {
       return {
-        success: true
+        success: false,
+        message: `地上楼层数超出范围，最大楼层为 ${this.aboveGroundFloorCount}`
+      };
+    }
+    if (floor < 0 && Math.abs(floor) > this.undergroundFloorCount) {
+      return {
+        success: false,
+        message: `地下楼层数超出范围，最大地下楼层为 ${this.undergroundFloorCount}`
       };
     }
 
-    /**
-     * 隐藏指定楼层以上的楼层
-     * @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;
+    // 执行拆分操作
+    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
+    };
+  }
 
-          // 重置所有楼层组件位置
-          var _iterator2 = _createForOfIteratorHelper(floorGroup.components),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var component = _step2.value;
-              component.mesh.position.copy(component.originalPosition);
-            }
+  /**
+   * 隐藏指定楼层以上的楼层
+   * @param targetFloor 目标楼层
+   */
+  hideAboveFloors(targetFloor) {
+    for (const floorGroup of this.floorGroups.values()) {
+      const floorLevel = floorGroup.level;
 
-            // 设置可见性
-          } 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();
-      }
+      // 重置所有楼层组件位置
+      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;
     }
+  }
 
-    /**
-     * 将指定楼层以上的楼层整体上移
-     * @param targetFloor 目标楼层
-     * @param animation 动画选项
-     */
-  }, {
-    key: "moveAboveFloorsUp",
-    value: function moveAboveFloorsUp(targetFloor, animation) {
-      var distance = 10;
-      var duration = animation.duration;
+  /**
+   * 将指定楼层以上的楼层整体上移
+   * @param targetFloor 目标楼层
+   * @param animation 动画选项
+   */
+  moveAboveFloorsUp(targetFloor, animation) {
+    const distance = 10;
+    const duration = animation.duration;
 
-      // 重置所有楼层可见性
-      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();
-          }
-        }
+    // 重置所有楼层可见性
+    for (const floorGroup of this.floorGroups.values()) {
+      for (const component of floorGroup.components) component.mesh.visible = true;
+    }
 
-        // 计算起始位置和目标位置
-      } 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();
-          }
+    // 计算起始位置和目标位置
+    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) {
-        _iterator5.e(err);
-      } finally {
-        _iterator5.f();
       }
-      this.animatePositions(startPositions, targetPositions, 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;
+    // 执行动画
+    this.animatePositions(startPositions, targetPositions, duration);
+  }
 
-      // 重置所有楼层可见性
-      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();
-          }
-        }
+  /**
+   * 将指定楼层以上的楼层向指定方向移动
+   * @param targetFloor 目标楼层
+   * @param animation 动画选项
+   */
+  moveAboveFloorsDirection(targetFloor, animation) {
+    const {
+      direction = [10, 10, 0]
+    } = animation.rule || {};
+    const duration = animation.duration;
 
-        // 计算起始位置和目标位置
-      } 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();
-          }
-        }
+    // 重置所有楼层可见性
+    for (const floorGroup of this.floorGroups.values()) {
+      for (const component of floorGroup.components) component.mesh.visible = true;
+    }
 
-        // 执行动画
-      } catch (err) {
-        _iterator9.e(err);
-      } finally {
-        _iterator9.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());
+        }
       }
-      this.animatePositions(startPositions, targetPositions, duration);
     }
 
-    /**
-     * 计算方向向量
-     * 规则：往右方(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;
+    // 执行动画
+    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);
     }
+    return vector;
+  }
 
-    /**
-     * 只显示指定楼层
-     * @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;
+  /**
+   * 只显示指定楼层
+   * @param targetFloor 目标楼层
+   */
+  showSoloFloor(targetFloor) {
+    for (const floorGroup of this.floorGroups.values()) {
+      const floorLevel = floorGroup.level;
 
-          // 重置所有楼层组件位置
-          var _iterator13 = _createForOfIteratorHelper(floorGroup.components),
-            _step13;
-          try {
-            for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
-              var component = _step13.value;
-              component.mesh.position.copy(component.originalPosition);
-            }
+      // 重置所有楼层组件位置
+      for (const component of floorGroup.components) component.mesh.position.copy(component.originalPosition);
 
-            // 设置可见性
-          } 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();
-      }
+      // 设置可见性
+      const shouldBeVisible = floorLevel === targetFloor;
+      for (const component of floorGroup.components) component.mesh.visible = shouldBeVisible;
     }
+  }
 
-    /**
-     * 执行位置动画
-     * @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;
+  /**
+   * 执行位置动画
+   * @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);
         }
-      };
-      animate();
+      });
+      if (progress < 1) {
+        requestAnimationFrame(animate);
+      } else {
+        // 动画结束
+        this.currentAnimation.timer = null;
+      }
+    };
+    animate();
 
-      // 设置超时以确保动画完成
-      this.currentAnimation.timer = window.setTimeout(function () {
-        _this3.currentAnimation.timer = null;
-      }, duration + 100);
-    }
+    // 设置超时以确保动画完成
+    this.currentAnimation.timer = window.setTimeout(() => {
+      this.currentAnimation.timer = null;
+    }, duration + 100);
+  }
 
-    /**
-     * 重置建筑到初始状态
-     */
-  }, {
-    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);
+  /**
+   * 重置建筑到初始状态
+   */
+  resetBuilding() {
+    for (const floorGroup of this.floorGroups.values()) {
+      for (const component of floorGroup.components) {
+        // 恢复原始位置
+        component.mesh.position.copy(component.originalPosition);
 
-              // 恢复原始可见性
-              component.mesh.visible = component.originalVisibility;
-            }
-          } catch (err) {
-            _iterator16.e(err);
-          } finally {
-            _iterator16.f();
-          }
-        }
-      } catch (err) {
-        _iterator15.e(err);
-      } finally {
-        _iterator15.f();
+        // 恢复原始可见性
+        component.mesh.visible = component.originalVisibility;
       }
     }
+  }
 
-    /**
-     * 获取楼层总数信息
-     */
-  }, {
-    key: "getFloorCounts",
-    value: function getFloorCounts() {
-      return {
-        aboveGround: this.aboveGroundFloorCount,
-        underground: this.undergroundFloorCount,
-        hasRoof: this.hasRoof
-      };
-    }
-  }]);
-  return BuildingSplit;
-}(ObjectLayer);
+  /**
+   * 获取楼层总数信息
+   */
+  getFloorCounts() {
+    return {
+      aboveGround: this.aboveGroundFloorCount,
+      underground: this.undergroundFloorCount,
+      hasRoof: this.hasRoof
+    };
+  }
+}
 export { BuildingSplit, EBuildingSplitType };
 //# sourceMappingURL=index.js.map