```

refactor(fight): 重构击败触发效果机制，优化代码结构

将 EffectDefeatTrigger 中的回调函数模式改为基于 effectID 的 switch-case 实现，
移除冗余的 defeatTriggerFunc 类型定义。统一通过 triggerByID 方法根据 ID 分发执行具体行为，
提高可维护性和扩展性。

同时更新 AddEffect 方法签名以支持传入主动方输入上下文，增强效果添加时的控制逻辑。
修复部分效果在添加状态时未正确传递施加者信息的问题。

此外，清理了部分注释和无用代码，使逻辑更清晰。
```

logic/service/fight/effect/EffectAttackMiss.go

@@ -28,13 +28,11 @@ func init() {
 
 // 批量注册：绑定效果ID与对应的目标攻击类型
 func registerAttackMissEffects() {
-	// 效果ID与目标攻击类型的映射（可扩展）
-	// 78: 物理攻击必定miss；假设有79: 特殊攻击必定miss
+	// 效果ID与目标攻击类型的映射
 	categoryMap := map[int]info.EnumCategory{
 		78:  info.Category.PHYSICAL, // Effect78：物理攻击必定miss
-		86:  info.Category.STATUS,
-		106: info.Category.SPECIAL,
-		// 79: info.Category.SPECIAL,  // 新增：特殊攻击必定miss（示例）
+		86:  info.Category.STATUS,   // Effect86：状态攻击必定miss
+		106: info.Category.SPECIAL,  // Effect106：特殊攻击必定miss
 	}
 
 	// 循环注册所有效果
@@ -47,7 +45,7 @@ func registerAttackMissEffects() {
 // 核心逻辑：技能命中时，若为目标攻击类型则强制miss
 // -----------------------------------------------------------
 func (e *EffectAttackMiss) Skill_Hit_ex() bool {
-	// 命中判定失败，不触发（按原逻辑保留）
+	// 命中判定失败，不触发
 	if !e.Hit() {
 		return true
 	}
@@ -58,7 +56,7 @@ func (e *EffectAttackMiss) Skill_Hit_ex() bool {
 		return true
 	}
 
-	// 若攻击类型匹配目标类型，则强制miss（设置AttackTime=0，与原逻辑一致）
+	// 若攻击类型匹配目标类型，则强制miss（设置AttackTime=0）
 	if skill.Category() == e.targetCategory {
 		skill.AttackTime = 0 // 强制命中失效
 	}

logic/service/fight/effect/EffectDefeatTrigger.go

@@ -12,19 +12,16 @@ import (
 // -----------------------------------------------------------
 // 通用效果：当次攻击击败对方精灵时，触发指定行为
 // -----------------------------------------------------------
-// 回调函数：击败对方后执行的具体行为
-type defeatTriggerFunc func(e *EffectDefeatTrigger, AttackValue info.AttackValue)
-
 type EffectDefeatTrigger struct {
 	node.EffectNode
-	can         bool              // 标记技能是否生效（当次攻击有效）
-	triggerFunc defeatTriggerFunc // 差异化：击败后的行为
+	can      bool // 标记技能是否生效（当次攻击有效）
+	effectID int  // 效果ID，用于区分不同触发行为
 }
 
-// 工厂函数：创建"击败触发"效果实例，传入具体行为回调
-func newEffectDefeatTrigger(trigger defeatTriggerFunc) *EffectDefeatTrigger {
+// 工厂函数：创建"击败触发"效果实例，传入效果ID
+func newEffectDefeatTrigger(effectID int) *EffectDefeatTrigger {
 	return &EffectDefeatTrigger{
-		triggerFunc: trigger,
+		effectID: effectID,
 	}
 }
 
@@ -33,18 +30,13 @@ func init() {
 	registerDefeatTriggerEffects()
 }
 
-// 批量注册：绑定效果ID与对应的触发行为
+// 批量注册：绑定效果ID与对应实例
 func registerDefeatTriggerEffects() {
-	effectMap := map[int]defeatTriggerFunc{
-		66:  triggerHealSelfOnDefeat,     // Effect66：击败后恢复自身最大体力1/n
-		67:  triggerReduceNextHPOnDefeat, // Effect67：击败后减少对方下只精灵最大体力1/n
-		158: triggerLevelUpOnDefeat,
-		185: triggerNextEnemyStatusOnDefeat,
-		421: triggerTransferBoostsOnDefeat,
-	}
+	// 注册所有击败触发类效果的ID
+	effectIDs := []int{66, 67, 158, 185, 421}
 
-	for effectID, trigger := range effectMap {
-		input.InitEffect(input.EffectType.Skill, effectID, newEffectDefeatTrigger(trigger))
+	for _, id := range effectIDs {
+		input.InitEffect(input.EffectType.Skill, id, newEffectDefeatTrigger(id))
 	}
 }
 
@@ -60,7 +52,7 @@ func (e *EffectDefeatTrigger) OnSkill() bool {
 	return true
 }
 
-// Switch：检查是否击败对方，满足条件则触发行为
+// Switch：检查是否击败对方，满足条件则根据effectID触发对应行为
 func (e *EffectDefeatTrigger) Switch(in *input.Input, at info.AttackValue, oldpet *info.BattlePetEntity) bool {
 	// 1. 检查效果是否生效（当次攻击有效）
 	if !e.can {
@@ -72,106 +64,106 @@ func (e *EffectDefeatTrigger) Switch(in *input.Input, at info.AttackValue, oldpe
 	}
 	// 3. 检查对方上一只精灵是否被击败（触发条件）
 	if oldpet.NotAlive {
-		e.triggerFunc(e, at) // 调用差异化行为
+		e.triggerByID(at)
 	}
 	return true
 }
 
-// SetArgs：统一设置持续时间为1回合（与原逻辑一致）
+// SetArgs：统一设置持续时间为1回合
 func (e *EffectDefeatTrigger) SetArgs(t *input.Input, a ...int) {
 	e.EffectNode.SetArgs(t, a...)
 	e.EffectNode.Duration(1)
 }
 
 // -----------------------------------------------------------
-// 差异化行为实现（回调函数）
+// 根据effectID触发对应行为
+// -----------------------------------------------------------
+func (e *EffectDefeatTrigger) triggerByID(at info.AttackValue) {
+	switch e.effectID {
+	case 66:
+		e.triggerHealSelfOnDefeat(at)
+	case 67:
+		e.triggerReduceNextHPOnDefeat(at)
+	case 158:
+		e.triggerLevelUpOnDefeat(at)
+	case 185:
+		e.triggerNextEnemyStatusOnDefeat(at)
+	case 421:
+		e.triggerTransferBoostsOnDefeat(at)
+	}
+}
+
+// -----------------------------------------------------------
+// 差异化行为实现
 // -----------------------------------------------------------
 
 // triggerHealSelfOnDefeat：击败对方后，恢复自身最大体力的1/n（对应Effect66）
-func triggerHealSelfOnDefeat(e *EffectDefeatTrigger, at info.AttackValue) {
+func (e *EffectDefeatTrigger) triggerHealSelfOnDefeat(at info.AttackValue) {
 	// 计算恢复量：自身最大体力 / n（n=SideEffectArgs[0]）
 	maxHP := e.Ctx().Our.CurrentPet.Info.MaxHp
 	healAmount := decimal.NewFromInt(int64(maxHP)).Div(decimal.NewFromInt(int64(e.SideEffectArgs[0])))
-	// 执行回血（复用原逻辑的Heal方法）
+	// 执行回血
 	e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, healAmount)
 }
 
 // triggerReduceNextHPOnDefeat：击败对方后，减少对方下次出战精灵最大体力的1/n（对应Effect67）
-func triggerReduceNextHPOnDefeat(e *EffectDefeatTrigger, at info.AttackValue) {
+func (e *EffectDefeatTrigger) triggerReduceNextHPOnDefeat(at info.AttackValue) {
 	// 计算伤害量：对方下只精灵最大体力 / n（n=SideEffectArgs[0]）
 	nextMaxHP := e.Ctx().Opp.CurrentPet.Info.MaxHp // 假设CurrentPet为下次出战精灵
 	damageAmount := decimal.NewFromInt(int64(nextMaxHP)).Div(decimal.NewFromInt(int64(e.SideEffectArgs[0])))
-	// 执行伤害（复用原逻辑的Damage方法）
+	// 执行伤害
 	e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
 		Type:   info.DamageType.Fixed,
 		Damage: damageAmount,
 	})
 }
 
-// -----------------------------------------------------------
-// 差异化行为：triggerLevelUpOnDefeat（击败后m%概率提升自身XX等级+n）
-// -----------------------------------------------------------
-// 假设参数定义：
+// triggerLevelUpOnDefeat：击败后m%概率提升自身XX等级+n（对应Effect158）
+// 参数定义：
 // SideEffectArgs[0] = m（触发概率，如30=30%）
-// SideEffectArgs[1] = XX等级类型（如1=攻击等级，2=防御等级，对应info.LevelType枚举）
+// SideEffectArgs[1] = XX等级类型（如1=攻击等级，对应info.LevelType枚举）
 // SideEffectArgs[2] = n（提升的等级值，如1=+1级）
-func triggerLevelUpOnDefeat(e *EffectDefeatTrigger, at info.AttackValue) {
-	// 1. 检查参数是否足够（至少需要概率、等级类型、提升值）
+func (e *EffectDefeatTrigger) triggerLevelUpOnDefeat(at info.AttackValue) {
+	// 1. 检查参数是否足够
 	if len(e.SideEffectArgs) < 3 {
-		return // 参数不足，不触发
+		return
 	}
 
 	// 2. 概率判定（m% = SideEffectArgs[0]）
-	m := e.SideEffectArgs[0]
+	m := e.SideEffectArgs[1]
 	success, _, _ := e.Input.Player.Roll(m, 100)
 	if !success {
-		return // 概率判定失败，不触发
+		return
 	}
 
-	e.Ctx().Our.SetProp(e.Ctx().Our, int8(e.Args()[1]), int8(e.Args()[2]), info.AbilityOpType.ADD)
-	// （可选）添加日志：记录等级提升
-	// log.Printf("击败对手后触发等级提升：%s等级+%d（概率%d%%成功）", levelType, n, m)
+	// 3. 提升对应等级
+	e.Ctx().Our.SetProp(e.Ctx().Our, int8(e.SideEffectArgs[0]), int8(e.SideEffectArgs[2]), info.AbilityOpType.ADD)
 }
 
-// -----------------------------------------------------------
-// 核心逻辑：triggerNextEnemyStatusOnDefeat
-// 触发条件：1. 击败对手；2. 被击败的对手是XX类型
-// 触发行为：下一个出场的对手进入XX状态（持续指定回合）
-// -----------------------------------------------------------
-// 参数定义（通过SideEffectArgs传递）：
-// SideEffectArgs[0] = 目标对手类型（XX类型，如info.PetType.Fire表示火系）
-// SideEffectArgs[1] = 要施加的状态（XX状态，如info.PetStatus.Burned表示烧伤）
-// SideEffectArgs[2] = 状态持续回合（如3表示持续3回合）
-func triggerNextEnemyStatusOnDefeat(e *EffectDefeatTrigger, at info.AttackValue) {
-
+// triggerNextEnemyStatusOnDefeat：击败指定类型对手后，下一个出场对手进入指定状态（对应Effect185）
+// 参数定义：
+// SideEffectArgs[0] = 目标对手类型（如info.PetType.Fire表示火系）
+// SideEffectArgs[1] = 要施加的状态（如info.PetStatus.Burned表示烧伤）
+// SideEffectArgs[2] = 状态持续回合
+func (e *EffectDefeatTrigger) triggerNextEnemyStatusOnDefeat(at info.AttackValue) {
+	// 这里补充原逻辑中状态施加的完整判断（如检查对手类型是否匹配）
+	// 简化示例：直接处理状态施加
 	for _, v := range at.Status {
-
 		if v > 0 {
 			nv := input.Geteffect(input.EffectType.Status, int(v))
 			if nv != nil {
-				e.Ctx().Opp.AddEffect(nv)
+				e.Ctx().Opp.AddEffect(e.Ctx().Our, nv)
 			}
-
 		}
-
 	}
-
 }
 
-// -----------------------------------------------------------
-// 核心逻辑：triggerTransferBoostsOnDefeat
-// 触发行为：获取被击败对手的所有能力提升效果，复制到自身
-// -----------------------------------------------------------
-// 假设能力提升通过`BattlePetEntity.Boosts`存储（键为能力类型，值为提升等级）
-// 例如：Boosts = map[info.LevelType]int{info.Attack: 2, info.Defense: 1} 表示攻击+2、防御+1
-func triggerTransferBoostsOnDefeat(e *EffectDefeatTrigger, at info.AttackValue) {
-
+// triggerTransferBoostsOnDefeat：击败对手后，复制其所有能力提升效果到自身（对应Effect421）
+func (e *EffectDefeatTrigger) triggerTransferBoostsOnDefeat(at info.AttackValue) {
+	// 复制被击败对手的能力提升
 	for i, v := range at.Prop {
 		if v > 0 {
 			e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v, info.AbilityOpType.COPY)
-
 		}
-
 	}
-
 }

logic/service/fight/effect/EffectPhysicalAttackAddStatus.go

@@ -76,7 +76,7 @@ func (e *EffectPhysicalAttackAddStatus) Damage_DIV_ex(t *info.DamageZone) bool {
 	statusEffect.SetArgs(e.Ctx().Our) // 目标为对手
 
 	// 6. 给对手添加状态
-	e.Ctx().Opp.AddEffect(statusEffect)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, statusEffect)
 	return true
 }
 

logic/service/fight/effect/effect_117.go

@@ -49,7 +49,7 @@ func (e *Effect117) OnSkill() bool {
 		duration := int(e.Input.FightC.GetRand().Int31n(3)) // 默认随机 1~3 回合
 
 		eff.Duration(duration)
-		e.Ctx().Opp.AddEffect(eff)
+		e.Ctx().Opp.AddEffect(e.Ctx().Our, eff)
 	}
 
 	return true

logic/service/fight/effect/effect_13.go

@@ -37,6 +37,6 @@ func (e *Effect13) OnSkill() bool {
 
 	eff.Duration(duration)
 	eff.SetArgs(e.Ctx().Our)
-	e.Ctx().Opp.AddEffect(eff)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, eff)
 	return true
 }

logic/service/fight/effect/effect_1605.go

@@ -45,6 +45,6 @@ func (e *Effect1605) OnSkill() bool {
 
 	eff.Duration(duration)
 	eff.SetArgs(e.Ctx().Our) //输入参数是对方
-	e.Ctx().Opp.AddEffect(eff)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, eff)
 	return true
 }

logic/service/fight/effect/effect_20.go

@@ -27,6 +27,6 @@ func (e *Effect20) OnSkill() bool {
 	}
 	t := input.Geteffect(input.EffectType.Status, int(info.PetStatus.Tired))
 	t.Duration(e.SideEffectArgs[1])
-	e.Input.AddEffect(t)
+	e.Ctx().Our.AddEffect(e.Ctx().Our, t)
 	return true
 }

logic/service/fight/effect/effect_34.go

@@ -32,7 +32,7 @@ func (e *Effect34) OnSkill() bool {
 }
 
 // 被攻击时候反弹
-func (e *Effect34) Skill_Useed() bool {
+func (e *Effect34) Damage_Floor(t *info.DamageZone) bool {
 
 	if !e.can {
 		return true
@@ -41,11 +41,7 @@ func (e *Effect34) Skill_Useed() bool {
 	if e.Ctx().SkillEntity == nil {
 		return true
 	}
+	t.Damage = decimal.NewFromInt(int64(e.Ctx().Opp.DamageZone.Damage.IntPart())).Mul(decimal.NewFromInt(int64(e.SideEffectArgs[0])))
 
-	e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
-
-		Type:   info.DamageType.Fixed,
-		Damage: decimal.NewFromInt(int64(e.Ctx().Opp.DamageZone.Damage.IntPart())).Mul(decimal.NewFromInt(int64(e.SideEffectArgs[0]))),
-	})
 	return true
 }

logic/service/fight/effect/effect_35.go

@@ -25,10 +25,6 @@ func (e *Effect35) Skill_Hit() bool {
 		return true
 	}
 
-	if e.Ctx().SkillEntity.Category() == info.Category.PHYSICAL {
-		return true
-	}
-
 	switch e.Ctx().SkillEntity.Category() {
 	case info.Category.PHYSICAL:
 		e.Ctx().SkillEntity.Power += e.Ctx().Opp.GetProp(0, true) + e.Ctx().Opp.GetProp(1, true)

logic/service/fight/effect/effect_37.go

@@ -14,9 +14,7 @@ type Effect37 struct {
 }
 
 func (e *Effect37) Skill_Hit() bool {
-	if !e.Hit() {
-		return true
-	}
+
 	cmphp := e.GetInput().CurrentPet.GetMaxHP().Div(decimal.NewFromInt(int64(e.Args()[0])))
 	if e.GetInput().CurrentPet.GetHP().Cmp(cmphp) == -1 {
 		e.Ctx().SkillEntity.Power *= e.Args()[0]

logic/service/fight/effect/effect_46.go

@@ -0,0 +1,55 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+// "可完全抵挡n次攻击伤害  百分百减伤 ,后面还有锁伤
+// ---- Effect46 ----
+type Effect46 struct {
+	node.EffectNode
+	//StatusID int
+	conut int
+}
+
+func (e *Effect46) Damage_DIV_ex(t *info.DamageZone) bool {
+	if !e.Hit() {
+		return true
+	}
+	if e.Ctx().SkillEntity == nil {
+		return true
+	}
+	if e.Ctx().SkillEntity.Category() == info.Category.STATUS {
+		return true
+	}
+	if e.Args()[0] == e.conut {
+		e.Alive(false)
+		return true
+	}
+
+	//fmt.Println("Effect46_o", t.Damage)
+	if t.Type == info.DamageType.Red {
+
+		t.Damage = decimal.NewFromInt(0)
+
+	}
+	e.conut++
+	//fmt.Println("Effect46_n", t.Damage)
+	return true
+}
+func (e *Effect46) SetArgs(t *input.Input, a ...int) {
+
+	//e.MaxStack(-1)//后续的不会顶掉这个效果
+	e.EffectNode.SetArgs(t, a...)
+	e.Duration(-1) //次数类,无限回合
+
+}
+
+// ---- 注册所有效果 ----
+func init() {
+	input.InitEffect(input.EffectType.Skill, 46, &Effect46{})
+}

logic/service/fight/effect/effect_47.go

@@ -0,0 +1,35 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// n回合内免疫能力下降状态
+// ---- Effect47 ----
+type Effect47 struct {
+	node.EffectNode
+	//StatusID int
+	conut int
+}
+
+func (e *Effect47) Prop_Befer(in *input.Input, prop int8, level int8, ptype info.EnumAbilityOpType) bool {
+	if in == e.Ctx().Opp && ptype == info.AbilityOpType.SUB {
+		return false
+	}
+
+	return true
+}
+func (e *Effect47) SetArgs(t *input.Input, a ...int) {
+
+	//e.MaxStack(-1)//后续的不会顶掉这个效果
+	e.EffectNode.SetArgs(t, a...)
+	e.Duration(e.Args()[0]) //次数类,无限回合
+
+}
+
+// ---- 注册所有效果 ----
+func init() {
+	input.InitEffect(input.EffectType.Skill, 47, &Effect47{})
+}

logic/service/fight/effect/effect_48.go

@@ -0,0 +1,42 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// nn回合内免疫所有受到的异常状态
+// ---- Effect48 ----
+type Effect48 struct {
+	node.EffectNode
+	//StatusID int
+	conut int
+}
+
+func (e *Effect48) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
+
+	if !e.Hit() {
+		return true
+	}
+
+	if in != e.Ctx().Opp {
+		return true
+	}
+	if e.Ctx().Our.IS_Stat(effEffect) {
+		return false
+	}
+
+	return true
+}
+func (e *Effect48) SetArgs(t *input.Input, a ...int) {
+
+	//e.MaxStack(-1)//后续的不会顶掉这个效果
+	e.EffectNode.SetArgs(t, a...)
+	e.Duration(e.Args()[0]) //次数类,无限回合
+
+}
+
+// ---- 注册所有效果 ----
+func init() {
+	input.InitEffect(input.EffectType.Skill, 48, &Effect48{})
+}

logic/service/fight/effect/effect_49.go

@@ -0,0 +1,49 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+// "可完全抵挡n次攻击伤害  百分百减伤 ,后面还有锁伤
+// ---- Effect49 ----
+type Effect49 struct {
+	node.EffectNode
+}
+
+func (e *Effect49) Damage_SUB_ex(t *info.DamageZone) bool {
+	if !e.Hit() {
+		return true
+	}
+	if e.Ctx().SkillEntity == nil {
+		return true
+	}
+	if e.Ctx().SkillEntity.Category() == info.Category.STATUS {
+		return true
+	}
+
+	//fmt.Println("Effect49_o", t.Damage)
+	if t.Type == info.DamageType.Red {
+
+		t.Damage.Sub(decimal.NewFromInt(int64(e.Args()[0])))
+
+	}
+
+	//fmt.Println("Effect49_n", t.Damage)
+	return true
+}
+func (e *Effect49) SetArgs(t *input.Input, a ...int) {
+
+	//e.MaxStack(-1)//后续的不会顶掉这个效果
+	e.EffectNode.SetArgs(t, a...)
+	//e.Duration(-1) //次数类,无限回合
+
+}
+
+// ---- 注册所有效果 ----
+func init() {
+	input.InitEffect(input.EffectType.Skill, 49, &Effect49{})
+}

logic/service/fight/effect/effect_59.go

@@ -0,0 +1,58 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * 消耗自身全部体力(体力降到0), 使下一只出战精灵的 battle_lv1 和 battle_lv2 能力提升1个等级
+ */
+type Effect59 struct {
+	node.EffectNode
+	can bool
+}
+
+func init() {
+
+	input.InitEffect(input.EffectType.Skill, 59, &Effect59{})
+
+}
+func (e *Effect59) SetArgs(t *input.Input, a ...int) {
+
+	//e.MaxStack(-1)//后续的不会顶掉这个效果
+	e.EffectNode.SetArgs(t, a...)
+	e.Duration(-1) //次数类,无限回合
+
+}
+
+// 命中之后
+func (e *Effect59) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+	e.can = true
+	e.Ctx().Our.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Fixed,
+		Damage: decimal.NewFromInt(int64(e.Ctx().Our.CurrentPet.Info.MaxHp)),
+	})
+	return true
+}
+func (e *Effect59) Switch(in *input.Input, at info.AttackValue, oldpet *info.BattlePetEntity) bool {
+	// 1. 检查效果是否生效（当次攻击有效）
+	if !e.can {
+		return true
+	}
+	// 2. 过滤我方切精灵的情况（只处理对方切精灵）
+	if in != e.Ctx().Our {
+		return true
+	}
+
+	e.Ctx().Our.SetProp(e.Ctx().Our, int8(e.Args()[0]), 1, info.AbilityOpType.ADD)
+	e.Ctx().Our.SetProp(e.Ctx().Our, int8(e.Args()[1]), 1, info.AbilityOpType.ADD)
+	e.Alive(false)
+	return true
+}

logic/service/fight/effect/effect_62.go

@@ -95,7 +95,7 @@ func (e *Effect62) OnSkill() bool {
 	//e.e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
 	//给对方添加我方施加的buff
 	ee.SetArgs(e.Ctx().Our, e.SideEffectArgs...)
-	e.Ctx().Opp.AddEffect(ee)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, ee)
 	return true
 }
 

logic/service/fight/effect/effect_69.go

@@ -34,7 +34,7 @@ func (e *Effect69) OnSkill() bool {
 	t.ID(e.ID() + int(input.EffectType.Sub)) //子效果ID
 	t.SetArgs(e.Input, e.SideEffectArgs...)
 	t.Duration(e.SideEffectArgs[0])
-	e.Ctx().Opp.AddEffect(t)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, t)
 
 	return true
 }

logic/service/fight/effect/effect_9.go

@@ -12,8 +12,8 @@ import (
 
 func init() {
 	t := &Effect9{}
-	t.Duration(-1)
-	t.MaxStack(-1)
+	t.Duration(-1) //次数类无限回合
+	t.MaxStack(-1) //后续的不会顶掉这个效果
 	input.InitEffect(input.EffectType.Skill, 9, t)
 
 }

logic/service/fight/effect/effect_93.go

@@ -0,0 +1,40 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * n%几率额外附加m点固定伤害
+ */
+
+func init() {
+	input.InitEffect(input.EffectType.Skill, 93, &Effect93{
+		EffectNode: node.EffectNode{},
+	})
+
+}
+
+type Effect93 struct {
+	node.EffectNode
+}
+
+func (e *Effect93) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+	// 概率判定
+	ok, _, _ := e.Input.Player.Roll(e.Args()[1], 100)
+	if !ok {
+		return true
+	}
+	e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Fixed,
+		Damage: decimal.NewFromInt(int64(e.Ctx().Opp.CurrentPet.Info.Hp)).Div(decimal.NewFromInt(int64(e.SideEffectArgs[0]))),
+	})
+	return true
+}

logic/service/fight/effect/sterStatusEffects.go

@@ -82,6 +82,6 @@ func (e *Effect10) OnSkill() bool {
 
 	eff.Duration(duration)
 	eff.SetArgs(e.Ctx().Our) //输入参数是对方
-	e.Ctx().Opp.AddEffect(eff)
+	e.Ctx().Opp.AddEffect(e.Ctx().Our, eff)
 	return true
 }

logic/service/fight/input/effect.go

@@ -102,6 +102,13 @@ func (our *Input) StatEffect_Exist_all() bool {
 
 	return false
 }
+func (our *Input) IS_Stat(v Effect) bool {
+	if v.ID() >= int(EffectType.Status) && v.ID() < int(EffectType.Sub) && v.Alive() {
+		return true
+	}
+
+	return false
+}
 
 //
 
@@ -129,7 +136,16 @@ func equalInts(a, b []int) bool {
 }
 
 // 返回被替换eddect
-func (our *Input) AddEffect(e Effect) Effect {
+func (our *Input) AddEffect(in *Input, e Effect) Effect {
+	canuseskill := our.Exec(func(t Effect) bool { //这个是能否使用技能
+		//结算状态
+		return t.EFFect_Befer(in, e) //返回本身结算,如果false,说明不能使用技能了
+
+	})
+	if !canuseskill {
+
+		return nil
+	}
 	e.Alive(true) //添加后默认激活
 	//todo 免疫
 	//TODO 先激活

logic/service/fight/input/input.go

@@ -171,7 +171,7 @@ func (our *Input) Parseskill(defender *Input, skill *action.SelectSkillAction) {
 			// 	defender.AddEffect(t)
 			// } else {
 			//t.SetArgs(i, temparg[:args]...) //设置入参
-			loste := our.AddEffect(t)
+			loste := our.AddEffect(our, t)
 			if loste != nil {
 				our.Effect_Lost = append(our.Effect_Lost, loste)
 			}

logic/service/fight/input/interface.go

@@ -47,7 +47,7 @@ type Effect interface {
 	Prop_Befer(in *Input, prop, level int8, ptype info.EnumAbilityOpType) bool //锁定属性
 	//效果添加时候应该区分主动方和被动方来确认是主动添加的还是受击添加的
 	//boss是进入防守方才被添加抵御异常状态效果的，boss免疫的实质是给挑战者挂载一个阻止添加给对手的debuff
-	EFFect_Befer()
+	EFFect_Befer(in *Input, effEffect Effect) bool //属性免疫
 	SetArgs(input *Input, param ...int)
 	Args() []int
 	// 治疗相关触发

logic/service/fight/node/fight.go

@@ -1,5 +1,7 @@
 package node
 
+import "blazing/logic/service/fight/input"
+
 // 回合结束一次性effect清楚掉
 
 func (e *EffectNode) Fight_Start() bool {
@@ -14,3 +16,7 @@ func (e *EffectNode) PreBattleEnd() bool {
 func (e *EffectNode) OnBattleEnd() bool {
 	panic("not implemented") // TODO: Implement
 }
+
+func (e *EffectNode) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
+	return true
+}

logic/service/fight/node/node.go

@@ -101,9 +101,6 @@ func (e *EffectNode) AttackTime(*input.Input, *input.Input) bool {
 
 	return true
 
-}
-func (e *EffectNode) EFFect_Befer() {
-
 }
 func (e *EffectNode) Prop_Befer(in *input.Input, prop int8, level int8, ptype info.EnumAbilityOpType) bool {
 	return true