```

refactor(effect): 更新状态枚举类型为 EnumPetStatus

将多个技能效果文件中的 EnumBattleStatus 类型统一更新为 EnumPetStatus，
以更准确地反映其用途。同时修改了相关函数签名和变量声明。

此外，清理了部分注释格式，并补充了关于被动效果不能被免疫的说明。
```

logic/service/fight/effect/effect_10-16_94_99_114.go

@@ -11,12 +11,12 @@ import (
 // -----------------------------------------------------------
 type Effect10 struct {
 	node.EffectNode
-	Status info.EnumBattleStatus // 要施加的状态类型
+	Status info.EnumPetStatus // 要施加的状态类型
 
 }
 
 // 工厂函数
-func newEffectStatus(status info.EnumBattleStatus) *Effect10 {
+func newEffectStatus(status info.EnumPetStatus) *Effect10 {
 	return &Effect10{
 		Status: status,
 	}
@@ -28,7 +28,7 @@ func init() {
 }
 
 func registerStatusEffects() {
-	statusList := map[int]info.EnumBattleStatus{
+	statusList := map[int]info.EnumPetStatus{
 		10: info.PetStatus.Paralysis,
 		11: info.PetStatus.Poisoned,
 		12: info.PetStatus.Burned,

logic/service/fight/effect/effect_105.go

@@ -0,0 +1,34 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/action"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * 给予对象损伤1/n，会回复自己的体力
+ */
+type Effect105 struct {
+	node.EffectNode
+}
+
+func init() {
+
+	input.InitEffect(input.EffectType.Skill, 105, &Effect105{})
+
+}
+
+// 命中之后
+func (e *Effect105) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+
+	e.Input.Heal(
+		e.Ctx().Our, &action.SelectSkillAction{}, e.Ctx().Our.DamageZone.Damage.Div(decimal.NewFromInt(int64(e.Args()[0]))),
+	)
+	return true
+}

logic/service/fight/effect/effect_13.go

@@ -11,7 +11,7 @@ import (
 // -----------------------------------------------------------
 type Effect13 struct {
 	node.EffectNode
-	Status info.EnumBattleStatus // 要施加的状态类型
+	Status info.EnumPetStatus // 要施加的状态类型
 
 }
 

logic/service/fight/effect/effect_1605.go

@@ -11,7 +11,7 @@ import (
 // -----------------------------------------------------------
 type Effect1605 struct {
 	node.EffectNode
-	Status info.EnumBattleStatus // 要施加的状态类型
+	Status info.EnumPetStatus // 要施加的状态类型
 
 }
 

logic/service/fight/effect/effect_50.go

@@ -0,0 +1,48 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+// n回合自身受到物理攻击伤害减半
+// ---- Effect50 ----
+type Effect50 struct {
+	node.EffectNode
+	StatusID int
+}
+
+func (e *Effect50) 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.PHYSICAL {
+		return true
+	}
+
+	//fmt.Println("Effect50_o", t.Damage)
+	if t.Type == info.DamageType.Red {
+
+		t.Damage = t.Damage.Div(decimal.NewFromInt(int64(e.Args()[1])))
+
+	}
+	//fmt.Println("Effect50_n", t.Damage)
+	return true
+}
+func (e *Effect50) SetArgs(t *input.Input, a ...int) {
+
+	e.EffectNode.SetArgs(t, a...)
+	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
+
+}
+
+// ---- 注册所有效果 ----
+func init() {
+	input.InitEffect(input.EffectType.Skill, 50, &Effect50{})
+}

logic/service/fight/effect/effect_57.go

@@ -0,0 +1,40 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/action"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * n回合内每回合使用技能恢复自身最大体力的1/m
+ */
+
+func init() {
+
+	//	t.Duration(-1) //设置成无限回合,到回合数就停止
+	input.InitEffect(input.EffectType.Skill, 57, &Effect57{})
+
+}
+
+type Effect57 struct {
+	node.EffectNode
+}
+
+// 默认添加回合
+func (e *Effect57) SetArgs(t *input.Input, a ...int) {
+
+	e.EffectNode.SetArgs(t, a...)
+	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
+
+}
+func (e *Effect57) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+	heal := e.Ctx().Our.CurrentPet.GetMaxHP().Div(decimal.NewFromInt(int64(e.Args()[1])))
+	e.Ctx().Opp.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
+	return true
+}

logic/service/fight/effect/effect_6.go

@@ -8,9 +8,8 @@ import (
 	"github.com/shopspring/decimal"
 )
 
-/**
+//对方所受伤害的1/n会反弹给自己
- * 对方所受伤害的1/n会反弹给自己
+//被动效果都是自己施加给自己的,所以不能免疫
- */
 
 func init() {
 	input.InitEffect(input.EffectType.Skill, 6, &Effect6{

logic/service/fight/effect/effect_77.go

@@ -0,0 +1,39 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/action"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * n回合内使用技能恢复m点体力值
+ */
+
+func init() {
+
+	//	t.Duration(-1) //设置成无限回合,到回合数就停止
+	input.InitEffect(input.EffectType.Skill, 77, &Effect77{})
+
+}
+
+type Effect77 struct {
+	node.EffectNode
+}
+
+// 默认添加回合
+func (e *Effect77) SetArgs(t *input.Input, a ...int) {
+
+	e.EffectNode.SetArgs(t, a...)
+	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
+
+}
+func (e *Effect77) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+	e.Ctx().Opp.Heal(e.Ctx().Our, &action.SelectSkillAction{}, decimal.NewFromInt(int64(e.Args()[0])))
+	return true
+}

logic/service/fight/effect/effect_78_86_106.go

@@ -0,0 +1,73 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// -----------------------------------------------------------
+// 通用效果：n回合内，指定类型的攻击对自身必定miss
+// -----------------------------------------------------------
+type EffectAttackMiss struct {
+	node.EffectNode
+	targetCategory info.EnumCategory // 差异化：目标攻击类型（物理/特殊等）
+}
+
+// 工厂函数：创建"指定攻击类型必定miss"效果实例
+func newEffectAttackMiss(category info.EnumCategory) *EffectAttackMiss {
+	return &EffectAttackMiss{
+		targetCategory: category,
+	}
+}
+
+// 初始化：批量注册所有"攻击类型必定miss"类效果
+func init() {
+	registerAttackMissEffects()
+}
+
+// 批量注册：绑定效果ID与对应的目标攻击类型
+func registerAttackMissEffects() {
+	// 效果ID与目标攻击类型的映射（可扩展）
+	// 78: 物理攻击必定miss；假设有79: 特殊攻击必定miss
+	categoryMap := map[int]info.EnumCategory{
+		78:  info.Category.PHYSICAL, // Effect78：物理攻击必定miss
+		86:  info.Category.STATUS,
+		106: info.Category.SPECIAL,
+		// 79: info.Category.SPECIAL,  // 新增：特殊攻击必定miss（示例）
+	}
+
+	// 循环注册所有效果
+	for effectID, category := range categoryMap {
+		input.InitEffect(input.EffectType.Skill, effectID, newEffectAttackMiss(category))
+	}
+}
+
+// -----------------------------------------------------------
+// 核心逻辑：技能命中时，若为目标攻击类型则强制miss
+// -----------------------------------------------------------
+func (e *EffectAttackMiss) Skill_Hit_ex() bool {
+	// 命中判定失败，不触发（按原逻辑保留）
+	if !e.Hit() {
+		return true
+	}
+
+	// 技能为空时不处理
+	skill := e.Ctx().SkillEntity
+	if skill == nil {
+		return true
+	}
+
+	// 若攻击类型匹配目标类型，则强制miss（设置AttackTime=0，与原逻辑一致）
+	if skill.Category() == e.targetCategory {
+		skill.AttackTime = 0 // 强制命中失效
+	}
+
+	return true
+}
+
+// 设置参数：复用父类逻辑，设置持续回合
+func (e *EffectAttackMiss) SetArgs(t *input.Input, a ...int) {
+	e.EffectNode.SetArgs(t, a...)
+	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0]) // 持续回合由SideEffectArgs[0]指定
+}

logic/service/fight/effect/effect_79.go

@@ -0,0 +1,39 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * 损失1/2的体力，提升自身的能力
+ */
+type Effect79 struct {
+	node.EffectNode
+}
+
+func init() {
+
+	input.InitEffect(input.EffectType.Skill, 79, &Effect79{})
+
+}
+
+// 命中之后
+// 特攻+2速度+1命中+1，
+func (e *Effect79) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+
+	e.Ctx().Our.SetProp(e.Ctx().Our, 2, 2, info.AbilityOpType.ADD)
+	e.Ctx().Our.SetProp(e.Ctx().Our, 4, 1, info.AbilityOpType.ADD)
+	e.Ctx().Our.SetProp(e.Ctx().Our, 5, 1, info.AbilityOpType.ADD)
+	e.Ctx().Our.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Fixed,
+		Damage: decimal.NewFromInt(int64(e.Ctx().Our.CurrentPet.Info.MaxHp)).Div(decimal.NewFromInt(2)),
+	})
+	return true
+}

logic/service/fight/effect/effect_80.go

@@ -0,0 +1,41 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+
+	"github.com/shopspring/decimal"
+)
+
+/**
+ * 损失1/2的体力，给于对手同等的伤害
+ */
+type Effect80 struct {
+	node.EffectNode
+}
+
+func init() {
+
+	input.InitEffect(input.EffectType.Skill, 80, &Effect80{})
+
+}
+
+// 命中之后
+// 特攻+2速度+1命中+1，
+func (e *Effect80) OnSkill() bool {
+	if !e.Hit() {
+		return true
+	}
+
+	att := decimal.NewFromInt(int64(e.Ctx().Our.CurrentPet.Info.MaxHp)).Div(decimal.NewFromInt(2))
+	e.Ctx().Our.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Fixed,
+		Damage: att,
+	})
+	e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Fixed,
+		Damage: att,
+	})
+	return true
+}

