<template>
  <!-- 动画系统不需要模板内容 -->
</template>

<script setup>
import { ref, onMounted, onUnmounted } from 'vue';
import { Style, Icon } from 'ol/style';

// 定义props
const props = defineProps({
  map: Object,
  vehicleSource: Object,
  vehicles: Object,
  getVehicleStyle: Function
});

// 动画相关变量
const animationFrameId = ref(null);
const lastAnimationTime = ref(0);
const vehicleAnimations = ref({}); // 存储平滑动画数据
const vehicleMotionHistory = ref({}); // 存储车辆移动历史
const PREDICTION_THRESHOLD = 50; // 从100ms降低到50ms，更早开始预测
const MAX_PREDICTION_TIME = 15000; // 从10000ms增加到15000ms，延长预测时间

// 物理模拟参数
const ACCELERATION = 0.15; // 加速度系数
const DECELERATION = 0.25; // 减速度系数
const INERTIA_FACTOR = 0.99; // 从0.985增加到0.99，进一步增强惯性效果，减少抖动
const PREDICTION_STRENGTH = 3; // 从4降低到3，进一步减少预测激进性，避免过度预测造成抖动
const SPEED_SMOOTHING = 0.98; // 从0.97增加到0.98，进一步增强速度平滑效果
const POSITION_SMOOTHING = 0.06; // 从0.08降低到0.06，进一步减小单次位置变化幅度，增强平滑度
const MIN_MOVE_THRESHOLD = 0.000005; // 从0.00001降低到0.000005，确保更平滑的微小移动
const CONTINUOUS_MOVEMENT = true; // 保持启用连续移动模式
const MIN_SPEED = 0.5; // 从1.0降低到0.5，进一步降低最低保持速度，减少抖动
const PREDICTION_DECAY_RATE = 0.9995; // 从0.999增加到0.9995，进一步减缓预测衰减
const PATH_PREDICTION_ENABLED = true; // 保持启用路径预测
const PATH_PREDICTION_POINTS = 15; // 从20降低到15，减少计算量
const CONTINUOUS_MOVEMENT_THRESHOLD = 200; // 从300ms降低到200ms，更快触发连续移动，减少停顿感
const POSITION_UPDATE_THRESHOLD = 3; // 从5降低到3，进一步减少位置更新阈值

// 缓动函数 - 平滑的加减速
function easeInOutQuad(t) {
  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
}

// 缓动函数 - 更自然的启动
function easeOutCubic(t) {
  return 1 - Math.pow(1 - t, 3);
}

// 缓动函数 - 更自然的减速
function easeOutQuint(t) {
  return 1 - Math.pow(1 - t, 5);
}

// 启动动画循环
function startAnimationLoop() {
  // 确保只有一个动画循环在运行
  if (animationFrameId.value) {
    cancelAnimationFrame(animationFrameId.value);
  }
  
  lastAnimationTime.value = 0; // 重置时间，确保第一帧计算正确
  
  const animate = (timestamp) => {
    if (!lastAnimationTime.value) lastAnimationTime.value = timestamp;
    const deltaTime = timestamp - lastAnimationTime.value;
    lastAnimationTime.value = timestamp;
    
    // 限制deltaTime，提高最小帧率到60fps
    const clampedDeltaTime = Math.min(deltaTime, 16.67); // 约60fps的最小帧率
    
    updateVehicleAnimations(clampedDeltaTime);
    
    animationFrameId.value = requestAnimationFrame(animate);
  };
  
  animationFrameId.value = requestAnimationFrame(animate);
}

