bl/logic/service/fight/input/input.go

package input

import (
	"blazing/common/data/xmlres"
	"blazing/logic/service/common"
	"blazing/logic/service/fight/action"
	"blazing/logic/service/fight/info"

	"github.com/jinzhu/copier"
	"github.com/shopspring/decimal"
)

type Input struct {
	CanChange  bool                  //是否可以死亡切换CanChange
	CurrentPet *info.BattlePetEntity //当前精灵
	AllPet     []*info.BattlePetEntity
	Player     common.PlayerI

	Finished bool //是否加载完成
	*info.AttackValue
	FightC common.FightI
	//	info.BattleActionI
	Effects     []Effect //effects 实际上全局就是effect无限回合 //effects容器 技能的
	EffectCache []Effect //这里是命中前执行的容器,也就是命中前执行的所有逻辑相关,理论上一个effect被激活,就应该同时将其他的effect取消激活
	//NewEffects  []Effect

	DamageZone struct {
		Damage       decimal.Decimal //伤害
		BeforeADD    decimal.Decimal //攻击伤害
		BeforeMul    decimal.Decimal
		BeforeFloor  decimal.Decimal
		BeforeDiv    decimal.Decimal
		BeforeSUB    decimal.Decimal
		BeforeLock   decimal.Decimal //锁伤 先锁受击方，再锁攻击方 受击方免疫也是这么锁  免疫等于锁0
		BeforeLocked decimal.Decimal
		//BeforePost decimal.Decimal

		//OldAttack  int //攻击伤害被挡前伤害记录
	} //伤害容器
	//First bool //是否先手
}

func NewInput(c common.FightI, p common.PlayerI) *Input {
	ret := &Input{FightC: c, Player: p}
	ret.Effects = make([]Effect, 0)

	// t := Geteffect(EffectType.Damage, 0)
	// t.Effect.SetArgs(ret)
	// ret.AddEffect(t) //添加默认基类,实现继承
	p.SetFightC(c) //给玩家设置战斗容器

	return ret

}
func (i *Input) GetPetInfo() *info.BattlePetEntity {

	return i.CurrentPet

}
func (input *Input) GenSataus() {

	for i := 0; i < 20; i++ { //堆叠状态剩余回合

		t := input.GetEffect(EffectType.Status, i)

		if t != nil && t.Alive() { //状态都是叠层类的

			input.Status[i] = int8(t.Duration())

		}

	}

}
func (input *Input) GenInfo() {

	input.RemainHp = int32(input.CurrentPet.Info.Hp)
	input.SkillList = input.CurrentPet.Info.SkillList

	// f.Second.SkillList = f.Second.CurrentPet.Info.SkillList
	// f.Second.RemainHp = int32(f.Second.CurrentPet.Info.Hp)
	// ret.FAttack = *f.First.AttackValue
	// ret.SAttack = *f.Second.AttackValue

}
func (i *Input) ResetAttackValue() {
	i.AttackValue.SkillID = 0
	i.AttackValue.IsCritical = 0
	i.AttackValue.GainHp = 0
	i.AttackValue.LostHp = 0

}

// 这个每回合都会调用
func (i *Input) InitAttackValue() {
	i.AttackValue = info.NewAttackValue(i.Player.GetInfo().UserID)

}
func (i *Input) GetPet(id uint32) (ii *info.BattlePetEntity, Reason info.ChangePetInfo) {
	for _, v := range i.AllPet {
		if v.Info.CatchTime == uint32(id) {
			copier.Copy(&Reason, &v.Info)
			Reason.UserId = i.Player.GetInfo().UserID

			ii = v
		}

	}
	return

}

// GetStatusBonus 获取最高的状态倍率
// 遍历状态数组，返回存在的状态中最高的倍率（无状态则返回1.0）
func (i *Input) GetStatusBonus() float64 {
	// 异常状态倍率映射表（状态索引 -> 倍率）
	var statusBonuses = map[info.EnumBattleStatus]float64{
		info.PetStatus.Paralysis: 1.5,
		info.PetStatus.Poisoned:  1.5,
		info.PetStatus.Sleep:     2.0,
		// /info.BattleStatus.Frozen:    2.0,
	}
	maxBonus := 1.0 // 默认无状态倍率

	for statusIdx := 0; statusIdx < 20; statusIdx++ {
		t := Geteffect(EffectType.Status, statusIdx)

		// 检查状态是否存在（数组中值为1表示存在该状态）
		if t != nil && t.Stack() > 0 {
			if bonus, exists := statusBonuses[info.EnumBattleStatus(statusIdx)]; exists && bonus > maxBonus {
				maxBonus = bonus
			}
		}
	}

	return maxBonus
}

func (i *Input) initeffectcache() {
	i.EffectCache = make([]Effect, 0) //先把上一回合数据清空,但是应该把本身延续类效果集成过来

	for _, v := range i.Effects {

		if v.Alive() { //说明存活效果而且是延续类效果,将之添加到初始化列表中

			//这里添加的效果是已经生效的效果对effect的复制,相当于技能施的效果的前置比如改命中的效果等
			i.EffectCache = append(i.EffectCache, v)

		}

	}

}

// 解析并 施加effect
func (i *Input) Parseskill(defender *Input, skill *action.SelectSkillAction) {
	i.initeffectcache() //这里说明是延续的效果,每次复制出来一个新的就好了
	//i.NewEffects = make([]Effect, 0) //这里说明是新增的效果
	temparg := skill.SideEffectArgS

	for _, v := range skill.SideEffectS {

		t := Geteffect(EffectType.Skill, v)

		args := xmlres.EffectArgs[v]
		//这里是给双方添加buff
		if t != nil {
			t.SetArgs(i, temparg[:args]...) //设置入参,施加方永远是我方

			// if t.Owner() { //如果取反,说明是给对方添加的回合效果
			// 	//实际上,owner永远为反,说明是对方给我添加的
			// 	t.SetArgs(i, temparg[:args]...) //设置入参,施加方永远是我方
			// 	//给双方添加
			// 	defender.AddEffect(t)
			// } else {
			//t.SetArgs(i, temparg[:args]...) //设置入参
			//i.AddEffect(t)
			//	}
			//这里是临时缓存buff,后面确认命中后修改HIT状态
			//	t.Alive() //先让效果保持存活
			i.EffectCache = append(i.EffectCache, t)
			//	i.NewEffects = append(i.NewEffects, t)
		}

		temparg = temparg[args:]
	}

}