328 lines
7.8 KiB
Go
328 lines
7.8 KiB
Go
package input
|
|
|
|
import (
|
|
element "blazing/common/data/Element"
|
|
"blazing/common/utils"
|
|
"blazing/logic/service/fight/action"
|
|
"blazing/logic/service/fight/info"
|
|
"fmt"
|
|
|
|
"github.com/shopspring/decimal"
|
|
)
|
|
|
|
func (u *Input) UseSkill(opp *Input, skill *action.SelectSkillAction) {
|
|
|
|
skill.Crit = 0
|
|
if skill.Category() == info.Category.STATUS { //属性技能不用算暴击
|
|
return
|
|
}
|
|
CritRate := utils.Max(skill.CritRate, 1)
|
|
|
|
//CritAtkFirst: 先出手时必定致命一击; 默认: 0
|
|
if skill.CritAtkFirst != 0 && u.FightC.IsFirst(u.Player) {
|
|
CritRate = 16
|
|
}
|
|
//CritAtkSecond: 后出手时必定致命一击; 默认: 0
|
|
if skill.CritAtkSecond != 0 && !u.FightC.IsFirst(u.Player) {
|
|
CritRate = 16
|
|
}
|
|
// CritSelfHalfHp: 自身体力低于一半时必定致命一击; 默认: 0
|
|
if skill.CritSelfHalfHp != 0 && (u.CurrentPet.HP < int(u.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, _, _ := u.Player.Roll(625*CritRate, 10000); t {
|
|
skill.Crit = 1
|
|
}
|
|
|
|
}
|
|
|
|
// 恢复血量
|
|
func (u *Input) Heal(ac action.BattleActionI, value decimal.Decimal) {
|
|
|
|
u.CurrentPet.Info.Hp += uint32(value.IntPart())
|
|
u.CurrentPet.Info.Hp = utils.Min(u.CurrentPet.Info.Hp, u.CurrentPet.Info.MaxHp)
|
|
}
|
|
|
|
// 伤害落实 // 血量扣减节点比如触发回神，反弹也在这里实现
|
|
func (u *Input) Damage(ctx Ctx) {
|
|
ctx.Input.DamageZone.BeforeADD = ctx.DamageZone.Damage
|
|
ok := ctx.Input.Exec(func(t Effect) bool {
|
|
tctx := ctx
|
|
tctx.Input = u
|
|
t.Damage_ADD(tctx) //红伤落实前,我方增伤
|
|
|
|
return true
|
|
})
|
|
|
|
ctx.Input.DamageZone.BeforeMul = ctx.DamageZone.Damage
|
|
if ok {
|
|
ok = ctx.Input.Exec(func(t Effect) bool {
|
|
tctx := ctx
|
|
tctx.Input = u
|
|
t.Damage_Mul(tctx) //红伤落实前,我方增伤
|
|
|
|
return true
|
|
})
|
|
}
|
|
ctx.Input.DamageZone.BeforeFloor = ctx.DamageZone.Damage
|
|
if ok {
|
|
ok = ctx.Exec(func(t Effect) bool {
|
|
tctx := ctx
|
|
tctx.Input = u
|
|
t.Damage_Floor(tctx) //红伤落实,内部有befer
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
ctx.Input.DamageZone.BeforeMul = ctx.DamageZone.Damage
|
|
if ok {
|
|
ok = u.Exec(func(t Effect) bool {
|
|
|
|
t.Damage_DIV(ctx) //红伤落实,内部有befer
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
ctx.Input.DamageZone.BeforeSUB = ctx.DamageZone.Damage
|
|
if ok {
|
|
ok = u.Exec(func(t Effect) bool {
|
|
|
|
t.Damage_SUB(ctx)
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
ctx.Input.DamageZone.BeforeLock = ctx.DamageZone.Damage
|
|
if ok {
|
|
ok = ctx.Input.Exec(func(t Effect) bool {
|
|
tctx := ctx
|
|
tctx.Input = u
|
|
t.Damage_Lock(tctx)
|
|
|
|
return true
|
|
})
|
|
}
|
|
ctx.Input.DamageZone.BeforeLocked = ctx.DamageZone.Damage
|
|
if ok {
|
|
u.Exec(func(t Effect) bool {
|
|
|
|
t.Damage_Locked(ctx)
|
|
|
|
return true
|
|
})
|
|
}
|
|
|
|
if ctx.DamageZone.Type == info.DamageType.Red { //红才会产生造成伤害
|
|
ctx.Input.DamageZone.Damage = ctx.DamageZone.Damage
|
|
ctx.AttackValue.LostHp = uint32(ctx.DamageZone.Damage.IntPart()) //红伤落实
|
|
}
|
|
|
|
if uint32(ctx.DamageZone.Damage.IntPart()) > u.CurrentPet.Info.Hp {
|
|
|
|
u.CurrentPet.Info.Hp = 0
|
|
} else {
|
|
u.CurrentPet.Info.Hp = u.CurrentPet.Info.Hp - uint32(ctx.DamageZone.Damage.IntPart())
|
|
}
|
|
|
|
//todo 待实现死亡effet
|
|
|
|
}
|
|
|
|
// 施加方，类型，等级，操作类别，是否成功
|
|
func (u *Input) SetProp(in *Input, prop, level int8, ptype info.EnumAbilityOpType) (ret bool) {
|
|
canuseskill := u.Exec(func(t Effect) bool { //这个是能否使用技能
|
|
//结算状态
|
|
return t.Prop_Befer(in, prop, level, ptype) //返回本身结算,如果false,说明不能使用技能了
|
|
|
|
})
|
|
if !canuseskill {
|
|
|
|
return false
|
|
}
|
|
var newValue int8
|
|
abfunc := func(prop, level int8, ptype info.EnumAbilityOpType) (ret bool) {
|
|
|
|
switch ptype {
|
|
case info.AbilityOpType.ADD:
|
|
newValue = utils.Min(u.AttackValue.Prop[prop]+int8(level), 6)
|
|
|
|
if newValue > u.AttackValue.Prop[prop] {
|
|
fmt.Println("属性值会增加")
|
|
return true
|
|
} else {
|
|
fmt.Println("属性值不会增加")
|
|
return false
|
|
}
|
|
|
|
case info.AbilityOpType.SUB:
|
|
newValue = utils.Max(u.AttackValue.Prop[prop]+int8(level), -6)
|
|
if newValue < u.AttackValue.Prop[prop] {
|
|
fmt.Println("属性值会减少")
|
|
return true
|
|
} else {
|
|
fmt.Println("属性值不会增加")
|
|
return false
|
|
}
|
|
|
|
case info.AbilityOpType.RESET:
|
|
if level > 0 && u.AttackValue.Prop[prop] > 0 { //消强
|
|
newValue = 0
|
|
return true
|
|
|
|
}
|
|
if level < 0 && u.AttackValue.Prop[prop] < 0 { //解弱
|
|
newValue = 0
|
|
return true
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
}
|
|
switch ptype {
|
|
|
|
case info.AbilityOpType.AbilityOpStealStrengthen:
|
|
|
|
temp := in.AttackValue.Prop[prop]
|
|
|
|
if temp <= 0 { //对方没有强化
|
|
return false
|
|
}
|
|
if abfunc(prop, temp, info.AbilityOpType.ADD) { //把对面的强化等级添加自身
|
|
u.AttackValue.Prop[prop] = newValue //成功把 强化更新
|
|
in.SetProp(u, prop, 1, info.AbilityOpType.RESET) //吸取后消除对面强化
|
|
|
|
}
|
|
|
|
case info.AbilityOpType.AbilityOpReverse:
|
|
temp := u.AttackValue.Prop[prop]
|
|
|
|
switch {
|
|
|
|
case level > 0: //反转强化
|
|
if temp <= 0 { //没有强化
|
|
return false
|
|
}
|
|
if abfunc(prop, temp*2, info.AbilityOpType.SUB) {
|
|
u.AttackValue.Prop[prop] = newValue
|
|
if temp == -u.AttackValue.Prop[prop] { //成功到对应弱化
|
|
|
|
return true
|
|
} else {
|
|
return true
|
|
|
|
}
|
|
|
|
} else { //自身免弱或已到-6
|
|
|
|
return false
|
|
}
|
|
default: //反转弱化
|
|
if temp >= 0 { //没有弱化
|
|
return false
|
|
}
|
|
if abfunc(prop, -temp*2, info.AbilityOpType.ADD) {
|
|
u.AttackValue.Prop[prop] = newValue
|
|
if temp == -u.AttackValue.Prop[prop] { //成功到对应强化
|
|
|
|
return true
|
|
} else {
|
|
return true
|
|
|
|
}
|
|
|
|
} else { //自身免弱或已到-6
|
|
|
|
return false
|
|
}
|
|
}
|
|
|
|
case info.AbilityOpType.AbilityOpBounceWeaken:
|
|
temp := u.AttackValue.Prop[prop]
|
|
if temp >= 0 { //没有弱化
|
|
return false
|
|
}
|
|
|
|
if in.SetProp(u, prop, temp, info.AbilityOpType.SUB) {
|
|
|
|
u.SetProp(u, prop, -1, info.AbilityOpType.RESET) //消除自身弱化
|
|
return true
|
|
}
|
|
default: //增加减少重置
|
|
|
|
if abfunc(prop, level, ptype) {
|
|
// 执行赋值
|
|
u.AttackValue.Prop[prop] = newValue
|
|
return true
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
}
|
|
func (i *Input) GetAction(opp *Input) {
|
|
//使用1#技能,实际上要按照四个技能权重去使用
|
|
i.FightC.UseSkill(i.Player, int32(i.FightC.GetCurrPET(i.Player).Skills[0].ID))
|
|
|
|
}
|
|
|
|
// 计算技能威力
|
|
func (i *Input) CalculatePower(deftype *Input, skill *info.SkillEntity) decimal.Decimal {
|
|
|
|
// 1. 计算等级因子 (level * 0.4 + 2)
|
|
levelFactor := decimal.NewFromInt(int64(i.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(i.GetProp(0, false)))
|
|
defenseDec = decimal.NewFromInt(int64(deftype.GetProp(1, false)))
|
|
|
|
case info.Category.SPECIAL:
|
|
|
|
attackDec = decimal.NewFromInt(int64(i.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.NewElementCalculator().GetOffensiveMultiplier(skill.Type().ID, deftype.CurrentPet.Type().ID)
|
|
|
|
typeRate = decimal.NewFromFloat(t)
|
|
|
|
damage := baseDamage.
|
|
Mul(skill.CriticalsameTypeBonus()). // 同属性加成
|
|
Mul(typeRate). // 克制系数
|
|
|
|
Mul(skill.Criticalrandom()) //随机波动
|
|
|
|
return damage
|
|
|
|
}
|