diff --git a/server/gameserver/buff.cc b/server/gameserver/buff.cc
index 50ad20c4..e467e005 100644
--- a/server/gameserver/buff.cc
+++ b/server/gameserver/buff.cc
@@ -77,7 +77,7 @@ int Buff::GetLeftTime()
 
 int Buff::GetLastingTime()
 {
-    return meta->GetDurationTime(owner, skill_meta) * 1000;
+    return meta->GetDurationTime(this) * 1000;
 }
 
 void Buff::InternalTimerAddBuff()
diff --git a/server/gameserver/buff/callfunc.cc b/server/gameserver/buff/callfunc.cc
index e97f07e5..fb9d72c1 100644
--- a/server/gameserver/buff/callfunc.cc
+++ b/server/gameserver/buff/callfunc.cc
@@ -20,7 +20,7 @@ void CallFuncBuff::Activate()
         break;
     case BuffCallFunc_e::kSpeedReduce:
         {
-            hold_param2_ = meta->GetBuffParam2(owner, skill_meta);
+            hold_param2_ = meta->GetBuffParam2(this);
             owner->GetAbility()->AddSpeedRuduce(hold_param2_);
         }
         break;
@@ -31,7 +31,18 @@ void CallFuncBuff::Activate()
         break;
     case BuffCallFunc_e::kDecHp:
         {
-            hold_param2_ = meta->GetBuffParam2(owner, skill_meta);
+            hold_param2_ = meta->GetBuffParam2(this);
+            if (GetCaster().Get()) {
+                float dmg_out = 0.0f;
+                owner->DecHP(hold_param2_,
+                             GetCaster().Get()->GetUniId(),
+                             GetCaster().Get()->GetName(),
+                             VP_Buff,
+                             GetCaster().Get()->GetUniId(),
+                             GetCaster().Get()->GetName(),
+                             dmg_out
+                             );
+            }
         }
         break;
     case BuffCallFunc_e::kMarkTag:
@@ -41,7 +52,7 @@ void CallFuncBuff::Activate()
         break;
     case BuffCallFunc_e::kSpeedAddition:
         {
-            hold_param2_ = meta->GetBuffParam2(owner, skill_meta);
+            hold_param2_ = meta->GetBuffParam2(this);
             owner->GetAbility()->AddSpeedAddition(hold_param2_);
         }
         break;
