refactor(fight): 重构战斗系统效果和技能逻辑

- 移除了未使用的 Effect0 基类效果
- 优化了技能施放和效果执行的逻辑
- 调整了命中和闪避的计算方式
-

logic/service/fight/effect/base.go

@@ -0,0 +1,52 @@
+package effect
+
+import (
+	"blazing/common/utils"
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// 施加一个基类effect
+type Effect0 struct {
+	node.EffectNode
+}
+
+// 技能命中计算
+func (this *Effect0) IsHit(attacker, defender *input.Input, skill *info.BattleSkillEntity) {
+	skill.AttackTimeC() //计算命中
+}
+
+func (this *Effect0) UseSkill(attacker, defender *input.Input) bool {
+	return true
+}
+func (this *Effect0) IsCrit(attacker, defender *input.Input, skill *info.BattleSkillEntity) {
+	CritRate := utils.Max(skill.CritRate, 1)
+	CritRateR := attacker.FightC.GetRand().Int31n(16)
+	//CritAtkFirst: 先出手时必定致命一击; 默认: 0
+	if skill.CritAtkFirst != 0 && attacker.First {
+		CritRate = 16
+	}
+	//CritAtkSecond: 后出手时必定致命一击; 默认: 0
+	if skill.CritAtkSecond != 0 && !attacker.First {
+		CritRate = 16
+	}
+	// CritSelfHalfHp: 自身体力低于一半时必定致命一击; 默认: 0
+	if skill.CritSelfHalfHp != 0 && (attacker.CurrentPet.HP < int(attacker.CurrentPet.Info.MaxHp)/2) {
+		CritRate = 16
+	}
+	//  CritFoeHalfHp: 对方体力低于一半时必定致命一击; 默认: 0
+	if skill.CritSelfHalfHp != 0 && (defender.CurrentPet.HP < int(defender.CurrentPet.Info.MaxHp)/2) {
+		CritRate = 16
+	}
+
+	//todo 暴击伤害
+	if CritRateR <= int32(CritRate) {
+		skill.Crit = 1
+	}
+
+}
+func init() {
+	input.InitEffect(0, &Effect0{})
+
+}

logic/service/fight/effect/effect_0.go

@@ -1,16 +0,0 @@
-package effect
-
-import (
-	"blazing/logic/service/fight/input"
-	"blazing/logic/service/fight/node"
-)
-
-// 施加一个基类effect
-type Effect0 struct {
-	node.EffectNode
-}
-
-func init() {
-	input.InitEffect(0, &Effect0{})
-
-}

logic/service/fight/fightc.go

@@ -363,18 +363,15 @@ func (f *FightC) parseskill(attacker, defender *input.Input, id *SelectSkillActi
 		if ok { //获取成功
 
 			args := t.GetArgSize()
-			t.SetArgs(temparg[:args]) //设置入参
+			eff := deepcopy.Copy(t).(input.Effect)
-			// //如果不是是房主方,说明施加的对象是反的,比如本来是false,实际上是给邀请方施加的
+			eff.SetArgs(temparg[:args]) //设置入参
-			// //所以这里要对target取反
+
-			// if id.GetPlayerID() != f.ownerID {
-			// 	t.SetOwner(!t.GetOwner())
-			// }
 			temparg = temparg[args:]
 			if t.GetOwner() { //如果取反,说明是给对方添加的回合效果
 				//实际上,owner永远为反,说明是对方给我添加的
-				defender.Effect.AddEffect(deepcopy.Copy(t).(input.Effect))
+				defender.Effect.AddEffect(eff)
 			} else {
-				attacker.Effect.AddEffect(deepcopy.Copy(t).(input.Effect))
+				attacker.Effect.AddEffect(eff)
 			}
 
 		}
@@ -412,22 +409,24 @@ func (f *FightC) processSkillAttack(attacker, defender *input.Input, skill *Sele
 
 	attacker.Effect.Exec(func(t input.Effect) bool { //计算命中
 
-		attacker.AttackValue.AttackTime = t.IsHit(attacker, defender, skill.Skill)
+		t.IsHit(attacker, defender, skill.Skill) //相当于先调整基础命中
+
 		return attacker.AttackTime == 0 //等于0,继续处理
 	})
-	defender.Effect.Exec(func(t input.Effect) bool { //计算命中
+	defender.Effect.Exec(func(t input.Effect) bool { //计算闪避
-
+		t.TakeHit(attacker, defender, skill.Skill)
-		attacker.AttackValue.AttackTime = t.TakeHit(attacker, defender, skill.Skill)
 
 		return attacker.AttackTime > 0 //
 	})
+	attacker.AttackValue.AttackTime = skill.Skill.AttackTime
 	if attacker.AttackValue.AttackTime > 0 { //如果命中
 
 		spower := skill.Skill.CalculatePower(defender.CurrentPet)
 		attacker.Damage = spower
 		attacker.Effect.Exec(func(t input.Effect) bool { //计算暴击率加成
 
-			attacker.AttackValue.IsCritical = t.IsCrit(attacker, defender, skill.Skill)
+			t.IsCrit(attacker, defender, skill.Skill)
+			attacker.AttackValue.IsCritical = skill.Skill.Crit
 			return attacker.AttackValue.IsCritical == 0
 		})
 		if attacker.AttackValue.IsCritical == 1 {

logic/service/fight/info/BattleSkillEntity.go

@@ -42,8 +42,8 @@ type BattleSkillEntity struct {
 	DamageValue decimal.Decimal // 伤害值
 	Rand        *rand.Rand
 	Pet         *BattlePetEntity
-
+	Crit        uint32
-	Hit uint32
+	AttackTime  uint32
 }
 
 // CreateBattleSkillWithInfinity 创建战斗技能实例（可指定是否无限PP）
@@ -164,16 +164,15 @@ var DamageC = enum.New[struct {
 // }
 
 // 计算是否命中
-func (s *BattleSkillEntity) AttackTime() uint32 {
+func (s *BattleSkillEntity) AttackTimeC() {
-	s.Hit = 0 //先重置上一次的
+	s.AttackTime = 0 //先重置上一次的
 	if s.MustHit != 0 {
-		s.Hit = 2
+		s.AttackTime = 2
 	}
 
 	if int64(s.Pet.Accuracy(int64(s.Accuracy))) > s.Rand.Int63n(100) {
-		s.Hit = 1
+		s.AttackTime = 1
 	}
-	return s.Hit
 
 }
 func (s *BattleSkillEntity) CriticalsameTypeBonus() decimal.Decimal {

logic/service/fight/input/input.go

@@ -18,14 +18,17 @@ type Input struct {
 	*info.AttackValue
 	FightC common.FightI
 	//	info.BattleActionI
-	Effect NodeManager     //effects容器OurEffect  node.NodeManager   //effects容器
+	Effect   NodeManager     //effects容器 技能的
-	Damage decimal.Decimal //造成伤害
+	Prop     NodeManager     //属性容器
-	First  bool
+	Status   NodeManager     //状态容器
+	NewSeIdx NodeManager     //全局容器
+	Damage   decimal.Decimal //造成伤害
+	First    bool            //是否先手
 }
 
 func NewInput(c common.FightI, p common.PlayerI) *Input {
 	ret := &Input{FightC: c, Player: p}
-	t, _ := NodeM[0]
+	t := NodeM[0]
 	ret.Effect.AddEffect(deepcopy.Copy(t).(Effect)) //添加默认基类,实现继承
 	p.SetFightC(c)                                  //给玩家设置战斗容器
 	return ret

logic/service/fight/input/nodemanger.go

@@ -20,12 +20,12 @@ type Effect interface {
 	// OnDamage() bool                // 造成伤害时触发
 	//使用技能 可以取消用技能节点
 	SetArgs(param []int)
-	IsCrit(attacker, defender *Input, skill *info.BattleSkillEntity) uint32   //是否暴击
+	IsCrit(attacker, defender *Input, skill *info.BattleSkillEntity)          //是否暴击
 	CalculateDamage(attacker, defender *Input, skill *info.BattleSkillEntity) //击判定成功且伤害计算前触发
 	// Shield() bool                                                             // 护盾值变化时触发
 	// PostDamage() bool                                                         // 伤害结算后触发（血量扣除后）
-	IsHit(attacker, defender *Input, skill *info.BattleSkillEntity) uint32   //闪避率计算,,实际上是修改命中的判断
+	IsHit(attacker, defender *Input, skill *info.BattleSkillEntity)   //闪避率计算,,实际上是修改命中的判断
-	TakeHit(attacker, defender *Input, skill *info.BattleSkillEntity) uint32 //闪避率计算,,实际上是修改命中的判断
+	TakeHit(attacker, defender *Input, skill *info.BattleSkillEntity) //闪避率计算,,实际上是修改命中的判断
 	//() bool                                                  // 暴击伤害结算后触发
 
 	// OnHit() bool         // 技能命中时触发

logic/service/fight/node/attack.go

@@ -1,20 +1,18 @@
 package node
 
 import (
-	"blazing/common/utils"
 	"blazing/logic/service/fight/info"
 	"blazing/logic/service/fight/input"
 )
 
 // 技能命中计算
-func (this *EffectNode) IsHit(attacker, defender *input.Input, skill *info.BattleSkillEntity) uint32 {
+func (this *EffectNode) IsHit(attacker, defender *input.Input, skill *info.BattleSkillEntity) {
-	return skill.AttackTime() //计算命中
+
 }
 
 // 被命中计算,默认直接返回,重写这个来实现闪避率
-func (this *EffectNode) TakeHit(attacker, defender *input.Input, skill *info.BattleSkillEntity) uint32 {
+func (this *EffectNode) TakeHit(attacker, defender *input.Input, skill *info.BattleSkillEntity) {
 
-	return skill.Hit
 }
 
 func (this *EffectNode) UseSkill(attacker, defender *input.Input) bool {
@@ -59,32 +57,9 @@ func (this *EffectNode) PostDamage() bool {
 	panic("not implemented") // TODO: Implement
 }
 
-func (this *EffectNode) IsCrit(attacker, defender *input.Input, skill *info.BattleSkillEntity) uint32 {
+// 正常来说,什么都不做
-	CritRate := utils.Max(skill.CritRate, 1)
+func (this *EffectNode) IsCrit(attacker, defender *input.Input, skill *info.BattleSkillEntity) {
-	CritRateR := attacker.FightC.GetRand().Int31n(16)
+	//return skill.Crit
-	//CritAtkFirst: 先出手时必定致命一击; 默认: 0
-	if skill.CritAtkFirst != 0 && attacker.First {
-		CritRate = 16
-	}
-	//CritAtkSecond: 后出手时必定致命一击; 默认: 0
-	if skill.CritAtkSecond != 0 && !attacker.First {
-		CritRate = 16
-	}
-	// CritSelfHalfHp: 自身体力低于一半时必定致命一击; 默认: 0
-	if skill.CritSelfHalfHp != 0 && (attacker.CurrentPet.HP < int(attacker.CurrentPet.Info.MaxHp)/2) {
-		CritRate = 16
-	}
-	//  CritFoeHalfHp: 对方体力低于一半时必定致命一击; 默认: 0
-	if skill.CritSelfHalfHp != 0 && (defender.CurrentPet.HP < int(defender.CurrentPet.Info.MaxHp)/2) {
-		CritRate = 16
-	}
-
-	//todo 暴击伤害
-	if CritRateR <= int32(CritRate) {
-		return 1
-	}
-
-	return 0
 }
 
 func (this *EffectNode) OnHit() bool {