// 更新车辆动画
function updateVehicleAnimations(deltaTime) {
  if (!props.vehicleSource || !props.map) return;
  
  const currentTime = performance.now();
  
  Object.keys(props.vehicles).forEach(id => {
    const vehicle = props.vehicles[id];
    if (!vehicle) return;
    
    const animData = vehicleAnimations.value[id];
    if (!animData) return;
    
    // 确保车辆总是在移动，即使没有新的位置更新
    ensureContinuousMovement(animData, vehicle, currentTime, deltaTime);
    
    const timeSinceLastUpdate = currentTime - animData.lastUpdated;
    
    // 1. 计算目标位置（基于预测）
    let targetPosition = [...animData.targetPosition];
    
    // 平滑速度过渡 - 当前速度逐渐接近目标速度
    if (animData.currentSpeed === undefined) {
      animData.currentSpeed = animData.speed;
    } else {
      // 使用更平滑的速度过渡
      const speedSmoothingFactor = vehicle.speedViolation ? 0.98 : SPEED_SMOOTHING;
      animData.currentSpeed = animData.currentSpeed * speedSmoothingFactor + 
                             animData.speed * (1 - speedSmoothingFactor);
    }
    
    let currentSpeed = animData.currentSpeed;
    
    // 根据时间应用不同程度的预测
    if (timeSinceLastUpdate > PREDICTION_THRESHOLD && animData.predictionVector) {
      // 计算预测因子，随时间增长但有上限
      const predictTime = Math.min(timeSinceLastUpdate, MAX_PREDICTION_TIME);
      const predictFactor = (predictTime - PREDICTION_THRESHOLD) / 1000 * 0.6; // 从0.8降低到0.6，减少预测激进性
      
      // 应用预测向量，考虑当前速度
      const speedFactor = Math.min(1.0, currentSpeed / 30); // 从1.2/25降低到1.0/30，减少高速预测
      
      // 计算预测位置
      const predictedPosition = [
        animData.targetPosition[0] + animData.predictionVector[0] * predictFactor * speedFactor,
        animData.targetPosition[1] + animData.predictionVector[1] * predictFactor * speedFactor
      ];
      
      // 平滑过渡到预测位置
      targetPosition = predictedPosition;
      
      // 预测时逐渐降低速度，但不要完全停止
      if (predictTime > 2000) {
        // 长时间无更新，缓慢降低速度，但保持最低速度
        const slowdownFactor = Math.max(0.6, 1 - (predictTime - 2000) / 15000); // 从0.5/10000调整为0.6/15000，减缓减速率
        currentSpeed = Math.max(currentSpeed * slowdownFactor, MIN_SPEED); // 确保最低速度不为0
      }
    }
    
    // 2. 计算当前位置到目标位置的向量
    const dx = targetPosition[0] - animData.position[0];
    const dy = targetPosition[1] - animData.position[1];
    const distance = Math.sqrt(dx * dx + dy * dy);
    
    // 忽略过小的位置更新，减少抖动
    if (distance < MIN_MOVE_THRESHOLD && !CONTINUOUS_MOVEMENT) {
      return;
    }
    
    // 3. 如果距离足够远或启用了连续移动，应用平滑移动
    if (distance > MIN_MOVE_THRESHOLD || CONTINUOUS_MOVEMENT) {
      // 计算理想移动距离（基于速度和时间）
      const idealDistance = (currentSpeed * 1000 / 3600) * (deltaTime / 1000);
      
      // 根据距离动态调整移动比例
      let moveRatio;
      
      // 超速车辆使用更平滑的移动
      const positionSmoothingFactor = vehicle.speedViolation ? POSITION_SMOOTHING * 0.7 : POSITION_SMOOTHING;
      
      if (distance < idealDistance * 1.2) { // 从1.5降低到1.2，更早开始减速
        // 接近目标时减速（使用更强的缓动）
        moveRatio = Math.min(positionSmoothingFactor * 1.2, idealDistance / distance); // 从1.5降低到1.2
        moveRatio = easeOutQuint(moveRatio);
      } else {
        // 正常行驶时使用标准缓动
        moveRatio = Math.min(positionSmoothingFactor, idealDistance / distance);
        moveRatio = easeOutCubic(moveRatio);
      }
      
      // 修复逻辑：确保最小移动和惯性移动是互斥的
      // 如果距离很小且有预测向量，使用预测向量进行微小移动
      if (distance < MIN_MOVE_THRESHOLD && animData.predictionVector) {
        // 使用预测向量作为移动方向，但使用很小的移动量
        const minMoveAmount = (currentSpeed * 1000 / 3600) * (deltaTime / 1000) * 0.05; // 从0.1降低到0.05，减小微小移动幅度
        
        // 归一化预测向量
        const predLen = Math.sqrt(
          animData.predictionVector[0] * animData.predictionVector[0] + 
          animData.predictionVector[1] * animData.predictionVector[1]
        );
        
        if (predLen > 0) {
          const normPredX = animData.predictionVector[0] / predLen;
          const normPredY = animData.predictionVector[1] / predLen;
          
          // 应用最小移动量
          animData.position[0] += normPredX * minMoveAmount;
          animData.position[1] += normPredY * minMoveAmount;
          
          // 保存本次移动向量用于下一帧惯性计算
          animData.lastDx = normPredX * minMoveAmount;
          animData.lastDy = normPredY * minMoveAmount;
        }
      } 
      // 距离足够大时，应用惯性移动
      else {
        if (animData.lastDx !== undefined && animData.lastDy !== undefined) {
          // 超速车辆使用更强的惯性
          const inertiaFactor = vehicle.speedViolation ? INERTIA_FACTOR * 1.05 : INERTIA_FACTOR; // 从1.1降低到1.05，减少超速车辆惯性过强
          
          const inertiaX = animData.lastDx * inertiaFactor;
          const inertiaY = animData.lastDy * inertiaFactor;
          
          // 混合新方向和惯性方向
          const newDx = dx * moveRatio;
          const newDy = dy * moveRatio;
          
          // 根据速度和距离调整惯性影响
          const inertiaWeight = Math.min(0.75, currentSpeed / 80) * // 从0.85/70降低到0.75/80，减少惯性权重
                              Math.min(0.9, distance / 10); // 从1.0/8调整为0.9/10，减少短距离惯性
          
          // 计算新位置（混合惯性和目标方向）
          const nextX = animData.position[0] + newDx * (1 - inertiaWeight) + inertiaX * inertiaWeight;
          const nextY = animData.position[1] + newDy * (1 - inertiaWeight) + inertiaY * inertiaWeight;
          
          // 应用位置更新
          animData.position[0] = nextX;
          animData.position[1] = nextY;
          
          // 保存本次移动向量用于下一帧惯性计算
          animData.lastDx = nextX - animData.position[0];
          animData.lastDy = nextY - animData.position[1];
        } else {
          // 首次移动，没有惯性
          animData.position[0] += dx * moveRatio;
          animData.position[1] += dy * moveRatio;
          
          // 初始化移动向量
          animData.lastDx = dx * moveRatio;
          animData.lastDy = dy * moveRatio;
        }
      }
      
      // 更新地图上的要素位置
      const feature = props.vehicleSource.getFeatureById(id);
      if (feature) {
        feature.getGeometry().setCoordinates(animData.position);
        
        // 更新车辆对象中的位置信息，确保标签能够正确跟随
        if (props.vehicles[id]) {
          props.vehicles[id].position = animData.position;
        }
        
        // 更新车辆样式，传递正确的heading值
        if (feature && props.getVehicleStyle) {
          // 获取车辆的当前heading值
          const vehicle = props.vehicles[id];
          const currentHeading = vehicle ? vehicle.heading : 0;
          
          // 只在heading发生变化时才更新样式，避免频繁更新导致闪烁
          if (!animData.lastHeading || Math.abs(animData.lastHeading - currentHeading) > 1) {
            feature.setStyle(props.getVehicleStyle(id, currentSpeed, currentHeading));
            animData.lastHeading = currentHeading;
          }
        }
      }
    }
    
    // 保存当前速度用于下一帧
    animData.currentSpeed = currentSpeed;
    
    // 更新历史轨迹
    updateVehiclePathHistory(id, animData, currentTime);
  });
}

