bl/logic/service/fight/effect/effect_attr.go

package effect

import (
	"blazing/logic/service/fight/info"
	"blazing/logic/service/fight/input"
	"blazing/logic/service/fight/node"
)

// -----------------------------------------------------------
// 通用效果：属性同步/反转类效果（45/51/55/56）
// -----------------------------------------------------------

// 操作类型定义：区分不同的属性操作
type propOpType int

const (
	opDefenseSync propOpType = iota // 同步防御力（45）
	opAttackSync                    // 同步攻击力（51）
	opTypeReverse                   // 反转属性类型（55）
	opTypeSync                      // 同步属性类型（56）
)

// 效果上下文：存储属性修改前的原始值（用于还原）
type propOpContext struct {
	oldOurProp uint32 // 我方原始属性值（45/51）
	oldOurType int    // 我方原始类型值（56）
	oldOppType int    // 对方原始类型值（55）
	propIndex  int    // 属性索引（0=攻击，1=防御）
	opType     propOpType
}

// 全局映射：关联效果ID与对应的操作配置
var propOpMap = make(map[int]func() propOpContext)

// EffectPropSyncReverse：属性同步/反转效果核心结构体
type EffectPropSyncReverse struct {
	node.EffectNode
	ctx     propOpContext // 操作上下文（存储原始值）
	bindpet *info.BattlePetEntity
}

// 工厂函数：创建属性同步/反转效果实例
func newEffectPropSyncReverse() *EffectPropSyncReverse {
	return &EffectPropSyncReverse{}
}

// 初始化：批量注册所有属性同步/反转类效果
func init() {
	registerPropSyncReverseEffects()
}

// 批量注册：绑定效果ID与对应的操作配置
func registerPropSyncReverseEffects() {
	// 效果ID与操作配置的映射
	effectMap := map[int]func() propOpContext{
		45: func() propOpContext { // n回合防御力和对手相同
			return propOpContext{opType: opDefenseSync, propIndex: 1}
		},
		51: func() propOpContext { // n回合攻击力和对手相同
			return propOpContext{opType: opAttackSync, propIndex: 0}
		},
		55: func() propOpContext { // n回合反转属性类型
			return propOpContext{opType: opTypeReverse}
		},
		56: func() propOpContext { // n回合同步属性类型
			return propOpContext{opType: opTypeSync}
		},
	}

	// 注册到全局映射，并初始化效果
	for effectID, ctxFunc := range effectMap {
		propOpMap[effectID] = ctxFunc
		input.InitEffect(input.EffectType.Skill, effectID, newEffectPropSyncReverse())
	}
}

// SetArgs：设置效果参数（回合数）
func (e *EffectPropSyncReverse) SetArgs(t *input.Input, a ...int) {
	e.EffectNode.SetArgs(t, a...)
	// 从SideEffectArgs[0]获取持续回合数
	e.EffectNode.Duration(e.EffectNode.SideEffectArgs[0])
	// 初始化操作上下文
	e.ctx = propOpMap[int(e.ID().Suffix())]()
}
func (e *EffectPropSyncReverse) OnSkill() bool {

	if !e.Hit() {
		return true
	}
	if e.bindpet != nil {
		return true
	}
	ourPet := e.Ctx().Our.CurrentPet
	oppPet := e.Ctx().Opp.CurrentPet
	switch e.ctx.opType {
	case opDefenseSync, opAttackSync:
		// 同步攻防属性：保存我方原始值，覆盖为对方值
		e.ctx.oldOurProp = ourPet.Info.Prop[e.ctx.propIndex]
		ourPet.Info.Prop[e.ctx.propIndex] = oppPet.Info.Prop[e.ctx.propIndex]

	case opTypeReverse:
		// 反转属性类型：保存双方原始值，交换类型
		e.ctx.oldOurType = ourPet.PetInfo.Type
		e.ctx.oldOppType = oppPet.PetInfo.Type
		ourPet.PetInfo.Type, oppPet.PetInfo.Type = oppPet.PetInfo.Type, ourPet.PetInfo.Type

	case opTypeSync:
		// 同步属性类型：保存我方原始值，覆盖为对方值
		e.ctx.oldOurType = ourPet.PetInfo.Type
		ourPet.PetInfo.Type = oppPet.PetInfo.Type
	}

	//绑定对方精灵
	e.bindpet = e.Ctx().Opp.CurrentPet
	return true
}

// Alive：效果存活判定（结束时还原属性）
func (e *EffectPropSyncReverse) Alive(t ...bool) bool {
	if !e.Hit() {
		return true
	}

	if e.BoolisFalse(t...) {
		ourPet := e.Ctx().Our.CurrentPet

		oppPet := e.bindpet
		switch e.ctx.opType {
		case opDefenseSync, opAttackSync:
			// 还原攻防属性
			ourPet.Info.Prop[e.ctx.propIndex] = e.ctx.oldOurProp

		case opTypeReverse:
			// 还原反转的属性类型（恢复双方原始值）
			ourPet.PetInfo.Type = e.ctx.oldOurType
			oppPet.PetInfo.Type = e.ctx.oldOppType

		case opTypeSync:
			// 还原同步的属性类型
			ourPet.PetInfo.Type = e.ctx.oldOurType
		}
	}

	return e.EffectNode.Alive(t...)

}