diff --git a/rm_common/include/rm_common/decision/command_sender.h b/rm_common/include/rm_common/decision/command_sender.h
index ddb0ab2f..c4f18198 100644
--- a/rm_common/include/rm_common/decision/command_sender.h
+++ b/rm_common/include/rm_common/decision/command_sender.h
@@ -551,10 +551,10 @@ class ShooterCommandSender : public TimeStampCommandSenderBase<rm_msgs::ShootCmd
   double getWheelSpeedDes()
   {
     setSpeedDesAndWheelSpeedDes();
+    if (deploy_flag_)
+      return deploy_wheel_speed_;
     if (hero_flag_)
     {
-      if (deploy_flag_)
-        return deploy_wheel_speed_;
       return wheel_speed_des_;
     }
     return wheel_speed_des_ + total_extra_wheel_speed_;
@@ -805,7 +805,9 @@ class JointPositionBinaryCommandSender : public CommandSenderBase<std_msgs::Floa
 public:
   explicit JointPositionBinaryCommandSender(ros::NodeHandle& nh) : CommandSenderBase<std_msgs::Float64>(nh)
   {
-    ROS_ASSERT(nh.getParam("on_pos", on_pos_) && nh.getParam("off_pos", off_pos_));
+    // ROS_ASSERT(nh.getParam("on_pos", on_pos_) && nh.getParam("off_pos", off_pos_));
+    nh.getParam("on_pos", on_pos_);
+    nh.getParam("off_pos", off_pos_);
   }
   void on()
   {
@@ -821,6 +823,12 @@ class JointPositionBinaryCommandSender : public CommandSenderBase<std_msgs::Floa
   {
     current_position_ = msg_.data;
     change_position_ = current_position_ + scale * per_change_position_;
+    const double min_position = on_pos_ < off_pos_ ? on_pos_ : off_pos_;
+    const double max_position = on_pos_ > off_pos_ ? on_pos_ : off_pos_;
+    if (change_position_ < min_position)
+      change_position_ = min_position;
+    else if (change_position_ > max_position)
+      change_position_ = max_position;
     msg_.data = change_position_;
   }
   bool getState() const
@@ -835,7 +843,7 @@ class JointPositionBinaryCommandSender : public CommandSenderBase<std_msgs::Floa
 
 private:
   bool state{};
-  double on_pos_{}, off_pos_{}, current_position_{}, change_position_{}, per_change_position_{ 0.05 };
+  double on_pos_{}, off_pos_{}, current_position_{}, change_position_{}, per_change_position_{ 0.03 };
 };
 
 class CardCommandSender : public CommandSenderBase<std_msgs::Float64>
diff --git a/rm_common/include/rm_common/decision/heat_limit.h b/rm_common/include/rm_common/decision/heat_limit.h
index f42b55fe..b19ffb49 100644
--- a/rm_common/include/rm_common/decision/heat_limit.h
+++ b/rm_common/include/rm_common/decision/heat_limit.h
@@ -62,6 +62,8 @@ class HeatLimit
       ROS_ERROR("Burst shoot frequency no defined (namespace: %s)", nh.getNamespace().c_str());
     if (!nh.getParam("minimal_shoot_frequency", minimal_shoot_frequency_))
       ROS_ERROR("Minimal shoot frequency no defined (namespace: %s)", nh.getNamespace().c_str());
+    if (!nh.getParam("outpost_shoot_frequency", outpost_shoot_frequency_))
+      ROS_ERROR("Outpost shoot frequency no defined (namespace: %s)", nh.getNamespace().c_str());
     if (!nh.getParam("safe_shoot_frequency", safe_shoot_frequency_))
       ROS_ERROR("Safe shoot frequency no defined (namespace: %s)", nh.getNamespace().c_str());
     if (!nh.getParam("heat_coeff", heat_coeff_))
@@ -113,6 +115,7 @@ class HeatLimit
     }
     local_heat_pub_data_.once_shoot_num = once_shoot_num_;
     local_heat_pub_data_.local_shooter_cooling_heat = local_shooter_cooling_heat_;
+    local_heat_pub_data_.desire_shoot_frequency = shoot_frequency_;
     local_heat_pub_.publish(local_heat_pub_data_);
   }
 
@@ -137,6 +140,7 @@ class HeatLimit
     {
       shooter_cooling_heat_ = data.shooter_id_1_42_mm_cooling_heat;
     }
+    referee_status_change_ = true;
   }
 
   void setRefereeStatus(bool status)
@@ -144,13 +148,16 @@ class HeatLimit
     referee_is_online_ = status;
   }
 
-  double getShootFrequency() const
+  double getShootFrequency()
   {
     std::lock_guard<std::mutex> lock(heat_mutex_);
     if (!referee_is_online_)
       return 5.0;
-    if (state_ == BURST)
-      return shoot_frequency_;
+    if (referee_status_change_ && abs(local_shooter_cooling_heat_ - shooter_cooling_heat_) > 10)
+    {
+      local_shooter_cooling_heat_ = shooter_cooling_heat_;
+    }
+    referee_status_change_ = false;
     double shooter_cooling_heat =
         (use_local_heat_ || !referee_is_online_) ? local_shooter_cooling_heat_ : shooter_cooling_heat_;
     if (shooter_cooling_limit_ - shooter_cooling_heat < bullet_heat_)
@@ -192,7 +199,7 @@ class HeatLimit
     state_ = mode;
   }
 
-  bool getShootFrequencyMode() const
+  int getShootFrequencyMode() const
   {
     return state_;
   }
@@ -231,12 +238,13 @@ class HeatLimit
   std::string type_{};
   bool burst_flag_ = false;
   double bullet_heat_, safe_shoot_frequency_{}, heat_coeff_{}, shoot_frequency_{}, low_shoot_frequency_{},
-      high_shoot_frequency_{}, burst_shoot_frequency_{}, minimal_shoot_frequency_{};
+      high_shoot_frequency_{}, burst_shoot_frequency_{}, minimal_shoot_frequency_{}, outpost_shoot_frequency_{};
 
   bool referee_is_online_, use_local_heat_, last_shoot_state_{};
   int shooter_cooling_limit_, shooter_cooling_rate_, shooter_cooling_heat_;
   double local_shooter_cooling_heat_{}, heat_protect_threshold_{};
   int once_shoot_num_{};
+  bool referee_status_change_{};
 
   ros::Publisher local_heat_pub_;
   ros::Subscriber shoot_state_sub_;
diff --git a/rm_common/include/rm_common/decision/invincible_detect.h b/rm_common/include/rm_common/decision/invincible_detect.h
new file mode 100644
index 00000000..3eaa9fbe
--- /dev/null
+++ b/rm_common/include/rm_common/decision/invincible_detect.h
@@ -0,0 +1,54 @@
+//
+// Created by ray on 25-1-11.
+//
+
+#pragma once
+
+#include <ros/ros.h>
+#include <rm_msgs/GameStatus.h>
+#include <rm_msgs/GameRobotStatus.h>
+
+namespace rm_common
+{
+class InvincibleDetect
+{
+public:
+  InvincibleDetect(ros::NodeHandle& nh)
+  {
+    if (!nh.getParam("invincible_check", invincible_check_))
+      ROS_ERROR("Invincible_check no defined (namespace: %s)", nh.getNamespace().c_str());
+  }
+  typedef enum
+  {
+    INJURABLE = 0,
+    IN_SUPPLY_BASE = 1,
+    NORMAL_FRESHLY_RESURRECTED = 2,
+    MONEY_FRESHLY_RESURRECTED = 3,
+  } InvincibleState;
+
+  //  void updateEnemyStatus(int robot_id)
+  // 调用上面的update函数，需要输入敌方id，然后函数中直接更新对应id机器人的无敌状态
+  //  InvincibleState getInvincibleState(int robot_id)
+  // 用这个函数来get对应机器人的无敌状态，然后用这个状态做判断，如果不是INJURABLE，就把shooter设为READY
+
+private:
+  //  updateState()
+  void updateRobotInfo(int track_id, rm_msgs::GameRobotStatus& data)
+  {
+    robot_id = data.robot_id;
+    if (robot_id < 100)
+      track_id = track_id + 100;
+  }
+
+  void updateInvincibleState(int track_id, bool is_red)
+  {
+  }
+
+  int last_hp;
+  float last_revive_time;
+  float last_heal_time;
+  int robot_id;
+  InvincibleState invincible_state = INJURABLE;
+  XmlRpc::XmlRpcValue invincible_check_;
+};
+}  // namespace rm_common
diff --git a/rm_common/include/rm_common/decision/power_limit.h b/rm_common/include/rm_common/decision/power_limit.h
index a50f4aa0..42591b95 100644
--- a/rm_common/include/rm_common/decision/power_limit.h
+++ b/rm_common/include/rm_common/decision/power_limit.h
@@ -39,6 +39,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <string>
 
 #include <ros/ros.h>
 #include <rm_msgs/ChassisCmd.h>