// 更新车辆历史轨迹
function updateVehiclePathHistory(id, animData, currentTime) {
  // 初始化历史轨迹数组（如果不存在）
  if (!animData.pathHistory) {
    animData.pathHistory = [];
  }
  
  // 每150ms记录一次位置，提高记录频率
  if (!animData.lastPathRecordTime || currentTime - animData.lastPathRecordTime > 150) {
    // 添加当前位置到历史轨迹
    animData.pathHistory.push({
      time: currentTime,
      position: [...animData.position],
      heading: animData.heading,
      speed: animData.currentSpeed
    });
    
    // 增加历史轨迹长度，提供更多数据点用于预测
    if (animData.pathHistory.length > PATH_PREDICTION_POINTS + 4) {
      animData.pathHistory.shift();
    }
    
    animData.lastPathRecordTime = currentTime;
  }
}

// 确保车辆持续移动，即使没有新的位置更新
function ensureContinuousMovement(animData, vehicle, currentTime, deltaTime) {
  // 检查上次更新时间，使用更低的阈值
  const timeSinceLastUpdate = currentTime - animData.lastUpdated;
  
  // 如果超过阈值没有位置更新，且车辆当前速度大于0
  if (timeSinceLastUpdate > CONTINUOUS_MOVEMENT_THRESHOLD && animData.currentSpeed > 0) {
    // 如果启用了路径预测，使用历史轨迹预测未来路径
    if (PATH_PREDICTION_ENABLED && animData.pathHistory && animData.pathHistory.length >= 3) {
      const predictedPath = predictFuturePath(animData);
      if (predictedPath) {
        // 平滑过渡到预测向量，而不是直接替换
        if (!animData.predictionVector) {
          animData.predictionVector = predictedPath.vector;
        } else {
          // 平滑混合当前预测向量和新预测向量，使用更平滑的过渡
          animData.predictionVector = [
            animData.predictionVector[0] * 0.8 + predictedPath.vector[0] * 0.2, // 从0.7/0.3调整为0.8/0.2
            animData.predictionVector[1] * 0.8 + predictedPath.vector[1] * 0.2
          ];
        }
        
        // 平滑过渡到预测位置，使用更平滑的过渡
        animData.targetPosition = [
          animData.targetPosition[0] * 0.8 + predictedPath.position[0] * 0.2, // 从0.7/0.3调整为0.8/0.2
          animData.targetPosition[1] * 0.8 + predictedPath.position[1] * 0.2
        ];
      }
    } 
    // 如果没有预测向量或预测向量太小，创建一个基于历史数据的预测向量
    else if (!animData.predictionVector || 
        (Math.abs(animData.predictionVector[0]) < 0.001 && Math.abs(animData.predictionVector[1]) < 0.001)) {
      
      // 使用最近两个历史点计算预测向量
      if (animData.pathHistory && animData.pathHistory.length >= 2) {
        const latestPoints = animData.pathHistory.slice(-2);
        const dx = latestPoints[1].position[0] - latestPoints[0].position[0];
        const dy = latestPoints[1].position[1] - latestPoints[0].position[1];
        const len = Math.sqrt(dx*dx + dy*dy);
        
        if (len > 0.001) {
          const normalizedDx = dx / len;
          const normalizedDy = dy / len;
          const predX = normalizedDx * animData.currentSpeed * 0.18;
          const predY = normalizedDy * animData.currentSpeed * 0.18;
          animData.predictionVector = [predX, predY];
          
          // 更新目标位置为当前位置加上预测向量
          animData.targetPosition = [
            animData.position[0] + predX * 15,
            animData.position[1] + predY * 15
          ];
        } else {
          // 如果历史点距离太近，使用默认的前进向量
          animData.predictionVector = [0, animData.currentSpeed * 0.18];
          animData.targetPosition = [
            animData.position[0],
            animData.position[1] + animData.currentSpeed * 0.18 * 15
          ];
        }
      } else {
        // 没有足够的历史数据，使用默认的前进向量
        animData.predictionVector = [0, animData.currentSpeed * 0.18];
        animData.targetPosition = [
          animData.position[0],
          animData.position[1] + animData.currentSpeed * 0.18 * 15
        ];
      }
    } else {
      // 预测向量存在但需要缓慢衰减，避免突然停止
      // 使用更高的衰减率
      animData.predictionVector = [
        animData.predictionVector[0] * PREDICTION_DECAY_RATE,
        animData.predictionVector[1] * PREDICTION_DECAY_RATE
      ];
      
      // 更新目标位置
      animData.targetPosition = [
        animData.position[0] + animData.predictionVector[0] * 15, // 从12增加到15
        animData.position[1] + animData.predictionVector[1] * 15
      ];
    }
    
    // 缓慢降低速度，但保持更高的最低速度
    if (!animData.lastSpeedReduction || currentTime - animData.lastSpeedReduction > 1000) {
      animData.speed = Math.max(animData.speed * 0.98, MIN_SPEED); // 从0.97增加到0.98，进一步减缓速度降低率
      animData.lastSpeedReduction = currentTime;
    }
  }
}