logic/service/fight/effect/effect_84_92.go

@@ -0,0 +1,97 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// -----------------------------------------------------------
+// 通用效果：受物理攻击时概率附加指定状态（如麻痹、冰冻等）
+// -----------------------------------------------------------
+type EffectPhysicalAttackAddStatus struct {
+	node.EffectNode
+	targetStatus info.EnumPetStatus // 差异化：要附加的目标状态
+}
+
+// 工厂函数：创建"物理攻击触发状态"效果实例
+func newEffectPhysicalAttackAddStatus(status info.EnumPetStatus) *EffectPhysicalAttackAddStatus {
+	return &EffectPhysicalAttackAddStatus{
+		targetStatus: status,
+	}
+}
+
+// 初始化：批量注册所有"物理攻击触发状态"类效果
+func init() {
+	registerPhysicalAttackAddStatusEffects()
+}
+
+// 批量注册：绑定效果ID与对应的目标状态
+func registerPhysicalAttackAddStatusEffects() {
+	// 效果ID与目标状态的映射（84=麻痹，92=冰冻，可按需扩展其他状态）
+	statusMap := map[int]info.EnumPetStatus{
+		84:  info.PetStatus.Paralysis, // Effect84：物理攻击触发麻痹
+		92:  info.PetStatus.Frozen,    // Effect92：物理攻击触发冰冻
+		108: info.PetStatus.Burned,    // Effect108：物理攻击触发灼烧
+		// 新增类似效果只需在这里加条目，例如：
+		// 100: info.PetStatus.Poisoned, // 物理攻击触发中毒
+	}
+
+	// 循环注册所有效果
+	for effectID, status := range statusMap {
+		input.InitEffect(input.EffectType.Skill, effectID, newEffectPhysicalAttackAddStatus(status))
+	}
+}
+
+// -----------------------------------------------------------
+// 核心逻辑：受物理攻击时触发（覆盖父类方法）
+// -----------------------------------------------------------
+func (e *EffectPhysicalAttackAddStatus) Damage_DIV_ex(t *info.DamageZone) bool {
+	// 1. 命中判定失败，不触发
+	if !e.Hit() {
+		return true
+	}
+
+	// 2. 技能为空或非物理攻击，不触发
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() != info.Category.PHYSICAL {
+		return true
+	}
+
+	// 3. 概率判定（Args()[1]为触发概率）
+	success, _, _ := e.Input.Player.Roll(e.Args()[1], 100)
+	if !success {
+		return true
+	}
+
+	// 4. 计算持续回合（默认2~3回合，支持通过参数指定）
+	duration := e.getDuration()
+
+	// 5. 获取状态效果实例并设置参数
+	statusEffect := input.Geteffect(input.EffectType.Status, int(e.targetStatus))
+	if statusEffect == nil {
+		return true
+	}
+	statusEffect.Duration(duration)
+	statusEffect.SetArgs(e.Ctx().Our) // 目标为对手
+
+	// 6. 给对手添加状态
+	e.Ctx().Opp.AddEffect(statusEffect)
+	return true
+}
+
+// 设置参数（复用父类逻辑）
+func (e *EffectPhysicalAttackAddStatus) SetArgs(t *input.Input, a ...int) {
+	e.EffectNode.SetArgs(t, a...)
+	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
+}
+
+// 计算持续回合（封装为独立方法，增强可读性）
+func (e *EffectPhysicalAttackAddStatus) getDuration() int {
+	// 优先使用配置的回合数（SideEffectArgs[1]）
+	if len(e.EffectNode.SideEffectArgs) > 1 {
+		return e.EffectNode.SideEffectArgs[1]
+	}
+	// 默认随机2~3回合（Int31n(2)返回0/1，+2后为2/3）
+	return int(e.Input.FightC.GetRand().Int31n(2)) + 2
+}