@@ -77,13 +78,8 @@ class PowerLimit
       ROS_ERROR("Gyro power no defined (namespace: %s)", nh.getNamespace().c_str());
     if (!nh.getParam("upstairs_power", upstairs_power_))
       ROS_ERROR("Upstairs power no defined (namespace: %s)", nh.getNamespace().c_str());
-    if (!nh.getParam("max_power_limit", max_power_limit_))
-      ROS_ERROR("max power limit no defined (namespace: %s)", nh.getNamespace().c_str());
-    if (!nh.getParam("power_gain", power_gain_))
-      ROS_ERROR("power gain no defined (namespace: %s)", nh.getNamespace().c_str());
-    if (!nh.getParam("total_burst_time", total_burst_time_))
-      ROS_ERROR("total burst time no defined (namespace: %s)", nh.getNamespace().c_str());
-    default_max_power_limit_ = max_power_limit_;
+    if (!ros::param::get("/rm_manual/robot_type", robot_type_))
+      ROS_WARN("Only standard and hero robot types are supported (namespace: %s)", nh.getNamespace().c_str());
     default_burst_power_ = burst_power_;
   }
   typedef enum
@@ -97,45 +93,60 @@ class PowerLimit
 
   void updateSafetyPower(int safety_power)
   {
-    if (safety_power > 0)
+    if (robot_type_ == "standard")
+      safety_power_ = 40 + robot_id_ * 5;
+    else if (robot_type_ == "hero")
+      safety_power_ = 45 + robot_id_ * 5;
+    else
       safety_power_ = safety_power;
-    ROS_INFO("update safety power: %d", safety_power);
+    ROS_WARN_THROTTLE(2.0, "update safety power: %.0f", safety_power_);
+  }
+
+  void updateBurstPower(const double& burst_power_limit)
+  {
+    burst_power_ = burst_power_limit;
+    ROS_WARN("update burst power: %.0f", burst_power_);
   }
+
   void updateState(uint8_t state)
   {
     expect_state_ = state;
   }
+
   void setGameRobotData(const rm_msgs::GameRobotStatus data)
   {
+    robot_level_ = data.robot_level;
     robot_id_ = data.robot_id;
     chassis_power_limit_ = data.chassis_power_limit;
   }
+
   void setChassisPowerBuffer(const rm_msgs::PowerHeatData data)
   {
     chassis_power_buffer_ = data.chassis_power_buffer;
   }
+
   void setCapacityData(const rm_msgs::PowerManagementSampleAndStatusData data)
   {
-    capacity_is_online_ = ros::Time::now() - data.stamp < ros::Duration(0.3);
+    capacity_is_online_ = ros::Time::now() - data.stamp < ros::Duration(5);
     cap_energy_ = data.capacity_remain_charge;
     cap_state_ = data.state_machine_running_state;
   }
+
   void setRefereeStatus(bool status)
   {
     referee_is_online_ = status;
   }
+
   void setStartBurstTime(const ros::Time start_burst_time)
   {
     start_burst_time_ = start_burst_time;
   }
+
   ros::Time getStartBurstTime() const
   {
     return start_burst_time_;
   }