// 基于历史轨迹预测未来路径
function predictFuturePath(animData) {
  if (!animData.pathHistory || animData.pathHistory.length < 3) {
    return null;
  }
  
  // 获取最近的几个历史点
  const history = animData.pathHistory;
  const points = history.length;
  
  // 计算平均移动向量
  let totalDx = 0;
  let totalDy = 0;
  let totalWeight = 0;
  
  // 从最近的点开始，给予更高权重
  for (let i = points - 2; i >= 0; i--) {
    const curr = history[i + 1];
    const prev = history[i];
    
    // 计算两点之间的向量
    const dx = curr.position[0] - prev.position[0];
    const dy = curr.position[1] - prev.position[1];
    
    // 计算时间差
    const dt = curr.time - prev.time;
    
    // 改进权重计算，使用指数衰减而不是线性衰减
    // 这会使最近的点有更大的影响力
    const weight = Math.pow(0.8, (points - i - 1)) / Math.max(1, dt / 1000);
    
    totalDx += dx * weight;
    totalDy += dy * weight;
    totalWeight += weight;
  }
  
  // 如果没有有效的移动向量，返回null
  if (totalWeight <= 0) {
    return null;
  }
  
  // 计算加权平均向量
  const avgDx = totalDx / totalWeight;
  const avgDy = totalDy / totalWeight;
  
  // 计算向量长度
  const vectorLength = Math.sqrt(avgDx * avgDx + avgDy * avgDy);
  
  // 如果向量太小，返回null
  if (vectorLength < 0.001) {
    return null;
  }
  
  // 归一化向量并应用当前速度
  const normalizedDx = avgDx / vectorLength;
  const normalizedDy = avgDy / vectorLength;
  
  // 根据当前速度缩放向量，增加平滑因子
  const speedFactor = animData.currentSpeed * 0.12; // 增加到0.12
  const predictionVector = [
    normalizedDx * speedFactor,
    normalizedDy * speedFactor
  ];
  
  // 计算预测位置，增加预测距离
  const predictedPosition = [
    animData.position[0] + normalizedDx * speedFactor * 12, // 增加到12
    animData.position[1] + normalizedDy * speedFactor * 12
  ];
  
  return {
    vector: predictionVector,
    position: predictedPosition
  };
}

