Files
bl/logic/service/fight/input/fight.go
昔念 a86782b1ea ```text
refactor(fight): 重构战斗准备逻辑并优化战斗启动流程

将 ReadyFight 方法拆分为多个职责清晰的子方法:
- buildFightStartInfo: 构建战斗初始信息
- checkBothPlayersReady: 检查PVP双方是否就绪
- handleNPCFightSpecial: 处理NPC战斗特殊逻辑(如可捕捉标记)
- startBattle: 统一启动战斗流程

同时修复部分逻辑顺序问题,增强代码可读性和扩展性。

feat(fight): 新增精灵王挑战协议支持

增加 StartPetWarInboundInfo 结构体用于接收精灵王挑战请求,
为后续实现相关功能提供基础。

fix(effect): 修正多个技能效果数值引用错误

- effect_37: 技能威力计算使用正确参数索引
- effect_50: 固定减伤比例调整为除以2
- effect_65: 正确比较技能分类类型
- effect_68: 致死保护改为锁定剩余1点生命值
- effect_77: 回复目标由敌方改为己方
- effect_93: 固定伤害值直接取参数

refactor(effect): 移除冗余效果类文件

删除 effect_133.go 和 effect_90.go 文件,其功能已被统一条件伤害和倍率系统取代;
移除 effect_74.go、effect_75.go 中重复的状态随机施加逻辑。

refactor(effect): 更新能力操作枚举命名一致性

重命名 AbilityOpType 枚举项名称,去除前缀,提升语义清晰度:
- AbilityOpStealStrengthen → StealStrengthen
- AbilityOpReverse → Reverse
- AbilityOpBounceWeaken → BounceWeaken

chore(fight): 完善 BattlePetEntity 属性初始化逻辑

在创建 BattlePetEntity 时即设置 PType,避免后续多次查询 PetMAP;
移除 Type() 方法中的冗余配置查找逻辑。

fix(skill): 确保必中技能不参与命中率计算

在 AttackTimeC 方法中添加 return 防止必中技能继续执行命中率公式计算。

refactor(fight): 调整战斗回合结束逻辑

进入新回合时允许玩家更换精灵,并提前跳出循环防止多余处理。

style(effect): 更正拼写及变量命名风格

修改 BaseSataus.Switch 方法签名中的参数命名;
更正 Effect58 中 can 字段首字母大写;
2025-11-14 23:09:16 +08:00

340 lines
9.0 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package input
import (
element "blazing/common/data/Element"
"blazing/common/data/xmlres"
"blazing/common/utils"
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"math/rand"
"github.com/shopspring/decimal"
)
// 计算暴击
func (our *Input) CalculateCrit(opp *Input, skill *info.SkillEntity) {
skill.Crit = 0
if skill.Category() == info.Category.STATUS { //属性技能不用算暴击
return
}
CritRate := utils.Max(skill.CritRate, 1)
//CritAtkFirst: 先出手时必定致命一击; 默认: 0
if skill.CritAtkFirst != 0 && our.FightC.IsFirst(our.Player) {
CritRate = 16
}
//CritAtkSecond: 后出手时必定致命一击; 默认: 0
if skill.CritAtkSecond != 0 && !our.FightC.IsFirst(our.Player) {
CritRate = 16
}
// CritSelfHalfHp: 自身体力低于一半时必定致命一击; 默认: 0
if skill.CritSelfHalfHp != 0 && (our.CurrentPet.HP < int(our.CurrentPet.Info.MaxHp)/2) {
CritRate = 16
}
// CritFoeHalfHp: 对方体力低于一半时必定致命一击; 默认: 0
if skill.CritSelfHalfHp != 0 && (opp.CurrentPet.HP < int(opp.CurrentPet.Info.MaxHp)/2) {
CritRate = 16
}
//todo 暴击伤害
if t, _, _ := our.Player.Roll(625*CritRate, 10000); t {
skill.Crit = 1
}
}
// 恢复血量
func (our *Input) Heal(in *Input, ac action.BattleActionI, value decimal.Decimal) {
//使用道具回血
if _, ok := ac.(*action.UseItemAction); !ok &&
ac != nil &&
in == our {
our.AttackValue.GainHp = int32(value.IntPart()) //道具有专门的回血包
}
if value.IsPositive() {
our.CurrentPet.Info.Hp += uint32(value.IntPart())
our.CurrentPet.Info.Hp = utils.Min(our.CurrentPet.Info.Hp, our.CurrentPet.Info.MaxHp)
} else {
if uint32(value.Abs().IntPart()) > our.CurrentPet.Info.Hp {
our.CurrentPet.Info.Hp = 0
} else {
our.CurrentPet.Info.Hp += uint32(value.IntPart())
}
}
}
func (our *Input) HealPP(value int) {
for i := 0; i < len(our.CurrentPet.Info.SkillList); i++ {
our.CurrentPet.Info.SkillList[i].PP += uint32(value)
our.CurrentPet.Info.SkillList[i].PP = utils.Min(our.CurrentPet.Info.SkillList[i].PP, uint32(xmlres.SkillMap[int(our.CurrentPet.Info.SkillList[i].ID)].MaxPP))
}
}
func (our *Input) DelPP(value int) {
for i := 0; i < len(our.CurrentPet.Info.SkillList); i++ {
if uint32(value) > our.CurrentPet.Info.SkillList[i].PP {
our.CurrentPet.Info.SkillList[i].PP = 0
} else {
our.CurrentPet.Info.SkillList[i].PP -= uint32(value)
}
}
}
// /红伤只允许调用一次来保持锁伤
// 这个方法是对对方造成伤害
// 伤害落实 // 血量扣减节点比如触发回神,反弹也在这里实现
func (our *Input) Damage(in *Input, sub *info.DamageZone) {
if sub.Type == info.DamageType.Red { //每回合计算伤害的时候重置伤害
our.Opp.DamageZone.Damage = sub.Damage
}
// 对方对我方造成,需要吃到对方的加成
var ok bool
if our != in {
ok = our.Opp.Exec(func(t Effect) bool {
t.Damage_ADD(sub) //红伤落实前,我方增伤
return true
})
//sub.BeforeMul = sub.Damage
if ok {
ok = our.Opp.Exec(func(t Effect) bool {
t.Damage_Mul(sub) //红伤落实前,我方增伤
return true
})
}
//sub.BeforeFloor = sub.Damage
if ok {
ok = our.Opp.Exec(func(t Effect) bool {
t.Damage_Floor(sub) //红伤落实,内部有befer
return true
})
}
}
// sub.BeforeMul = sub.Damage
if ok {
ok = our.Exec(func(t Effect) bool {
t.Damage_DIV_ex(sub) //红伤落实,内部有befer
return true
})
}
//sub.BeforeSUB = sub.Damage
if ok {
ok = our.Exec(func(t Effect) bool {
t.Damage_SUB_ex(sub)
return true
})
}
// sub.BeforeLock = sub.Damage
if ok && in != our {
ok = our.Opp.Exec(func(t Effect) bool {
t.Damage_Lock(sub)
return true
})
}
//sub.BeforeLocked = sub.Damage
if ok {
our.Exec(func(t Effect) bool {
t.Damage_Lock_ex(sub)
return true
})
}
if sub.Type == info.DamageType.Red { //红才会产生造成伤害
our.Opp.DamageZone.Damage = sub.Damage // 叠加总伤害 这里相当于记录红伤
our.Opp.AttackValue.LostHp = uint32(our.Opp.DamageZone.Damage.IntPart()) //红伤落实
}
if uint32(sub.Damage.IntPart()) > our.CurrentPet.Info.Hp {
our.CurrentPet.Info.Hp = 0
} else {
our.CurrentPet.Info.Hp = our.CurrentPet.Info.Hp - uint32(sub.Damage.IntPart())
}
//todo 待实现死亡effet
}
func (our *Input) GetAction(opp *Input) {
// 获取己方当前宠物和对方当前宠物
selfPet := our.FightC.GetCurrPET(our.Player)
//没血就切换精灵
if selfPet.Info.Hp <= 0 {
for _, v := range our.AllPet {
if v.Info.Hp > 0 {
our.FightC.ChangePet(our.Player, v.Info.CatchTime)
return
}
}
}
//oppPet := opp.FightC.GetCurrPET(opp.Player)
skills := selfPet.Skills
// 空技能列表直接返回,避免错误
if len(skills) == 0 {
return
}
// 步骤1计算所有技能的伤害并筛选出能秒杀对方的技能
var killableSkills []struct {
*info.SkillEntity // 技能对象假设原技能类型为skill
damage decimal.Decimal // 技能实际伤害
}
// 存储所有技能及伤害(用于后续筛选)
type skillWithDamage struct {
*info.SkillEntity
damage decimal.Decimal
}
allSkills := make([]skillWithDamage, 0, len(skills))
for _, s := range skills {
if s == nil {
continue
}
// 计算技能对对方的伤害假设CalculatePower返回伤害值或需从技能中获取
damage := our.CalculatePower(opp, s)
if !s.CanUse() {
continue
}
allSkills = append(allSkills, skillWithDamage{SkillEntity: s, damage: damage})
// 判断是否能秒杀(伤害 >= 对方当前生命值)
if uint32(damage.IntPart()) >= opp.CurrentPet.Info.Hp { // 假设oppPet.HP为对方当前剩余生命值
killableSkills = append(killableSkills, struct {
*info.SkillEntity
damage decimal.Decimal
}{s, damage})
}
}
// 若存在能秒杀的技能,优先使用(选权重最高的,避免浪费高伤害技能)
if len(killableSkills) > 0 {
bestKillSkill := killableSkills[0].SkillEntity
// maxWeight := killableSkills[0].SkillEntity.Weight // 假设技能有Weight字段表示权重
// for _, ks := range killableSkills[1:] {
// if ks.skill.Weight > maxWeight {
// maxWeight = ks.skill.Weight
// bestKillSkill = ks.skill
// }
// }
our.FightC.UseSkill(our.Player, int32(bestKillSkill.ID))
return
}
randomIdx := rand.Intn(len(allSkills))
chosenSkill := skills[randomIdx]
our.FightC.UseSkill(our.Player, int32(chosenSkill.ID))
// i.FightC.UseSkill(i.Player, int32(bestSkill.skill.ID))
}
// 计算技能威力
func (our *Input) CalculatePower(deftype *Input, skill *info.SkillEntity) decimal.Decimal {
// 1. 计算等级因子 (level * 0.4 + 2)
levelFactor := decimal.NewFromInt(int64(our.CurrentPet.Info.Level)).
Mul(decimal.NewFromFloat(0.4)).Add(decimal.NewFromInt(2))
var (
attackDec decimal.Decimal //攻击值
defenseDec decimal.Decimal //防御值
)
switch skill.Category() { //判断技能类型
case info.Category.PHYSICAL:
attackDec = decimal.NewFromInt(int64(our.GetProp(0, false)))
defenseDec = decimal.NewFromInt(int64(deftype.GetProp(1, false)))
case info.Category.SPECIAL:
attackDec = decimal.NewFromInt(int64(our.GetProp(2, false)))
defenseDec = decimal.NewFromInt(int64(deftype.GetProp(3, false)))
default:
return decimal.NewFromInt(0)
}
// 5. 基础伤害公式:等级因子 * 威力因子 * 攻击 / 防御 / 50 + 2
baseDamage := levelFactor.
Mul(decimal.NewFromInt(int64(skill.Power))).
Mul(attackDec).
Div(defenseDec).
Div(decimal.NewFromInt(50)).
Add(decimal.NewFromInt(2))
var typeRate decimal.Decimal
//fmt.Println(skill.Type().ID, deftype.CurrentPet.Type().ID)
t, _ := element.Calculator.GetOffensiveMultiplier(skill.Type().ID, deftype.CurrentPet.Type().ID)
typeRate = decimal.NewFromFloat(t)
// 8. DmgBindLv: 使对方受到的伤害值等于等级; 默认: 0
// 9. PwrBindDv: 1,威力power取决于潜力个体值*5; 2,威力power取决于最大体力*1/3+潜力(个体值); 默认: 0
// 10. PwrDouble: 攻击时,若对方处于异常状态, 则威力翻倍;
// 11. DmgBindHpDv: 造成的伤害等于自身剩余体力*1/2+潜力(个体值); 默认: 0
if skill.DmgBindLv != 0 {
baseDamage = decimal.NewFromInt(int64(deftype.CurrentPet.Info.Level))
}
if skill.PwrBindDv != 0 {
if skill.PwrBindDv == 1 {
baseDamage = decimal.NewFromInt(int64(our.CurrentPet.Info.Dv * 5))
}
if skill.PwrBindDv == 2 {
baseDamage = decimal.NewFromInt(int64(our.CurrentPet.Info.Hp/3 + our.CurrentPet.Info.Dv))
}
}
if skill.PwrDouble != 0 {
if deftype.StatEffect_Exist_all() {
baseDamage = baseDamage.Mul(decimal.NewFromInt(2))
}
}
if skill.DmgBindHpDv != 0 {
baseDamage = decimal.NewFromInt(int64(our.CurrentPet.Info.Hp/2 + our.CurrentPet.Info.Dv))
}
damage := baseDamage.
Mul(skill.CriticalsameTypeBonus()). // 同属性加成
Mul(typeRate). // 克制系数
Mul(skill.Criticalrandom()) //随机波动
return damage
}