@@ -113,7 +124,7 @@ void CallFuncBuff::ProcIntervalRangeAddBuffFunc()
 void CallFuncBuff::ProcAddMinorMode()
 {
     if (skill_meta) {
-        float dur_time = meta->GetBuffParam3(owner, skill_meta);
+        float dur_time = meta->GetBuffParam3(this);
         Skill* skill = owner->GetSkill(skill_meta->skill_id());
         if (skill) {
             skill->AddMinorMode
diff --git a/server/gameserver/buff/reverse.cc b/server/gameserver/buff/reverse.cc
index f03f7d66..997b5a82 100644
--- a/server/gameserver/buff/reverse.cc
+++ b/server/gameserver/buff/reverse.cc
@@ -13,7 +13,7 @@
 
 void ReverseBuff::Activate()
 {
-    hold_param1_ = meta->GetBuffParam1(owner, skill_meta);
+    hold_param1_ = meta->GetBuffParam1(this);
     if (caster_.Get()) {
         glm::vec3 dir = caster_.Get()->GetPos().CalcDir(owner->GetPos());
         if ((std::isfinite(dir.x) &&
diff --git a/server/gameserver/buff/sprint.cc b/server/gameserver/buff/sprint.cc
index 241f4f40..39a9fe17 100644
--- a/server/gameserver/buff/sprint.cc
+++ b/server/gameserver/buff/sprint.cc
@@ -22,9 +22,9 @@ void SprintBuff::Activate()
         owner->IncDisableMoveDirTimes();
     }
     #endif
-    move_distance_limit_ = meta->GetBuffParam2(owner, skill_meta);
-    check_interval_time_ = meta->GetBuffParam5(owner, skill_meta);
-    check_distance_ = meta->GetBuffParam4(owner, skill_meta);
+    move_distance_limit_ = meta->GetBuffParam2(this);
+    check_interval_time_ = meta->GetBuffParam5(this);
+    check_distance_ = meta->GetBuffParam4(this);
     SprintMove();
     CoCollisionCheck();
 }
@@ -178,34 +178,6 @@ void SprintBuff::OnEnemyHit(Creature* enemy)
     for (int buff_id : meta->_buff_param3_int_list) {
         enemy->TryAddBuff(owner, buff_id, skill_meta);
     }
-    #if 0
-    if (skill_meta) {
-        switch (skill_meta->GetMagicId()) {
-        case MAGIC_20901_XIONG:
-            {
-                float dmg = SkillHelper::GetYmczDmg(owner,
-                                                    enemy,
-                                                    skill_meta);
-                if (dmg > 0.0001f) {
-                    float dmg_out = 0.0f;
-                    enemy->DecHP(
-                                 dmg,
-                                 owner->GetUniId(),
-                                 owner->GetName(),
-                                 0,
-                                 owner->GetUniId(),
-                                 owner->GetName(),
-                                 dmg_out);
-                }
-            }
-            break;
-        default:
-            {
-            }
-            break;
-        }
-    }
-    #endif
 }
 
 #if 0
diff --git a/server/gameserver/creature.cc b/server/gameserver/creature.cc
index b4b3b81f..873222fe 100644
--- a/server/gameserver/creature.cc
+++ b/server/gameserver/creature.cc
@@ -275,7 +275,7 @@ int Creature::AddBuff(Creature* caster,
     {
         buff->remover_timer = room->xtimer.SetTimeoutWpEx
             (
-             buff_meta->GetDurationTime(this, buff_skill_meta) * SERVER_FRAME_RATE,
+             buff_meta->GetDurationTime(buff.get()) * SERVER_FRAME_RATE,
              [buff_wp = (std::weak_ptr<Buff>)buff] (int event, const a8::Args* args)
              {
                  if (a8::TIMER_EXEC_EVENT == event) {
diff --git a/server/gameserver/lispenv.cc b/server/gameserver/lispenv.cc
index aee61951..0cc329f6 100644
--- a/server/gameserver/lispenv.cc
+++ b/server/gameserver/lispenv.cc
@@ -1,6 +1,7 @@
 #include "precompile.h"
 
 #include "lispenv.h"
+#include "buff.h"
 
 #include "mt/Skill.h"
 #include "mt/SkillNumber.h"
@@ -22,22 +23,19 @@ public:
                  }
                  a8::lisp::Atom atom = std::any_cast<a8::lisp::Atom>(params->at(0)->value);
                  int idx = atom.val;
-                 result = context_.skill_meta->_number_meta->GetAttrByIdx(idx);
+                 result = context_.buff->skill_meta->_number_meta->GetAttrByIdx(idx);
                  return std::make_shared<a8::lisp::Value>(a8::lisp::Atom(result));
              });
     }
 
     float Eval(std::shared_ptr<a8::lisp::Value> expr,
-               Creature* c,
-               const mt::Skill* skill_meta)
+               Buff* buff)
     {
-        context_.c = c;
-        context_.skill_meta = skill_meta;
+        context_.buff = buff;
 
         auto result = a8::lisp::Expr::Eval(expr, shared_from_this());
 
-        context_.c = nullptr;
-        context_.skill_meta = nullptr;
+        context_.buff = nullptr;
 
         if (!result) {
             abort();
@@ -102,8 +100,7 @@ public:
 private:
 
     struct {
-        Creature* c = nullptr;
-        const mt::Skill* skill_meta = nullptr;
+        Buff* buff = nullptr;
     } context_;
 
 };
@@ -125,8 +122,7 @@ std::shared_ptr<a8::lisp::Value> LispEnv::CompileSkillNumberExpr(const std::stri
 }
 
 float LispEnv::EvalSkillNumberExpr(std::shared_ptr<a8::lisp::Value> expr,
-                                   Creature* c,
-                                   const mt::Skill* skill_meta)
+                                   Buff* buff)
 {
-    return skill_env_->Eval(expr, c, skill_meta);
+    return skill_env_->Eval(expr, buff);
 }
diff --git a/server/gameserver/lispenv.h b/server/gameserver/lispenv.h
index 29fcbacc..15343450 100644
--- a/server/gameserver/lispenv.h
+++ b/server/gameserver/lispenv.h
@@ -19,8 +19,8 @@ class LispEnv : public a8::Singleton<LispEnv>
 
     std::shared_ptr<a8::lisp::Value> CompileSkillNumberExpr(const std::string& script);
     float EvalSkillNumberExpr(std::shared_ptr<a8::lisp::Value> expr,
-                              Creature* c,
-                              const mt::Skill* skill_meta);
+                              Buff* buff
+                              );
 
  private:
 
diff --git a/server/gameserver/mt/Buff.cc b/server/gameserver/mt/Buff.cc
index 7ca161a9..95b7968d 100644
--- a/server/gameserver/mt/Buff.cc
+++ b/server/gameserver/mt/Buff.cc
@@ -345,79 +345,73 @@ namespace mt
         }
     }
 
-    float Buff::GetDurationTime(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetDurationTime(::Buff* buff) const
     {
         if (_duration_time_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _duration_time_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _duration_time;
     }
 
-    float Buff::GetBuffParam1(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetBuffParam1(::Buff* buff) const
     {
         if (_buff_param1_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _buff_param1_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _buff_param1;
     }
 
-    float Buff::GetBuffParam2(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetBuffParam2(::Buff* buff) const
     {
         if (_buff_param2_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _buff_param2_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _buff_param2;
     }
 
-    float Buff::GetBuffParam3(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetBuffParam3(::Buff* buff) const
     {
         if (_buff_param3_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _buff_param3_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _buff_param3;
     }
 
-    float Buff::GetBuffParam4(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetBuffParam4(::Buff* buff) const
     {
         if (_buff_param4_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _buff_param4_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _buff_param4;
     }
 
-    float Buff::GetBuffParam5(Creature* c, const mt::Skill* skill_meta) const
+    float Buff::GetBuffParam5(::Buff* buff) const
     {
         if (_buff_param5_expr) {
             return LispEnv::Instance()->EvalSkillNumberExpr
                 (
                  _buff_param5_expr,
-                 c,
-                 skill_meta
+                 buff
                  );
         }
         return _buff_param5;
diff --git a/server/gameserver/mt/Buff.h b/server/gameserver/mt/Buff.h
index 3df3bace..e8dcf9ff 100644
--- a/server/gameserver/mt/Buff.h
+++ b/server/gameserver/mt/Buff.h
@@ -12,6 +12,7 @@ namespace a8
 
 }
 
+class Buff;
 class Creature;
 namespace mt
 {
@@ -54,12 +55,12 @@ namespace mt
 
         std::vector<int> _child_buff_list;
 
-        float GetDurationTime(Creature* c, const mt::Skill* skill_meta) const;
-        float GetBuffParam1(Creature* c, const mt::Skill* skill_meta) const;
-        float GetBuffParam2(Creature*, const mt::Skill* skill_meta) const;
-        float GetBuffParam3(Creature* c, const mt::Skill* skill_meta) const;
-        float GetBuffParam4(Creature* c, const mt::Skill* skill_meta) const;
-        float GetBuffParam5(Creature* c, const mt::Skill* skill_meta) const;
+        float GetDurationTime(::Buff* buff) const;
+        float GetBuffParam1(::Buff* buff) const;
+        float GetBuffParam2(::Buff* buff) const;
+        float GetBuffParam3(::Buff* buff) const;
+        float GetBuffParam4(::Buff* buff) const;
+        float GetBuffParam5(::Buff* buff) const;
 
     private:
         float _duration_time = 0.0f;