// 初始化车辆动画数据
function initVehicleAnimation(id, coordinates, heading, speed) {
  vehicleAnimations.value[id] = {
    position: [...coordinates],
    targetPosition: [...coordinates],
    heading: heading, // 保存heading值
    targetHeading: heading, // 保存目标heading值
    speed: speed,
    currentSpeed: speed,
    lastUpdated: Date.now(),
    predictionVector: null,
    lastDx: 0,
    lastDy: 0,
    lastHeading: heading, // 添加lastHeading字段用于跟踪heading变化
    // 添加速度历史记录用于平滑过渡
    speedHistory: [speed, speed, speed],
    pathHistory: [], // 初始化路径历史
    lastPathRecordTime: Date.now() // 初始化路径记录时间
  };
  
  vehicleMotionHistory.value[id] = [];
}

// 更新车辆动画目标
function updateVehicleAnimationTarget(id, coordinates, heading, speed) {
  const animData = vehicleAnimations.value[id] || {};
  const now = Date.now();
  
  // 记录历史轨迹点
  vehicleMotionHistory.value[id] = vehicleMotionHistory.value[id] || [];
  vehicleMotionHistory.value[id].push({
    time: now,
    position: coordinates,
    heading: heading, // 保存正确的heading值
    speed: speed
  });
  
  // 增加历史点数量
  if (vehicleMotionHistory.value[id].length > 10) { // 从8增加到10
    vehicleMotionHistory.value[id].shift();
  }
  
  // 计算预测向量 - 使用更复杂的算法
  let predictionVector = [0, 0];
  
  if (vehicleMotionHistory.value[id].length >= 2) {
    // 基本预测 - 使用最近两点
    const history = vehicleMotionHistory.value[id];
    const latest = history[history.length - 1];
    const previous = history[history.length - 2];
    
    const dt = Math.max(1, latest.time - previous.time);
    const dx = (latest.position[0] - previous.position[0]);
    const dy = (latest.position[1] - previous.position[1]);
    
    // 基础预测向量 - 考虑时间间隔
    const baseSpeed = Math.sqrt(dx*dx + dy*dy) * (1000 / dt); // 单位时间内的移动距离
    const normalizedDx = baseSpeed > 0 ? dx / baseSpeed : 0;
    const normalizedDy = baseSpeed > 0 ? dy / baseSpeed : 0;
    
    // 减小预测强度
    predictionVector = [
      normalizedDx * (PREDICTION_STRENGTH * 0.9) * baseSpeed, 
      normalizedDy * (PREDICTION_STRENGTH * 0.9) * baseSpeed
    ];
    
    // 如果有更多历史点，使用加权平均提高预测准确性
    if (vehicleMotionHistory.value[id].length >= 3) {
      // 使用多个历史点计算平均移动趋势
      let totalWeight = 0;
      let weightedDx = 0;
      let weightedDy = 0;
      
      // 从最近到最远遍历历史点，使用更多的历史点
      for (let i = history.length - 2; i >= 0 && i >= history.length - 7; i--) { // 从5增加到7
        const curr = history[i+1];
        const prev = history[i];
        
        const pointDt = Math.max(1, curr.time - prev.time);
        const pointDx = curr.position[0] - prev.position[0];
        const pointDy = curr.position[1] - prev.position[1];
        
        // 使用指数衰减权重
        const weight = Math.pow(0.85, (history.length - i - 1));
        totalWeight += weight;
        
        weightedDx += pointDx * weight;
        weightedDy += pointDy * weight;
      }
      
      if (totalWeight > 0) {
        // 归一化加权向量
        weightedDx /= totalWeight;
        weightedDy /= totalWeight;
        
        // 混合最新向量和加权历史向量，增加历史向量的权重
        predictionVector = [
          predictionVector[0] * 0.6 + weightedDx * PREDICTION_STRENGTH * 0.4, // 从0.7/0.3调整为0.6/0.4
          predictionVector[1] * 0.6 + weightedDy * PREDICTION_STRENGTH * 0.4
        ];
      }
    }
    
    // 根据速度调整预测强度，使用更平滑的曲线
    const speedFactor = Math.min(1.8, Math.pow(speed / 15, 0.8)); // 使用幂函数使曲线更平滑
    predictionVector = [
      predictionVector[0] * speedFactor,
      predictionVector[1] * speedFactor
    ];
    
    // 如果车辆几乎静止，减弱预测但保持最低预测强度
    if (speed < 2) {
      predictionVector = [
        predictionVector[0] * 0.4, // 从0.3增加到0.4
        predictionVector[1] * 0.4
      ];
    }
  }
  
  // 保存速度历史用于平滑过渡，增加历史点
  if (!animData.speedHistory) {
    animData.speedHistory = [speed, speed, speed, speed]; // 增加一个点
  } else {
    animData.speedHistory.push(speed);
    if (animData.speedHistory.length > 4) { // 从3增加到4
      animData.speedHistory.shift();
    }
  }
  
  // 计算平滑速度（避免速度突变）
  const smoothedSpeed = animData.speedHistory.reduce((sum, s) => sum + s, 0) / 
                       animData.speedHistory.length;
  
  // 更新动画数据 - 保留当前位置，只更新目标位置
  vehicleAnimations.value[id] = {
    ...animData,
    targetPosition: coordinates,
    targetHeading: heading, // 保存目标heading值
    heading: animData.heading || heading, // 保留当前heading，如果不存在则使用新的heading
    position: animData.position || coordinates,
    speed: smoothedSpeed, // 使用平滑后的速度
    lastUpdated: now,
    predictionVector,
    speedHistory: animData.speedHistory
  };
}