logic/service/fight/effect/effect_status.go

@@ -12,7 +12,7 @@ import (
 
 type BaseSataus struct {
 	node.EffectNode
-	Status info.EnumBattleStatus
+	Status info.EnumPetStatus
 }
 
 // /重写切换事件
@@ -107,7 +107,7 @@ func (e *DrainedHP) Skill_Hit_Pre(a, b *action.SelectSkillAction) bool {
 func init() {
 	//麻痹，疲惫，害怕，石化，都是无法行动
 
-	tt := func(t info.EnumBattleStatus, f *StatusNotSkill) {
+	tt := func(t info.EnumPetStatus, f *StatusNotSkill) {
 
 		f.Status = t
 		input.InitEffect(input.EffectType.Status, int(t), f)

logic/service/fight/info/info.go

@@ -125,31 +125,31 @@ type WeakenedS struct {
 
 // 定义战斗状态枚举
 var PetStatus = enum.New[struct {
-	Paralysis        EnumBattleStatus `enum:"0"`  // 麻痹
+	Paralysis        EnumPetStatus `enum:"0"`  // 麻痹
-	Poisoned         EnumBattleStatus `enum:"1"`  // 中毒
+	Poisoned         EnumPetStatus `enum:"1"`  // 中毒
-	Burned           EnumBattleStatus `enum:"2"`  // 烧伤
+	Burned           EnumPetStatus `enum:"2"`  // 烧伤
-	DrainHP          EnumBattleStatus `enum:"3"`  // 吸取对方的体力
+	DrainHP          EnumPetStatus `enum:"3"`  // 吸取对方的体力
-	DrainedHP        EnumBattleStatus `enum:"4"`  // 被对方吸取体力
+	DrainedHP        EnumPetStatus `enum:"4"`  // 被对方吸取体力
-	Frozen           EnumBattleStatus `enum:"5"`  // 冻伤
+	Frozen           EnumPetStatus `enum:"5"`  // 冻伤
-	Fear             EnumBattleStatus `enum:"6"`  // 害怕
+	Fear             EnumPetStatus `enum:"6"`  // 害怕
-	Tired            EnumBattleStatus `enum:"7"`  // 疲惫
+	Tired            EnumPetStatus `enum:"7"`  // 疲惫
-	Sleep            EnumBattleStatus `enum:"8"`  // 睡眠
+	Sleep            EnumPetStatus `enum:"8"`  // 睡眠
-	Petrified        EnumBattleStatus `enum:"9"`  // 石化
+	Petrified        EnumPetStatus `enum:"9"`  // 石化
-	Confused         EnumBattleStatus `enum:"10"` // 混乱
+	Confused         EnumPetStatus `enum:"10"` // 混乱
-	Weakened         EnumBattleStatus `enum:"11"` // 衰弱
+	Weakened         EnumPetStatus `enum:"11"` // 衰弱
-	MountainGodGuard EnumBattleStatus `enum:"12"` // 山神守护
+	MountainGodGuard EnumPetStatus `enum:"12"` // 山神守护
-	Flammable        EnumBattleStatus `enum:"13"` // 易燃
+	Flammable        EnumPetStatus `enum:"13"` // 易燃
-	Berserk          EnumBattleStatus `enum:"14"` // 狂暴
+	Berserk          EnumPetStatus `enum:"14"` // 狂暴
-	IceBound         EnumBattleStatus `enum:"15"` // 冰封
+	IceBound         EnumPetStatus `enum:"15"` // 冰封
-	Bleeding         EnumBattleStatus `enum:"16"` // 流血
+	Bleeding         EnumPetStatus `enum:"16"` // 流血
-	ImmuneToStatDrop EnumBattleStatus `enum:"17"` // 免疫能力下降
+	ImmuneToStatDrop EnumPetStatus `enum:"17"` // 免疫能力下降
-	ImmuneToAbnormal EnumBattleStatus `enum:"18"` // 免疫异常状态
+	ImmuneToAbnormal EnumPetStatus `enum:"18"` // 免疫异常状态
-	Paralyzed        EnumBattleStatus `enum:"19"` // 瘫痪
+	Paralyzed        EnumPetStatus `enum:"19"` // 瘫痪
 	// Blind             EnumBattleStatus `enum:"20"` // 失明（预留）
 }]()
 
 // 枚举类型别名（根据实际枚举库要求定义）
-type EnumBattleStatus = byte
+type EnumPetStatus = byte
 
 // 精灵的能力提升
 type PropDict struct {

logic/service/fight/input/fight.go

@@ -186,6 +186,7 @@ func (our *Input) Damage(in *Input, sub *info.DamageZone) {
 
 }
 
+// 攻击,防御,特供,特防,速度,命中
 // 施加方，类型，等级，操作类别，是否成功
 func (our *Input) SetProp(in *Input, prop, level int8, ptype info.EnumAbilityOpType) (ret bool) {
 	//in.Our = our                                          //设置属性的角色是我方

logic/service/fight/input/input.go

@@ -124,7 +124,7 @@ func (our *Input) GetPet(id uint32) (ii *info.BattlePetEntity, Reason info.Chang
 // 遍历状态数组，返回存在的状态中最高的倍率（无状态则返回1.0）
 func (our *Input) GetStatusBonus() float64 {
 	// 异常状态倍率映射表（状态索引 -> 倍率）
-	var statusBonuses = map[info.EnumBattleStatus]float64{
+	var statusBonuses = map[info.EnumPetStatus]float64{
 		info.PetStatus.Paralysis: 1.5,
 		info.PetStatus.Poisoned:  1.5,
 		info.PetStatus.Sleep:     2.0,
@@ -137,7 +137,7 @@ func (our *Input) GetStatusBonus() float64 {
 
 		// 检查状态是否存在（数组中值为1表示存在该状态）
 		if t != nil && t.Stack() > 0 {
-			if bonus, exists := statusBonuses[info.EnumBattleStatus(statusIdx)]; exists && bonus > maxBonus {
+			if bonus, exists := statusBonuses[info.EnumPetStatus(statusIdx)]; exists && bonus > maxBonus {
 				maxBonus = bonus
 			}
 		}