-  inline void setBurstPowerLimit(const double& burst_power_limit)
-  {
-    burst_power_ = burst_power_limit;
-  }
+
   uint8_t getState()
   {
     return expect_state_;
@@ -145,12 +156,10 @@ class PowerLimit
   {
     if (upstairs)
     {
-      max_power_limit_ = upstairs_power_;
       burst_power_ = upstairs_power_;
     }
     else
     {
-      max_power_limit_ = default_max_power_limit_;
       burst_power_ = default_burst_power_;
     }
   }
@@ -188,7 +197,7 @@ class PowerLimit
     if (robot_id_ == rm_msgs::GameRobotStatus::BLUE_ENGINEER || robot_id_ == rm_msgs::GameRobotStatus::RED_ENGINEER)
       chassis_cmd.power_limit = 400;
     else
-    {  // standard and hero
+    {
       if (referee_is_online_)
       {
         if (capacity_is_online_ && expect_state_ != ALLOFF)
@@ -218,7 +227,10 @@ class PowerLimit
           normal(chassis_cmd);
       }
       else
+      {
+        updateSafetyPower(safety_power_);
         chassis_cmd.power_limit = safety_power_;
+      }
     }
     applyPosturePowerScale(chassis_cmd);
   }
@@ -227,24 +239,19 @@ class PowerLimit
   void charge(rm_msgs::ChassisCmd& chassis_cmd)
   {
     allow_use_cap_ = false;
-    chassis_cmd.power_limit = chassis_power_limit_ * 0.70;
   }
 
   void normal(rm_msgs::ChassisCmd& chassis_cmd)
   {
     allow_use_cap_ = false;
-    if (cap_state_ != ALLOFF && cap_energy_ > disable_normal_cap_threshold_ &&
-        chassis_power_buffer_ > power_buffer_threshold_)
-    {
-      chassis_cmd.power_limit = chassis_power_limit_ + extra_power_;
-    }
-    else
+    if (chassis_power_limit_ == 65535)
     {
-      chassis_cmd.power_limit = chassis_power_limit_;
+      expect_state_ = BURST;  // Unlimit power limit in referee
+      return;
     }
-    if (chassis_cmd.power_limit > max_power_limit_)
+    if (cap_state_ != ALLOFF)
     {
-      chassis_cmd.power_limit = max_power_limit_;
+      chassis_cmd.power_limit = chassis_power_limit_ - 5;
     }
   }
 
@@ -255,16 +262,17 @@ class PowerLimit
 
   void burst(rm_msgs::ChassisCmd& chassis_cmd, bool is_gyro)
   {
+    if (chassis_power_limit_ != 65535 && (chassis_power_limit_ > burst_power_ || chassis_power_limit_ > gyro_power_))
+    {
+      chassis_cmd.power_limit = chassis_power_limit_;
+      return;
+    }
     if (cap_state_ != ALLOFF && cap_energy_ > capacitor_threshold_ && chassis_power_buffer_ > power_buffer_threshold_)
     {
       if (is_gyro)
-      {
         setGyroPower(chassis_cmd);
-      }
       else
-      {
         setBurstPower(chassis_cmd);
-      }
     }
     else
       expect_state_ = NORMAL;
@@ -279,9 +287,10 @@ class PowerLimit
 
   uint8_t expect_state_{}, cap_state_{};
 
+  std::string robot_type_{};
   int chassis_power_buffer_{};
-  int robot_id_{}, chassis_power_limit_{};
-  double max_power_limit_{ 70.0 };
+  int robot_id_{}, robot_level_{};
+  int chassis_power_limit_{};
   float cap_energy_{};
   double safety_power_{};
   double capacitor_threshold_{};
@@ -290,14 +299,12 @@ class PowerLimit
   double enable_gyro_cap_threshold_{}, disable_gyro_cap_threshold_{};
   double disable_normal_cap_threshold_{};
   double extra_power_{}, burst_power_{}, gyro_power_{}, upstairs_power_{};
-  double default_max_power_limit_{}, default_burst_power_{};
-  double power_gain_{};
+  double default_burst_power_{};
 
   bool allow_gyro_cap_{ false }, allow_use_cap_{ false };
   double posture_power_scale_{ 1.0 };
 
   ros::Time start_burst_time_{};
-  int total_burst_time_{};
 
   bool referee_is_online_{ false };
   bool capacity_is_online_{ false };
diff --git a/rm_common/include/rm_common/decision/service_caller.h b/rm_common/include/rm_common/decision/service_caller.h
index 457a2089..76beca7d 100644
--- a/rm_common/include/rm_common/decision/service_caller.h
+++ b/rm_common/include/rm_common/decision/service_caller.h
@@ -46,6 +46,9 @@
 #include <controller_manager_msgs/SwitchController.h>
 #include <control_msgs/QueryCalibrationState.h>
 #include <rm_msgs/StatusChange.h>
+#include <std_srvs/Empty.h>
+#include <std_srvs/SetBool.h>
+#include <std_srvs/Trigger.h>
 
 namespace rm_common
 {
@@ -132,7 +135,35 @@ class ServiceCallerBase
   std::mutex mutex_;
   int fail_count_, fail_limit_;
 };
+class ColorChangeServiceCaller : public ServiceCallerBase<std_srvs::SetBool>
+{
+public:
+  explicit ColorChangeServiceCaller(ros::NodeHandle& nh)
+    : ServiceCallerBase<std_srvs::SetBool>(nh, "/superpower_track_vision/change_color")
+  {
+    service_.request.data = false;
+    callService();
+  }
+  void changeColor()
+  {
+    service_.request.data = !service_.request.data;
+    callService();
+  }
+};
 
+class TrackerResetServiceCaller : public ServiceCallerBase<std_srvs::Trigger>
+{
+public:
+  explicit TrackerResetServiceCaller(ros::NodeHandle& nh)
+    : ServiceCallerBase<std_srvs::Trigger>(nh, "/superpower_track/reset")
+  {
+    callService();
+  }
+  void reset()
+  {
+    callService();
+  }
+};
 class SwitchControllersServiceCaller : public ServiceCallerBase<controller_manager_msgs::SwitchController>
 {
 public:
@@ -185,7 +216,7 @@ class SwitchDetectionCaller : public ServiceCallerBase<rm_msgs::StatusChange>
 {
 public:
   explicit SwitchDetectionCaller(ros::NodeHandle& nh)
-    : ServiceCallerBase<rm_msgs::StatusChange>(nh, "/detection_nodelet/status_switch")
+    : ServiceCallerBase<rm_msgs::StatusChange>(nh, "/Processor/status_change")
   {
     service_.request.target = rm_msgs::StatusChangeRequest::ARMOR;
     service_.request.exposure = rm_msgs::StatusChangeRequest::EXPOSURE_LEVEL_0;
diff --git a/rm_common/include/rm_common/math_utilities.h b/rm_common/include/rm_common/math_utilities.h
index 841a5674..08aac317 100644
--- a/rm_common/include/rm_common/math_utilities.h
+++ b/rm_common/include/rm_common/math_utilities.h
@@ -76,3 +76,13 @@ T alpha(T cutoff, double freq)
   T te = 1.0 / freq;
   return 1.0 / (1.0 + tau / te);
 }
+
+template <typename T>
+T limit(T val, T min, T max)
+{
+  if (val > max)
+    return max;
+  if (val < min)
+    return min;
+  return val;
+}
diff --git a/rm_common/include/rm_common/rls.h b/rm_common/include/rm_common/rls.h
new file mode 100644
index 00000000..cf0f2030
--- /dev/null
+++ b/rm_common/include/rm_common/rls.h
@@ -0,0 +1,165 @@
+//
+// Created by xiezd on 3/25/26.
+//
+
+#pragma once
+
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+
+#include <Eigen/Dense>
+#include "eigen_types.h"
+
+#define RLS_ASSERT(condition, message)                                                                                 \
+  if (!(condition))                                                                                                    \
+  throw std::invalid_argument(message)
+
+template <typename T>
+class Rls
+{
+public:
+  Rls(int xSize, int ySize, T lambda, T pInit) : xSize_(xSize), ySize_(ySize), lambda_(lambda)
+  {
+    RLS_ASSERT(xSize_ > 0, "rls: xSize should be positive");
+    RLS_ASSERT(ySize_ > 0, "rls: ySize should be positive");
+    RLS_ASSERT(std::abs(lambda_) > std::numeric_limits<T>::epsilon(), "rls: lambda should be non-zero");
+
+    x_.resize(xSize_, 1);
+    x_.setZero();
+    xt_.resize(1, xSize_);
+    xt_.setZero();
+
+    w_.resize(xSize_, ySize_);
+    w_.setZero();
+    output_.resize(xSize_, ySize_);
+    output_.setZero();
+    k_.resize(xSize_, 1);
+    k_.setZero();
+    kNumerator_.resize(xSize_, 1);
+    kNumerator_.setZero();
+
+    p_.resize(xSize_, xSize_);
+    p_.setIdentity();
+    p_ *= pInit;
+
+    y_.resize(ySize_, 1);
+    y_.setZero();
+    u_.resize(ySize_, 1);
+    u_.setZero();
+    e_.resize(ySize_, 1);
+    e_.setZero();
+  }
+
+  template <typename TX>
+  bool setX(const Eigen::MatrixBase<TX>& x)
+  {
+    static_assert(TX::ColsAtCompileTime == 1 || TX::ColsAtCompileTime == Eigen::Dynamic,
+                  "rls: X should be a column vector");
+    RLS_ASSERT(x.rows() == xSize_ && x.cols() == 1, "rls: X size mismatch");
+    x_ = x;
+    return true;
+  }
+
+  template <typename TY>
+  bool setY(const Eigen::MatrixBase<TY>& y)
+  {
+    static_assert(TY::ColsAtCompileTime == 1 || TY::ColsAtCompileTime == Eigen::Dynamic,
+                  "rls: Y should be a column vector");
+    RLS_ASSERT(y.rows() == ySize_ && y.cols() == 1, "rls: Y size mismatch");
+    y_ = y;
+    return true;
+  }
+
+  bool setY(T y)
+  {
+    RLS_ASSERT(ySize_ == 1, "rls: setY(scalar) requires ySize==1");
+    y_(0, 0) = y;
+    return true;
+  }
+
+  template <typename TW>
+  bool setW(const Eigen::MatrixBase<TW>& w)
+  {
+    RLS_ASSERT(w.rows() == xSize_ && w.cols() == ySize_, "rls: W size mismatch");
+    w_ = w;
+    return true;
+  }
+
+  template <typename TU>
+  bool setU(const Eigen::MatrixBase<TU>& u)
+  {
+    static_assert(TU::ColsAtCompileTime == 1 || TU::ColsAtCompileTime == Eigen::Dynamic,
+                  "rls: U should be a column vector");
+    RLS_ASSERT(u.rows() == ySize_ && u.cols() == 1, "rls: U size mismatch");
+    u_ = u;
+    return true;
+  }
+
+  bool setU(T u)
+  {
+    RLS_ASSERT(ySize_ == 1, "rls: setU(scalar) requires ySize==1");
+    u_(0, 0) = u;
+    return true;
+  }
+
+  bool update()
+  {
+    xt_ = x_.transpose();
+    // Compute predicted output using current weights: u_pred = x^T * w
+    // Compute prediction error: e = y - u_pred
+    e_ = y_ - u_;
+
+    kNumerator_ = p_ * x_;
+    T denominator = lambda_ + (xt_ * p_ * x_)(0, 0);
+    RLS_ASSERT(std::abs(denominator) > std::numeric_limits<T>::epsilon(),
+               "rls: denominator too small, numerical instability");
+
+    // Compute gain vector: k = P*x / (lambda + x^T*P*x)
+    k_ = kNumerator_ / denominator;
+    // Update parameters: w = w + k * e^T
+    output_ = w_ + k_ * e_.transpose();
+    w_ = output_;
+
+    // Update covariance matrix: P = (P - k*x^T*P) / lambda
+    p_ = (p_ - k_ * xt_ * p_) / lambda_;
+    return true;
+  }
+
+  DMat<T> getW() const
+  {
+    return w_;
+  }
+
+  DMat<T> getP() const
+  {
+    return p_;
+  }
+
+  DVec<T> getError() const
+  {
+    return e_;
+  }
+
+  DVec<T> getEstimate() const
+  {
+    return u_;
+  }
+
+private:
+  int xSize_;
+  int ySize_;
+  T lambda_;
+
+  DVec<T> x_;
+  DMat<T> xt_;
+  DMat<T> w_;
+  DMat<T> output_;
+  DVec<T> k_;
+  DVec<T> kNumerator_;
+  DMat<T> p_;
+
+  DVec<T> y_;
+  DVec<T> u_;
+  DVec<T> e_;
+};
diff --git a/rm_common/include/rm_common/traj_gen.h b/rm_common/include/rm_common/traj_gen.h
index 6d00c022..0b54b2f1 100644
--- a/rm_common/include/rm_common/traj_gen.h
+++ b/rm_common/include/rm_common/traj_gen.h
@@ -199,3 +199,41 @@ class MinTimeTraj
     }
   }
 };
+
+template <typename T>
+class NonlinearTrackingDifferentiator
+{
+public:
+  NonlinearTrackingDifferentiator(T r, T h) : r_(r), h_(h)
+  {
+  }
+  void update(T v, T v_dot)
+  {
+    if ((v > 3. && x1_ < -3.) || (v < -3 && x1_ > 3))
+    {
+      x1_ = v;
+      x2_ = 0;
+    }
+    else
+    {
+      T y = x1_ - v + h_ * x2_;
+      T a0 = sqrt(h_ * h_ * r_ * r_ + 8 * r_ * fabs(y));
+      T a = x2_ + 0.5 * (a0 - h_ * r_) * (y > 0 ? 1 : -1);
+      T u = fabs(a) > h_ * r_ ? -r_ * (a > 0 ? 1 : -1) : -r_ * a / (h_ * r_);
+      x1_ = x1_ + h_ * (x2_ + v_dot);
+      x2_ = x2_ + h_ * u;
+    }
+  }
+  T getX1() const
+  {
+    return x1_;
+  }
+  T getX2() const
+  {
+    return x2_;
+  }
+
+private:
+  T r_{}, h_{};
+  T x1_{}, x2_{};
+};
diff --git a/rm_msgs/CMakeLists.txt b/rm_msgs/CMakeLists.txt
index 51ddc3ff..368b6646 100755
--- a/rm_msgs/CMakeLists.txt
+++ b/rm_msgs/CMakeLists.txt
@@ -12,6 +12,8 @@ find_package(catkin REQUIRED COMPONENTS
 add_message_files(
         FILES
         ActuatorState.msg
+        AimCompare.msg
+        AssemblyErrorData.msg
         BalanceState.msg
         BulletSolverData.msg
         BusState.msg
@@ -24,6 +26,7 @@ add_message_files(
         ShootCmd.msg
         ShootState.msg
         ShootBeforehandCmd.msg
+        GimbalAimCmd.msg
         GimbalCmd.msg
         GimbalDesError.msg
         GimbalPosState.msg
@@ -41,6 +44,7 @@ add_message_files(
         GpioData.msg
         TofRadarData.msg
         MultiDofCmd.msg
+        MPCGimbalAimCmd.msg
         TagMsg.msg
         TagMsgArray.msg
         SentryDeviate.msg
@@ -128,6 +132,7 @@ add_message_files(
 add_action_files(
         FILES
         Engineer.action
+        QueryGlobalLocalization.action
 )
 # Generate added messages and services with any dependencies listed here
 generate_messages(
diff --git a/rm_msgs/action/QueryGlobalLocalization.action b/rm_msgs/action/QueryGlobalLocalization.action
new file mode 100644
index 00000000..952fe423
--- /dev/null
+++ b/rm_msgs/action/QueryGlobalLocalization.action
@@ -0,0 +1,9 @@
+# Goal (Empty)
+---
+# Result
+bool success
+float64 coarse_align_inlier_fraction
+float64 fine_align_inlier_fraction
+---
+# Feedback
+float64 progress
diff --git a/rm_msgs/msg/AimCompare.msg b/rm_msgs/msg/AimCompare.msg
new file mode 100644
index 00000000..5e09157a
--- /dev/null
+++ b/rm_msgs/msg/AimCompare.msg
@@ -0,0 +1,24 @@
+std_msgs/Header header
+uint8 target_id
+bool bullet_valid
+bool external_valid
+float64 bullet_yaw
+float64 bullet_pitch
+float64 bullet_yaw_rate
+float64 bullet_pitch_rate
+float64 bullet_fly_time
+float64 bullet_error
+geometry_msgs/Point bullet_selected_armor_pos
+geometry_msgs/Vector3 bullet_selected_armor_vel
+float64 external_yaw
+float64 external_pitch
+float64 external_yaw_rate
+float64 external_pitch_rate
+float64 external_fly_time
+float64 external_error
+geometry_msgs/Point external_selected_armor_pos
+geometry_msgs/Vector3 external_selected_armor_vel
+float64 delta_yaw
+float64 delta_pitch
+float64 delta_fly_time
+float64 delta_error
diff --git a/rm_msgs/msg/AssemblyErrorData.msg b/rm_msgs/msg/AssemblyErrorData.msg
new file mode 100644
index 00000000..16402b12
--- /dev/null
+++ b/rm_msgs/msg/AssemblyErrorData.msg
@@ -0,0 +1,4 @@
+std_msgs/Header header
+float64 roll_error
+float64 pitch_error
+float64 yaw_error
diff --git a/rm_msgs/msg/BulletSolverData.msg b/rm_msgs/msg/BulletSolverData.msg
index a4defc57..9f19ac47 100644
--- a/rm_msgs/msg/BulletSolverData.msg
+++ b/rm_msgs/msg/BulletSolverData.msg
@@ -1,14 +1,10 @@
-
 std_msgs/Header header
-float64 yaw_subtract_
-float64 output_yaw_central
-float64 test_number
-float64 after_fly_yaw_subtract_
-float64 switch_armor_angle
-float64 switche_time_yaw_
-float64 center_this_armor_
-float64 center_next_armor_
-float64 center_diagonal_armor_
-float64 center_triple_next_armor_
+int16[150] selected_armor_
+int16[150] count_number_
+float64 start_vel
+float64 switchtime
+float64 traject_output_yaw_
 float64 traject_acc_
-int16 selected_armor_
+float64 traject_vel_
+int16 using_traject_
+float64[100] test_number
diff --git a/rm_msgs/msg/GimbalAimCmd.msg b/rm_msgs/msg/GimbalAimCmd.msg
new file mode 100644
index 00000000..0fa1b6c8
--- /dev/null
+++ b/rm_msgs/msg/GimbalAimCmd.msg
@@ -0,0 +1,12 @@
+std_msgs/Header header
+bool valid
+uint8 target_id
+uint8 shoot_cmd
+float64 yaw
+float64 pitch
+float64 yaw_rate
+float64 pitch_rate
+float64 fly_time
+float64 error
+geometry_msgs/Point selected_armor_pos
+geometry_msgs/Vector3 selected_armor_vel
diff --git a/rm_msgs/msg/LocalHeatData.msg b/rm_msgs/msg/LocalHeatData.msg
index 432322d5..18f73825 100644
--- a/rm_msgs/msg/LocalHeatData.msg
+++ b/rm_msgs/msg/LocalHeatData.msg
@@ -1,2 +1,3 @@
 int64 once_shoot_num
 float64 local_shooter_cooling_heat
+float64 desire_shoot_frequency
diff --git a/rm_msgs/msg/MPCGimbalAimCmd.msg b/rm_msgs/msg/MPCGimbalAimCmd.msg
new file mode 100644
index 00000000..547bce41
--- /dev/null
+++ b/rm_msgs/msg/MPCGimbalAimCmd.msg
@@ -0,0 +1,14 @@
+std_msgs/Header header
+bool valid
+uint8 target_id
+uint8 shoot_cmd
+float64 yaw
+float64 pitch
+float64 yaw_rate
+float64 pitch_rate
+float64 yaw_acc
+float64 pitch_acc
+float64 target_yaw
+float64 target_pitch
+float64 error
+geometry_msgs/Point selected_armor_pos
diff --git a/rm_msgs/msg/detection/TrackData.msg b/rm_msgs/msg/detection/TrackData.msg
index 276929d6..1cc15d3e 100644
--- a/rm_msgs/msg/detection/TrackData.msg
+++ b/rm_msgs/msg/detection/TrackData.msg
@@ -1,5 +1,6 @@
 std_msgs/Header header
 uint8 id
+uint8 outpost_id
 bool tracking
 uint8 armors_num
 geometry_msgs/Point position
@@ -10,4 +11,6 @@ float64 v_yaw
 float64 radius_1
 float64 radius_2
 float64 dz
+float64 za
+float64 next_armor_z_diff
 float64 accel
diff --git a/rm_msgs/msg/referee/ManualToReferee.msg b/rm_msgs/msg/referee/ManualToReferee.msg
index a51c9af6..9e1d83bc 100644
--- a/rm_msgs/msg/referee/ManualToReferee.msg
+++ b/rm_msgs/msg/referee/ManualToReferee.msg
@@ -3,7 +3,7 @@ time start_burst_time
 
 #standard
 uint8 shoot_frequency
-bool cover_state
+bool zip_state
 
 #hero
 bool gimbal_eject
diff --git a/rm_msgs/msg/referee/PowerManagementSampleAndStatusData.msg b/rm_msgs/msg/referee/PowerManagementSampleAndStatusData.msg
index 9946e9aa..ff9b2baa 100644
--- a/rm_msgs/msg/referee/PowerManagementSampleAndStatusData.msg
+++ b/rm_msgs/msg/referee/PowerManagementSampleAndStatusData.msg
@@ -1,9 +1,10 @@
 float32 chassis_power
-float32 chassis_expect_power
-float32 capacity_recent_charge_power
+float32 chassis_error_code
+float32 capacity_receive_message
 float32 capacity_remain_charge
 uint8 capacity_discharge_power
 uint8 state_machine_running_state
+
 uint8 power_management_protection_info
 uint8 power_management_topology
 
diff --git a/rm_referee/include/rm_referee/common/data.h b/rm_referee/include/rm_referee/common/data.h
index 83e162e6..3c6eb716 100644
--- a/rm_referee/include/rm_referee/common/data.h
+++ b/rm_referee/include/rm_referee/common/data.h
@@ -37,6 +37,8 @@
 
 #pragma once
 
+#include <array>
+#include <vector>
 #include <ros/ros.h>
 #include <unistd.h>
 #include <serial/serial.h>
diff --git a/rm_referee/include/rm_referee/referee.h b/rm_referee/include/rm_referee/referee.h
index 1b3af4d1..af62db2e 100644
--- a/rm_referee/include/rm_referee/referee.h
+++ b/rm_referee/include/rm_referee/referee.h
@@ -36,6 +36,7 @@
 //
 #pragma once
 
+#include <array>
 #include <cstdint>
 #include <vector>
 #include <ros/ros.h>
diff --git a/rm_referee/include/rm_referee/referee_base.h b/rm_referee/include/rm_referee/referee_base.h
index 51625a47..dfdaa828 100644
--- a/rm_referee/include/rm_referee/referee_base.h
+++ b/rm_referee/include/rm_referee/referee_base.h
@@ -47,7 +47,6 @@ class RefereeBase
   virtual void jointStateCallback(const sensor_msgs::JointState::ConstPtr& joint_state);
   virtual void actuatorStateCallback(const rm_msgs::ActuatorState::ConstPtr& data);
   virtual void dbusDataCallback(const rm_msgs::DbusData::ConstPtr& data);
-  virtual void heroLegDataCallback(const rm_msgs::ChassisActiveSusCmd::ConstPtr& data);
   virtual void chassisCmdDataCallback(const rm_msgs::ChassisCmd::ConstPtr& data);
   virtual void vel2DCmdDataCallback(const geometry_msgs::Twist::ConstPtr& data);
   virtual void shootStateCallback(const rm_msgs::ShootState::ConstPtr& data);
@@ -58,7 +57,7 @@ class RefereeBase
   virtual void radarDataCallBack(const std_msgs::Int8MultiArrayConstPtr& data);
   virtual void cameraNameCallBack(const std_msgs::StringConstPtr& data);
   virtual void trackCallBack(const rm_msgs::TrackDataConstPtr& data);
-  virtual void deployDistanceCallBack(const geometry_msgs::PointConstPtr& data);
+  virtual void enemycolorCallBack(const std_msgs::BoolConstPtr& data);
   virtual void balanceStateCallback(const rm_msgs::BalanceStateConstPtr& data);
   virtual void leggedChassisStatusCallback(const rm_msgs::LeggedChassisStatusConstPtr& data);
   virtual void radarReceiveCallback(const rm_msgs::ClientMapReceiveData::ConstPtr& data);
@@ -73,6 +72,8 @@ class RefereeBase
   virtual void customizeDisplayCmdCallBack(const std_msgs::UInt32ConstPtr& data);
   virtual void visualizeStateDataCallBack(const rm_msgs::VisualizeStateDataConstPtr& data);
   virtual void relocalizeProgressCallback(const std_msgs::Int32ConstPtr& data);
+  virtual void heroLegDataCallback(const rm_msgs::ChassisActiveSusCmd::ConstPtr& data);
+  virtual void deployDistanceCallBack(const geometry_msgs::PointConstPtr& data);
 
   // send  ui
   void sendSerialDataCallback();
@@ -82,7 +83,6 @@ class RefereeBase
   ros::Subscriber actuator_state_sub_;
   ros::Subscriber dbus_sub_;
   ros::Subscriber chassis_cmd_sub_;
-  ros::Subscriber hero_leg_data_sub_;
   ros::Subscriber vel2D_cmd_sub_;
   ros::Subscriber shoot_state_sub_;
   ros::Subscriber gimbal_cmd_sub_;
@@ -94,7 +94,6 @@ class RefereeBase
   ros::Subscriber manual_data_sub_;
   ros::Subscriber camera_name_sub_;
   ros::Subscriber track_sub_;
-  ros::Subscriber deploy_distance_sub_;
   ros::Subscriber balance_state_sub_;
   ros::Subscriber legged_chassis_status_sub_;
   ros::Subscriber radar_receive_sub_;
@@ -108,6 +107,9 @@ class RefereeBase
   ros::Subscriber shoot_cmd_sub_;
   ros::Subscriber customize_display_cmd_sub_;
   ros::Subscriber visualize_state_data_sub_;
+  ros::Subscriber hero_leg_data_sub_;
+  ros::Subscriber deploy_distance_sub_;
+  ros::Subscriber enemy_color_sub_;
   ros::Subscriber relocalize_progress_sub_;
 
   ChassisTriggerChangeUi* chassis_trigger_change_ui_{};
@@ -117,11 +119,12 @@ class RefereeBase
   TargetViewAngleTriggerChangeUi* target_view_angle_trigger_change_ui_{};
   CameraTriggerChangeUi* camera_trigger_change_ui_{};
   FrictionSpeedTriggerChangeUi* friction_speed_trigger_change_ui_{};
+  GyroTriggerChangeUi* gyro_trigger_change_ui_{};
+  ZipTriggerChangeUi* zip_trigger_change_ui_{};
   HeroLegTriggerChangeUi* hero_leg_trigger_change_ui_{};
 
   BulletTimeChangeUi* bullet_time_change_ui_{};
   CapacitorTimeChangeUi* capacitor_time_change_ui_{};
-  RelocalizeProgressTimeChangeUi* relocalize_progress_time_change_ui_{};
   EffortTimeChangeUi* effort_time_change_ui_{};
   ProgressTimeChangeUi* progress_time_change_ui_{};
   DartStatusTimeChangeUi* dart_status_time_change_ui_{};
@@ -134,10 +137,12 @@ class RefereeBase
   JointPositionTimeChangeUi *engineer_joint1_time_change_ui{}, *engineer_joint2_time_change_ui{},
       *engineer_joint3_time_change_ui{};
   TargetDistanceTimeChangeUi* target_distance_time_change_ui_{};
-  DeployDistanceTimeChangeUi* deploy_distance_time_change_ui_{};
-  HeroLegTimeChangeUi* hero_leg_time_change_ui_{};
   FriendBulletsTimeChangeGroupUi* friend_bullets_time_change_group_ui_{};
   TargetHpTimeChangeUi* target_hp_time_change_ui_{};
+  RelocalizeProgressTimeChangeUi* relocalize_progress_time_change_ui_{};
+  DeployDistanceTimeChangeUi* deploy_distance_time_change_ui_{};
+  HeroLegTimeChangeUi* hero_leg_time_change_ui_{};
+  EnemyColorTimeChangeUi* enemy_color_time_change_ui_{};
 
   DroneTowardsTimeChangeGroupUi* drone_towards_time_change_group_ui_{};
   StringTriggerChangeUi *servo_mode_trigger_change_ui_{}, *stone_num_trigger_change_ui_{},
@@ -146,7 +151,6 @@ class RefereeBase
 
   FixedUi* fixed_ui_{};
 
-  CoverFlashUi* cover_flash_ui_{};
   SpinFlashUi* spin_flash_ui_{};
   DeployFlashUi* deploy_flash_ui_{};
   HeroHitFlashUi* hero_hit_flash_ui_{};
diff --git a/rm_referee/include/rm_referee/ui/flash_ui.h b/rm_referee/include/rm_referee/ui/flash_ui.h
index 5c1eb5be..81ec61ce 100644
--- a/rm_referee/include/rm_referee/ui/flash_ui.h
+++ b/rm_referee/include/rm_referee/ui/flash_ui.h
@@ -66,20 +66,6 @@ class CustomizeDisplayFlashUi : public FlashGroupUi
   uint32_t symbol_;
 };
 
-class CoverFlashUi : public FlashUi
-{
-public:
-  explicit CoverFlashUi(XmlRpc::XmlRpcValue& rpc_value, Base& base, std::deque<Graph>* graph_queue,
-                        std::deque<Graph>* character_queue)
-    : FlashUi(rpc_value, base, "cover", graph_queue, character_queue){};
-  void updateManualCmdData(const rm_msgs::ManualToReferee::ConstPtr data, const ros::Time& last_get_data_time) override;
-
-private:
-  void display(const ros::Time& time) override;
-
-  uint8_t cover_state_;
-};
-
 class SpinFlashUi : public FlashUi
 {
 public:
diff --git a/rm_referee/include/rm_referee/ui/graph.h b/rm_referee/include/rm_referee/ui/graph.h
index 23a9979e..27485ad8 100644
--- a/rm_referee/include/rm_referee/ui/graph.h
+++ b/rm_referee/include/rm_referee/ui/graph.h
@@ -53,6 +53,11 @@ class Graph
   {
     config_.radius = radius;
   }
+  void setWidth(int width)
+  {
+    if (width > 0)
+      config_.width = width;
+  }
   void setIntNum(int num)
   {
     int a = num & 1023;
diff --git a/rm_referee/include/rm_referee/ui/time_change_ui.h b/rm_referee/include/rm_referee/ui/time_change_ui.h
index 14d1c025..dea4b466 100644
--- a/rm_referee/include/rm_referee/ui/time_change_ui.h
+++ b/rm_referee/include/rm_referee/ui/time_change_ui.h
@@ -3,7 +3,7 @@
 //
 
 #pragma once
-
+#include <std_msgs/Bool.h>
 #include "rm_referee/ui/ui_base.h"
 
 #include <rm_msgs/LeggedChassisStatus.h>
@@ -163,6 +163,8 @@ class LaneLineTimeChangeGroupUi : public TimeChangeGroupUi
       robot_height_ = data["height"];
       camera_range_ = data["camera_range"];
       surface_coefficient_ = data["surface_coefficient"];
+      if (data.hasMember("x_offset"))
+        x_offset_ = data["x_offset"];
     }
     else
       ROS_WARN("LaneLineTimeChangeGroupUi config 's member 'data' not defined.");
@@ -187,6 +189,7 @@ class LaneLineTimeChangeGroupUi : public TimeChangeGroupUi
 protected:
   std::string reference_frame_;
   double robot_radius_, robot_height_, camera_range_, surface_coefficient_ = 0.5;
+  double x_offset_ = 0.0;
   double pitch_angle_ = 0., screen_x_ = 1920, screen_y_ = 1080;
   double end_point_a_angle_, end_point_b_angle_;
 
@@ -335,7 +338,18 @@ class TargetDistanceTimeChangeUi : public TimeChangeUi
   void updateConfig() override;
   double target_distance_;
 };
+class EnemyColorTimeChangeUi : public TimeChangeUi
+{
+public:
+  explicit EnemyColorTimeChangeUi(XmlRpc::XmlRpcValue& rpc_value, Base& base, std::deque<Graph>* graph_queue,
+                                  std::deque<Graph>* character_queue)
+    : TimeChangeUi(rpc_value, base, "enemy_color", graph_queue, character_queue){};
+  void updateEnemyColorData(const std_msgs::Bool::ConstPtr& data);
 
+private:
+  void updateConfig() override;
+  int enemy_color_{};
+};
 class DeployDistanceTimeChangeUi : public TimeChangeUi
 {
 public:
diff --git a/rm_referee/include/rm_referee/ui/trigger_change_ui.h b/rm_referee/include/rm_referee/ui/trigger_change_ui.h
index 4c7d3342..dcb7037e 100644
--- a/rm_referee/include/rm_referee/ui/trigger_change_ui.h
+++ b/rm_referee/include/rm_referee/ui/trigger_change_ui.h
@@ -3,6 +3,9 @@
 //
 #pragma once
 
+#include <algorithm>
+#include <cmath>
+
 #include "rm_referee/ui/ui_base.h"
 #include <rm_common/decision/power_limit.h>
 #include "std_msgs/String.h"
@@ -78,6 +81,50 @@ class ChassisTriggerChangeUi : public TriggerChangeUi
   double mode_change_threshold_;
 };
 
+class GyroTriggerChangeUi : public TriggerChangeUi
+{
+public:
+  explicit GyroTriggerChangeUi(XmlRpc::XmlRpcValue& rpc_value, Base& base, std::deque<Graph>* graph_queue,
+                               std::deque<Graph>* character_queue)
+    : TriggerChangeUi(rpc_value, base, "gyro", graph_queue, character_queue)
+  {
+    outline_width_ = graph_->getConfig().width;
+    const auto config = graph_->getConfig();
+    const int rect_w = std::abs(config.end_x - config.start_x);
+    const int rect_h = std::abs(config.end_y - config.start_y);
+    fill_width_ = std::max(outline_width_ + 1, std::min(rect_w, rect_h) / 1);
+  }
+  void updateChassisCmdData(const rm_msgs::ChassisCmd::ConstPtr& data);
+
+private:
+  void update() override;
+  uint8_t chassis_mode_{};
+  int outline_width_{};
+  int fill_width_{};
+};
+
+class ZipTriggerChangeUi : public TriggerChangeUi
+{
+public:
+  explicit ZipTriggerChangeUi(XmlRpc::XmlRpcValue& rpc_value, Base& base, std::deque<Graph>* graph_queue,
+                              std::deque<Graph>* character_queue)
+    : TriggerChangeUi(rpc_value, base, "zip", graph_queue, character_queue)
+  {
+    outline_width_ = graph_->getConfig().width;
+    const auto config = graph_->getConfig();
+    const int rect_w = std::abs(config.end_x - config.start_x);
+    const int rect_h = std::abs(config.end_y - config.start_y);
+    fill_width_ = std::max(outline_width_ + 1, std::min(rect_w, rect_h) / 1);
+  }
+  void updateManualCmdData(const rm_msgs::ManualToReferee::ConstPtr data) override;
+
+private:
+  void update() override;
+  uint8_t zip_mode_{};
+  int outline_width_{};
+  int fill_width_{};
+};
+
 class HeroLegTriggerChangeUi : public TriggerChangeUi
 {
 public:
diff --git a/rm_referee/src/referee.cpp b/rm_referee/src/referee.cpp
index 1e47f18d..dcbcb5ed 100644
--- a/rm_referee/src/referee.cpp
+++ b/rm_referee/src/referee.cpp
@@ -725,8 +725,8 @@ int Referee::unpack(uint8_t* rx_data)
           uint8_t data[sizeof(rm_referee::PowerManagementSampleAndStatusData)];
           memcpy(&data, rx_data + 7, sizeof(rm_referee::PowerManagementSampleAndStatusData));
           sample_and_status_pub_data.chassis_power = (static_cast<uint16_t>((data[0] << 8) | data[1]) / 100.);
-          sample_and_status_pub_data.chassis_expect_power = (static_cast<uint16_t>((data[2] << 8) | data[3]) / 100.);
-          sample_and_status_pub_data.capacity_recent_charge_power =
+          sample_and_status_pub_data.chassis_error_code = (static_cast<uint16_t>((data[2] << 8) | data[3]) / 100.);
+          sample_and_status_pub_data.capacity_receive_message =
               (static_cast<uint16_t>((data[4] << 8) | data[5]) / 100.);
           sample_and_status_pub_data.capacity_remain_charge =
               (static_cast<uint16_t>((data[6] << 8) | data[7]) / 10000.);
diff --git a/rm_referee/src/referee_base.cpp b/rm_referee/src/referee_base.cpp
index 97f3987c..b6513a90 100644
--- a/rm_referee/src/referee_base.cpp
+++ b/rm_referee/src/referee_base.cpp
@@ -38,6 +38,8 @@ RefereeBase::RefereeBase(ros::NodeHandle& nh, Base& base) : base_(base), nh_(nh)
   RefereeBase::legged_chassis_status_sub_ = nh.subscribe<rm_msgs::LeggedChassisStatus>(
       legged_chassis_status_topic, 10, &RefereeBase::leggedChassisStatusCallback, this);
   RefereeBase::track_sub_ = nh.subscribe<rm_msgs::TrackData>("/track", 10, &RefereeBase::trackCallBack, this);
+  RefereeBase::enemy_color_sub_ =
+      nh.subscribe<std_msgs::Bool>("/sp_vision/enemy_color", 10, &RefereeBase::enemycolorCallBack, this);
   RefereeBase::deploy_distance_sub_ =
       nh.subscribe<geometry_msgs::Point>("/base2target", 10, &RefereeBase::deployDistanceCallBack, this);
   RefereeBase::map_sentry_sub_ =
@@ -95,6 +97,10 @@ RefereeBase::RefereeBase(ros::NodeHandle& nh, Base& base) : base_(base), nh_(nh)
       if (rpc_value[i]["name"] == "friction_speed")
         friction_speed_trigger_change_ui_ =
             new FrictionSpeedTriggerChangeUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
+      if (rpc_value[i]["name"] == "gyro")
+        gyro_trigger_change_ui_ = new GyroTriggerChangeUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
+      if (rpc_value[i]["name"] == "zip")
+        zip_trigger_change_ui_ = new ZipTriggerChangeUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
       if (rpc_value[i]["name"] == "gripper")
         gripper_state_trigger_change_ui_ =
             new StringTriggerChangeUi(rpc_value[i], base_, "gripper", &graph_queue_, &character_queue_);
@@ -165,6 +171,8 @@ RefereeBase::RefereeBase(ros::NodeHandle& nh, Base& base) : base_(base), nh_(nh)
       if (rpc_value[i]["name"] == "drone_towards")
         drone_towards_time_change_group_ui_ =
             new DroneTowardsTimeChangeGroupUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
+      if (rpc_value[i]["name"] == "enemy_color")
+        enemy_color_time_change_ui_ = new EnemyColorTimeChangeUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
       if (rpc_value[i]["name"] == "friend_bullets")
         friend_bullets_time_change_group_ui_ =
             new FriendBulletsTimeChangeGroupUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
@@ -178,8 +186,8 @@ RefereeBase::RefereeBase(ros::NodeHandle& nh, Base& base) : base_(base), nh_(nh)
     ui_nh.getParam("flash", rpc_value);
     for (int i = 0; i < rpc_value.size(); i++)
     {
-      if (rpc_value[i]["name"] == "cover")
-        cover_flash_ui_ = new CoverFlashUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
+      // if (rpc_value[i]["name"] == "cover")
+      //   cover_flash_ui_ = new CoverFlashUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
       if (rpc_value[i]["name"] == "spin")
         spin_flash_ui_ = new SpinFlashUi(rpc_value[i], base_, &graph_queue_, &character_queue_);
       if (rpc_value[i]["name"] == "capacity_run_out")
@@ -291,6 +299,10 @@ void RefereeBase::addUi()
     servo_mode_trigger_change_ui_->addForQueue();
   if (friction_speed_trigger_change_ui_)
     friction_speed_trigger_change_ui_->addForQueue();
+  if (gyro_trigger_change_ui_)
+    gyro_trigger_change_ui_->addForQueue();
+  if (zip_trigger_change_ui_)
+    zip_trigger_change_ui_->addForQueue();
   if (bullet_time_change_ui_)
   {
     bullet_time_change_ui_->reset();
@@ -298,6 +310,8 @@ void RefereeBase::addUi()
   }
   if (target_distance_time_change_ui_)
     target_distance_time_change_ui_->addForQueue();
+  if (enemy_color_time_change_ui_)
+    enemy_color_time_change_ui_->addForQueue();
   if (deploy_distance_time_change_ui_)
     deploy_distance_time_change_ui_->addForQueue();
   if (hero_leg_time_change_ui_)
@@ -497,10 +511,17 @@ void RefereeBase::heroLegDataCallback(const rm_msgs::ChassisActiveSusCmd::ConstP
   if (hero_leg_time_change_ui_ && !is_adding_)
     hero_leg_time_change_ui_->updateFeedforwardCountdown(data->feedforward_countdown);
 }
+void RefereeBase::enemycolorCallBack(const std_msgs::BoolConstPtr& data)
+{
+  if (enemy_color_time_change_ui_ && !is_adding_)
+    enemy_color_time_change_ui_->updateEnemyColorData(data);
+}
 void RefereeBase::chassisCmdDataCallback(const rm_msgs::ChassisCmd::ConstPtr& data)
 {
   if (chassis_trigger_change_ui_)
     chassis_trigger_change_ui_->updateChassisCmdData(data);
+  if (gyro_trigger_change_ui_ && !is_adding_)
+    gyro_trigger_change_ui_->updateChassisCmdData(data);
   if (spin_flash_ui_ && !is_adding_)
     spin_flash_ui_->updateChassisCmdData(data, ros::Time::now());
   if (deploy_flash_ui_ && !is_adding_)
@@ -549,10 +570,8 @@ void RefereeBase::manualDataCallBack(const rm_msgs::ManualToReferee::ConstPtr& d
     gimbal_trigger_change_ui_->updateManualCmdData(data);
   if (target_trigger_change_ui_ && !is_adding_)
     target_trigger_change_ui_->updateManualCmdData(data);
-  if (cover_flash_ui_ && !is_adding_)
-    cover_flash_ui_->updateManualCmdData(data, ros::Time::now());
-  // if (burst_flash_ui_ && !is_adding_)
-  //   burst_flash_ui_->updateBurstTimeData(data);
+  if (zip_trigger_change_ui_ && !is_adding_)
+    zip_trigger_change_ui_->updateManualCmdData(data);
 }
 void RefereeBase::radarDataCallBack(const std_msgs::Int8MultiArrayConstPtr& data)
 {
diff --git a/rm_referee/src/ui/flash_ui.cpp b/rm_referee/src/ui/flash_ui.cpp
index 3620aae9..c6c8e86d 100644
--- a/rm_referee/src/ui/flash_ui.cpp
+++ b/rm_referee/src/ui/flash_ui.cpp
@@ -139,20 +139,6 @@ void CustomizeDisplayFlashUi::display(const ros::Time& time)
   }
 }
 
-void CoverFlashUi::display(const ros::Time& time)
-{
-  if (!cover_state_)
-    graph_->setOperation(rm_referee::GraphOperation::DELETE);
-  FlashUi::updateFlashUiForQueue(time, cover_state_, true);
-}
-
-void CoverFlashUi::updateManualCmdData(const rm_msgs::ManualToReferee::ConstPtr data,
-                                       const ros::Time& last_get_data_time)
-{
-  cover_state_ = data->cover_state;
-  display(last_get_data_time);
-}
-
 void SpinFlashUi::display(const ros::Time& time)
 {
   if (chassis_mode_ != rm_msgs::ChassisCmd::RAW)
diff --git a/rm_referee/src/ui/time_change_ui.cpp b/rm_referee/src/ui/time_change_ui.cpp
index 1df0f8df..f5ea97d4 100644
--- a/rm_referee/src/ui/time_change_ui.cpp
+++ b/rm_referee/src/ui/time_change_ui.cpp
@@ -238,16 +238,16 @@ void LaneLineTimeChangeGroupUi::updateConfig()
   {
     if (it.first == "lane_line_left")
     {
-      it.second->setStartX(screen_x_ / 2 - spacing_x_a);
+      it.second->setStartX(screen_x_ / 2 + x_offset_ - spacing_x_a);
       it.second->setStartY(screen_y_ / 2 - spacing_y_a);
-      it.second->setEndX(screen_x_ / 2 - spacing_x_b * surface_coefficient_);
+      it.second->setEndX(screen_x_ / 2 + x_offset_ - spacing_x_b * surface_coefficient_);
       it.second->setEndY(screen_y_ / 2 - spacing_y_b);
     }
     else if (it.first == "lane_line_right")
     {
-      it.second->setStartX(screen_x_ / 2 + spacing_x_a);
+      it.second->setStartX(screen_x_ / 2 + x_offset_ + spacing_x_a);
       it.second->setStartY(screen_y_ / 2 - spacing_y_a);
-      it.second->setEndX(screen_x_ / 2 + spacing_x_b * surface_coefficient_);
+      it.second->setEndX(screen_x_ / 2 + x_offset_ + spacing_x_b * surface_coefficient_);
       it.second->setEndY(screen_y_ / 2 - spacing_y_b);
     }
   }
@@ -599,6 +599,19 @@ void TargetDistanceTimeChangeUi::updateConfig()
 {
   graph_->setFloatNum(target_distance_);
 }
+void EnemyColorTimeChangeUi::updateEnemyColorData(const std_msgs::Bool::ConstPtr& data)
+{
+  enemy_color_ = data->data;
+  updateForQueue();
+}
+void EnemyColorTimeChangeUi::updateConfig()
+{
+  char temp_content[32];
+  snprintf(temp_content, sizeof(temp_content), "%s", enemy_color_ ? "BLUE" : "RED");
+  std::string enemy_color_content(temp_content);
+  graph_->setContent(enemy_color_content);
+  graph_->setColor(enemy_color_ ? rm_referee::GraphColor::CYAN : rm_referee::GraphColor::PINK);
+}
 
 void DeployDistanceTimeChangeUi::updateDeployDistanceData(const geometry_msgs::PointConstPtr& data)
 {
diff --git a/rm_referee/src/ui/trigger_change_ui.cpp b/rm_referee/src/ui/trigger_change_ui.cpp
index 2e350296..774bd43b 100644
--- a/rm_referee/src/ui/trigger_change_ui.cpp
+++ b/rm_referee/src/ui/trigger_change_ui.cpp
@@ -229,6 +229,38 @@ void ChassisTriggerChangeUi::updateCapacityResetStatus()
   displayInCapacity();
 }
 
+void GyroTriggerChangeUi::update()
+{
+  if (chassis_mode_ == rm_msgs::ChassisCmd::RAW)
+    graph_->setWidth(fill_width_);
+  else
+    graph_->setWidth(outline_width_);
+  graph_->setOperation(rm_referee::GraphOperation::UPDATE);
+  updateForQueue(false);
+}
+
+void GyroTriggerChangeUi::updateChassisCmdData(const rm_msgs::ChassisCmd::ConstPtr& data)
+{
+  chassis_mode_ = data->mode;
+  update();
+}
+
+void ZipTriggerChangeUi::update()
+{
+  if (zip_mode_)
+    graph_->setWidth(fill_width_);
+  else
+    graph_->setWidth(outline_width_);
+  graph_->setOperation(rm_referee::GraphOperation::UPDATE);
+  updateForQueue(false);
+}
+
+void ZipTriggerChangeUi::updateManualCmdData(const rm_msgs::ManualToReferee::ConstPtr data)
+{
+  zip_mode_ = data->zip_state;
+  update();
+}
+
 void HeroLegTriggerChangeUi::updateMode(uint8_t mode)
 {
   leg_mode_ = mode;
@@ -359,11 +391,11 @@ void TargetTriggerChangeUi::updateConfig(uint8_t main_mode, bool main_flag, uint
 {
   graph_->setContent(getTargetState(main_mode, sub_mode));
   if (main_flag)
-    graph_->setColor(rm_referee::GraphColor::ORANGE);
+    graph_->setColor(rm_referee::GraphColor::WHITE);
   else if (sub_flag)
-    graph_->setColor(rm_referee::GraphColor::PINK);
+    graph_->setColor(rm_referee::GraphColor::WHITE);
   else
-    graph_->setColor(rm_referee::GraphColor::CYAN);
+    graph_->setColor(rm_referee::GraphColor::WHITE);
 }
 
 std::string TargetTriggerChangeUi::getTargetState(uint8_t target, uint8_t armor_target)