// 停止动画循环
function stopAnimationLoop() {
  if (animationFrameId.value) {
    cancelAnimationFrame(animationFrameId.value);
    animationFrameId.value = null;
  }
}

// 重置动画数据
function resetAnimations() {
  vehicleAnimations.value = {};
  vehicleMotionHistory.value = {};
  
  Object.keys(props.vehicles).forEach(id => {
    const vehicle = props.vehicles[id];
    if (vehicle) {
      vehicleAnimations.value[id] = {
        position: [...vehicle.position],
        targetPosition: [...vehicle.position],
        heading: vehicle.heading || 0, // 使用车辆的heading值
        targetHeading: vehicle.heading || 0, // 使用车辆的heading值
        speed: vehicle.speed,
        currentSpeed: vehicle.speed,
        lastUpdated: Date.now(),
        predictionVector: null,
        lastDx: 0,
        lastDy: 0,
        lastHeading: vehicle.heading || 0, // 使用车辆的heading值
        speedHistory: [vehicle.speed, vehicle.speed, vehicle.speed],
        pathHistory: [], // 重置路径历史
        lastPathRecordTime: Date.now() // 重置路径记录时间
      };
    }
  });
}

// 组件挂载时启动动画
onMounted(() => {
  startAnimationLoop();
});

// 组件卸载时清理
onUnmounted(() => {
  stopAnimationLoop();
});

// 暴露方法
defineExpose({
  startAnimationLoop,
  stopAnimationLoop,
  resetAnimations,
  initVehicleAnimation,
  updateVehicleAnimationTarget,
  vehicleAnimations,
  vehicleMotionHistory
});
</script> 