admin/bl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

```

Browse Source 
docs(effect): 移除已完成的效果任务文档

移除effects 876-1061范围内的任务文档，这些effect已经实现或不再需要跟踪。
包括task-053至task-089的多个任务列表，涵盖各种战斗效果的实现说明。
```
This commit is contained in:
昔念
2026-03-31 20:02:25 +08:00
parent 5b346ef505
commit 5675fff48c
44 changed files with 3144 additions and 934 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
logic/service/fight/effect/1006_1010.go Normal file
View File

@@ -0,0 +1,165 @@
package effect
import (
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 1006: 造成的伤害超过{0}则下{1}回合免疫异常状态
type Effect1006 struct {
node.EffectNode
}
func (e *Effect1006) Skill_Use() bool {
if len(e.Args()) < 2 || e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1006, int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1006Sub struct {
RoundEffectArg0Base
}
func (e *Effect1006Sub) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
if in != e.Ctx().Opp || !input.IS_Stat(effEffect) {
return true
}
return false
}
// Effect 1007: {0}回合内每次攻击都有{1}%概率令对手{2}，未触发则对手全属性-{3}
type Effect1007 struct {
node.EffectNode
}
func (e *Effect1007) Skill_Use() bool {
if len(e.Args()) < 4 {
return true
}
sub := e.Ctx().Our.InitEffect(
input.EffectType.Sub,
1007,
int(e.Args()[0].IntPart()),
int(e.Args()[1].IntPart()),
int(e.Args()[2].IntPart()),
int(e.Args()[3].IntPart()),
)
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1007Sub struct {
RoundEffectArg0Base
}
func (e *Effect1007Sub) OnSkill() bool {
if len(e.Args()) < 4 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
ok, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100)
if ok {
addStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[2].IntPart()))
return true
}
applyAllPropDown(e.Ctx().Our, e.Ctx().Opp, int8(e.Args()[3].IntPart()))
return true
}
// Effect 1008: 造成的伤害高于{0}则获得{1}点护盾
type Effect1008 struct {
node.EffectNode
}
func (e *Effect1008) Skill_Use() bool {
if len(e.Args()) < 2 || e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) <= 0 {
return true
}
e.Ctx().Our.AddShield(e.Args()[1])
return true
}
// Effect 1009: 消除对手能力提升状态，消除成功则对手全属性-{0}
type Effect1009 struct {
node.EffectNode
}
func (e *Effect1009) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
cleared = true
}
}
if !cleared {
return true
}
applyAllPropDown(e.Ctx().Our, e.Ctx().Opp, int8(e.Args()[0].IntPart()))
return true
}
// Effect 1010: 消除对手能力提升状态，消除成功则下{0}回合造成的伤害提高{1}%
type Effect1010 struct {
node.EffectNode
}
func (e *Effect1010) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
cleared = true
}
}
if !cleared {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1010, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1010Sub struct {
RoundEffectArg0Base
}
func (e *Effect1010Sub) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) < 2 {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(100).Add(e.Args()[1])).Div(alpacadecimal.NewFromInt(100))
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1006, &Effect1006{})
input.InitEffect(input.EffectType.Sub, 1006, &Effect1006Sub{})
input.InitEffect(input.EffectType.Skill, 1007, &Effect1007{})
input.InitEffect(input.EffectType.Sub, 1007, &Effect1007Sub{})
input.InitEffect(input.EffectType.Skill, 1008, &Effect1008{})
input.InitEffect(input.EffectType.Skill, 1009, &Effect1009{})
input.InitEffect(input.EffectType.Skill, 1010, &Effect1010{})
input.InitEffect(input.EffectType.Sub, 1010, &Effect1010Sub{})
}

203
logic/service/fight/effect/1031_1035.go Normal file
View File

@@ -0,0 +1,203 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 1031: 出手时本回合若未受到伤害则对手下{0}回合属性技能无效
type Effect1031 struct {
node.EffectNode
}
func (e *Effect1031) Skill_Use() bool {
if len(e.Args()) == 0 || e.Ctx().Opp.SumDamage.Cmp(alpacadecimal.Zero) > 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1031, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1031Sub struct {
RoundEffectArg0Base
}
func (e *Effect1031Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() != info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
// Effect 1032: 消除对手回合类效果，消除成功则下{0}回合令对手使用的攻击技能无效
type Effect1032 struct {
node.EffectNode
}
func (e *Effect1032) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1032, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1032Sub struct {
RoundEffectArg0Base
}
func (e *Effect1032Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
// Effect 1033: {0}%使对手{1}，未触发则自身下{2}回合攻击必定致命一击
type Effect1033 struct {
node.EffectNode
}
func (e *Effect1033) Skill_Use() bool {
if len(e.Args()) < 3 {
return true
}
success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
if success {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1033, int(e.Args()[2].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1033Sub struct {
RoundEffectArg0Base
}
func (e *Effect1033Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.XML.CritRate = 16
return true
}
// Effect 1034: 消除对手回合类效果，消除成功则免疫下{0}回合受到的攻击伤害
type Effect1034 struct {
node.EffectNode
}
func (e *Effect1034) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1034, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1034Sub struct {
RoundEffectArg0Base
}
func (e *Effect1034Sub) DamageLockEx(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red {
return true
}
zone.Damage = alpacadecimal.Zero
return true
}
// Effect 1035: 命中后{0}%使对手{1}，未触发则下{2}回合攻击有{3}%概率使对手{4}
type Effect1035 struct {
node.EffectNode
}
func (e *Effect1035) SkillHit() bool {
if len(e.Args()) < 5 {
return true
}
success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
if success {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
sub := e.Ctx().Our.InitEffect(
input.EffectType.Sub,
1035,
int(e.Args()[2].IntPart()),
int(e.Args()[3].IntPart()),
int(e.Args()[4].IntPart()),
)
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1035Sub struct {
RoundEffectArg0Base
}
func (e *Effect1035Sub) OnSkill() bool {
if len(e.Args()) < 3 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
success, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100)
if !success {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[2].IntPart()))
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1031, &Effect1031{})
input.InitEffect(input.EffectType.Sub, 1031, &Effect1031Sub{})
input.InitEffect(input.EffectType.Skill, 1032, &Effect1032{})
input.InitEffect(input.EffectType.Sub, 1032, &Effect1032Sub{})
input.InitEffect(input.EffectType.Skill, 1033, &Effect1033{})
input.InitEffect(input.EffectType.Sub, 1033, &Effect1033Sub{})
input.InitEffect(input.EffectType.Skill, 1034, &Effect1034{})
input.InitEffect(input.EffectType.Sub, 1034, &Effect1034Sub{})
input.InitEffect(input.EffectType.Skill, 1035, &Effect1035{})
input.InitEffect(input.EffectType.Sub, 1035, &Effect1035Sub{})
}

220
logic/service/fight/effect/1036_1040.go Normal file
View File

@@ -0,0 +1,220 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 1036: 消除对手回合类效果，消除成功则下{0}次攻击附加{1}点固定伤害
type Effect1036 struct {
node.EffectNode
}
func (e *Effect1036) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1036, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1036Sub struct {
node.EffectNode
remaining int
damage alpacadecimal.Decimal
}
func (e *Effect1036Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
if len(a) > 1 {
e.damage = alpacadecimal.NewFromInt(int64(a[1]))
}
}
func (e *Effect1036Sub) OnSkill() bool {
if e.remaining <= 0 {
e.Alive(false)
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
if e.damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: e.damage,
})
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return true
}
// Effect 1037: 消除对手能力提升状态，消除成功则自身下{0}次攻击技能造成伤害额外提升{1}%
type Effect1037 struct {
node.EffectNode
}
func (e *Effect1037) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
cleared = true
}
}
if !cleared {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1037, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1037Sub struct {
node.EffectNode
remaining int
percent alpacadecimal.Decimal
}
func (e *Effect1037Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
if len(a) > 1 {
e.percent = alpacadecimal.NewFromInt(int64(a[1]))
}
}
func (e *Effect1037Sub) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red || e.remaining <= 0 {
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
zone.Damage = zone.Damage.Mul(hundred.Add(e.percent)).Div(hundred)
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return true
}
// Effect 1038: 双倍反转自身能力下降状态，反转成功则获得{0}点护盾
type Effect1038 struct {
node.EffectNode
}
func (e *Effect1038) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
reversed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -v*2)
}
if !reversed {
return true
}
shield := e.Args()[0]
if shield.Cmp(alpacadecimal.Zero) > 0 {
e.Ctx().Our.AddShield(shield)
}
return true
}
// Effect 1039: {0}回合内每回合使用技能恢复自身最大体力的1/{1}，低于1/{2}时直接回满
type Effect1039 struct {
RoundEffectArg0Base
}
func (e *Effect1039) OnSkill() bool {
if len(e.Args()) < 3 || e.Ctx().Our == nil || e.Ctx().Our.CurrentPet == nil {
return true
}
if e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 || e.Args()[2].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
maxHP := e.Ctx().Our.CurrentPet.GetMaxHP()
currentHP := e.Ctx().Our.CurrentPet.GetHP()
heal := maxHP.Div(e.Args()[1])
if currentHP.Cmp(maxHP.Div(e.Args()[2])) < 0 {
heal = maxHP.Sub(currentHP)
}
if heal.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
return true
}
// Effect 1040: 当回合若未击败对手则{0}%使对手{1}，未触发则自身全属性+{2}
type Effect1040 struct {
node.EffectNode
}
func (e *Effect1040) Skill_Use() bool {
if len(e.Args()) < 3 || e.Ctx().Opp == nil || e.Ctx().Opp.CurrentPet == nil || e.Ctx().Opp.CurrentPet.Info.Hp <= 0 {
return true
}
success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
if success {
addStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
applyAllPropUp(e.Ctx().Our, int8(e.Args()[2].IntPart()))
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1036, &Effect1036{})
input.InitEffect(input.EffectType.Sub, 1036, &Effect1036Sub{})
input.InitEffect(input.EffectType.Skill, 1037, &Effect1037{})
input.InitEffect(input.EffectType.Sub, 1037, &Effect1037Sub{})
input.InitEffect(input.EffectType.Skill, 1038, &Effect1038{})
input.InitEffect(input.EffectType.Skill, 1039, &Effect1039{})
input.InitEffect(input.EffectType.Skill, 1040, &Effect1040{})
}

195
logic/service/fight/effect/1041_1046.go Normal file
View File

@@ -0,0 +1,195 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 1041: 造成的攻击伤害若低于{0}则令对手下{1}次使用的攻击技能无效
type Effect1041 struct {
node.EffectNode
}
func (e *Effect1041) Skill_Use() bool {
if len(e.Args()) < 2 || e.Ctx().SkillEntity == nil {
return true
}
if e.Ctx().SkillEntity.Category() == info.Category.STATUS || e.Ctx().SkillEntity.AttackTime == 0 {
return true
}
if e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) >= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1041, int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1041Sub struct {
node.EffectNode
remaining int
}
func (e *Effect1041Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
}
func (e *Effect1041Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.remaining <= 0 {
e.Alive(false)
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return true
}
// Effect 1042: {0}回合内每回合自身技能消除对手能力提升状态
type Effect1042 struct {
node.EffectNode
}
func (e *Effect1042) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1042, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1042Sub struct {
RoundEffectArg0Base
}
func (e *Effect1042Sub) Skill_Use_ex() bool {
clearPositivePropsTo(e.Ctx().Opp, e.Ctx().Our)
return true
}
// Effect 1043: 反转自身能力下降状态，反转成功则{0}回合受到的伤害转化为自身体力
type Effect1043 struct {
node.EffectNode
}
func (e *Effect1043) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
if e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -2*v) {
reversed = true
}
}
if !reversed {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1043, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1043Sub struct {
RoundEffectArg0Base
}
func (e *Effect1043Sub) DamageLockEx(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red {
return true
}
if zone.Damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, zone.Damage)
zone.Damage = alpacadecimal.Zero
return true
}
// Effect 1045: 未击败对手则附加自身最大体力/{0}的百分比伤害
type Effect1045 struct {
node.EffectNode
}
func (e *Effect1045) Skill_Use() bool {
if len(e.Args()) == 0 || e.Ctx().Opp.CurrentPet == nil || e.Ctx().Opp.CurrentPet.Info.Hp == 0 {
return true
}
if e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
damage := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[0])
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
// Effect 1046: 若对手不处于异常状态则附加对手最大体力/{0}的百分比伤害
type Effect1046 struct {
node.EffectNode
}
func (e *Effect1046) OnSkill() bool {
if len(e.Args()) == 0 || e.Ctx().Opp.StatEffect_Exist_all() {
return true
}
if e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
damage := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[0])
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1041, &Effect1041{})
input.InitEffect(input.EffectType.Sub, 1041, &Effect1041Sub{})
input.InitEffect(input.EffectType.Skill, 1042, &Effect1042{})
input.InitEffect(input.EffectType.Sub, 1042, &Effect1042Sub{})
input.InitEffect(input.EffectType.Skill, 1043, &Effect1043{})
input.InitEffect(input.EffectType.Sub, 1043, &Effect1043Sub{})
input.InitEffect(input.EffectType.Skill, 1045, &Effect1045{})
input.InitEffect(input.EffectType.Skill, 1046, &Effect1046{})
}

204
logic/service/fight/effect/1052_1056.go Normal file
View File

@@ -0,0 +1,204 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
)
// Effect 1052: 消除对手能力提升状态，消除成功则令自身全属性+{0}
type Effect1052 struct {
node.EffectNode
}
func (e *Effect1052) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
cleared = true
}
}
if !cleared {
return true
}
applyAllPropUp(e.Ctx().Our, int8(e.Args()[0].IntPart()))
return true
}
// Effect 1053: {0}回合内对手使用攻击技能后使对手{1}，未触发则自身恢复最大体力的1/{2}
type Effect1053 struct {
node.EffectNode
}
func (e *Effect1053) Skill_Use() bool {
if len(e.Args()) < 3 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1053, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()), int(e.Args()[2].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1053Sub struct {
RoundEffectArg0Base
triggered bool
}
func (e *Effect1053Sub) Skill_Use_ex() bool {
if len(e.Args()) < 3 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
statusID := int(e.Args()[1].IntPart())
before := e.Ctx().Opp.StatEffect_Exist(info.EnumPetStatus(statusID))
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, statusID)
if !before && e.Ctx().Opp.StatEffect_Exist(info.EnumPetStatus(statusID)) {
e.triggered = true
}
return true
}
func (e *Effect1053Sub) TurnEnd() {
if !e.triggered && len(e.Args()) >= 3 && e.Duration() == 1 && e.Args()[2].IntPart() > 0 {
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[2])
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
}
e.EffectNode.TurnEnd()
}
// Effect 1054: 反转自身能力下降状态，反转成功则对手{0}
type Effect1054 struct {
node.EffectNode
}
func (e *Effect1054) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
if e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -2*v) {
reversed = true
}
}
if !reversed {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[0].IntPart()))
return true
}
// Effect 1055: 消除对手能力提升状态，消除成功则下{0}回合令对手使用的攻击技能无效
type Effect1055 struct {
node.EffectNode
}
func (e *Effect1055) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
cleared = true
}
}
if !cleared {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1055, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1055Sub struct {
RoundEffectArg0Base
}
func (e *Effect1055Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
// Effect 1056: 反转自身能力下降状态，反转成功则{0}回合内令对手使用的属性技能无效
type Effect1056 struct {
node.EffectNode
}
func (e *Effect1056) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
if e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -2*v) {
reversed = true
}
}
if !reversed {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1056, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1056Sub struct {
RoundEffectArg0Base
}
func (e *Effect1056Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() != info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetNoSide()
e.Ctx().SkillEntity.AttackTime = 0
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1052, &Effect1052{})
input.InitEffect(input.EffectType.Skill, 1053, &Effect1053{})
input.InitEffect(input.EffectType.Sub, 1053, &Effect1053Sub{})
input.InitEffect(input.EffectType.Skill, 1054, &Effect1054{})
input.InitEffect(input.EffectType.Skill, 1055, &Effect1055{})
input.InitEffect(input.EffectType.Sub, 1055, &Effect1055Sub{})
input.InitEffect(input.EffectType.Skill, 1056, &Effect1056{})
input.InitEffect(input.EffectType.Sub, 1056, &Effect1056Sub{})
}

226
logic/service/fight/effect/1057_1061.go Normal file
View File

@@ -0,0 +1,226 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
"github.com/gogf/gf/v2/util/grand"
)
var effect1059ControlStatuses = []int{
int(info.PetStatus.Paralysis),
int(info.PetStatus.Tired),
int(info.PetStatus.Fear),
int(info.PetStatus.Petrified),
int(info.PetStatus.Sleep),
}
type Effect1057 struct{ node.EffectNode }
func (e *Effect1057) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1057, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1057Sub struct{ RoundEffectArg0Base }
func (e *Effect1057Sub) PropBefer(source *input.Input, prop int8, level int8) bool {
if prop < 0 || int(prop) >= len(e.Ctx().Our.Prop) {
return true
}
if level != 0 || e.Ctx().Our.Prop[prop] <= 0 {
return true
}
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
e.Alive(false)
return true
}
type Effect1058 struct{ node.EffectNode }
func (e *Effect1058) OnSkill() bool {
if len(e.Args()) < 3 {
return true
}
success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
if success {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1058, int(e.Args()[2].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1058Sub struct{ RoundEffectArg0Base }
func (e *Effect1058Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
type Effect1059 struct{ node.EffectNode }
func (e *Effect1059) Skill_Use() bool {
if len(e.Args()) < 5 {
return true
}
e.Ctx().Our.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: e.Ctx().Our.CurrentPet.GetHP(),
})
success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
if success {
count := int(e.Args()[1].IntPart())
if count > len(effect1059ControlStatuses) {
count = len(effect1059ControlStatuses)
}
for _, idx := range grand.Perm(len(effect1059ControlStatuses))[:count] {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, effect1059ControlStatuses[idx])
}
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1059, int(e.Args()[2].IntPart()), int(e.Args()[3].IntPart()), int(e.Args()[4].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1059Sub struct{ node.EffectNode }
func (e *Effect1059Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(1)
}
func (e *Effect1059Sub) SwitchOut(in *input.Input) bool { return true }
func (e *Effect1059Sub) SwitchIn(in *input.Input) bool {
if in != e.Ctx().Our || len(e.Args()) < 3 {
return true
}
damageSub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 10591, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if damageSub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, damageSub)
}
prioritySub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 10592, int(e.Args()[0].IntPart()), int(e.Args()[2].IntPart()))
if prioritySub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, prioritySub)
}
e.Alive(false)
return true
}
type Effect1059DamageSub struct{ RoundEffectArg0Base }
func (e *Effect1059DamageSub) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) < 2 {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(100).Add(e.Args()[1])).Div(alpacadecimal.NewFromInt(100))
return true
}
type Effect1059PrioritySub struct{ RoundEffectArg0Base }
func (e *Effect1059PrioritySub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if len(e.Args()) < 2 {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
current.SkillEntity.XML.Priority += int(e.Args()[1].IntPart())
return true
}
type Effect1060 struct{ node.EffectNode }
func (e *Effect1060) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
absorbed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if !e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
continue
}
absorbed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
}
if !absorbed {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1060, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1060Sub struct{ RoundEffectArg0Base }
func (e *Effect1060Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
type Effect1061 struct{ node.EffectNode }
func (e *Effect1061) OnSkill() bool {
reversed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if !e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), -2*v) {
continue
}
reversed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
}
if !reversed {
clearPositivePropsTo(e.Ctx().Opp, e.Ctx().Our)
}
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1057, &Effect1057{})
input.InitEffect(input.EffectType.Sub, 1057, &Effect1057Sub{})
input.InitEffect(input.EffectType.Skill, 1058, &Effect1058{})
input.InitEffect(input.EffectType.Sub, 1058, &Effect1058Sub{})
input.InitEffect(input.EffectType.Skill, 1059, &Effect1059{})
input.InitEffect(input.EffectType.Sub, 1059, &Effect1059Sub{})
input.InitEffect(input.EffectType.Sub, 10591, &Effect1059DamageSub{})
input.InitEffect(input.EffectType.Sub, 10592, &Effect1059PrioritySub{})
input.InitEffect(input.EffectType.Skill, 1060, &Effect1060{})
input.InitEffect(input.EffectType.Sub, 1060, &Effect1060Sub{})
input.InitEffect(input.EffectType.Skill, 1061, &Effect1061{})
}

132
logic/service/fight/effect/1062_1066.go Normal file
View File

@@ -0,0 +1,132 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"strings"
"github.com/alpacahq/alpacadecimal"
)
type Effect1062 struct{ node.EffectNode }
func (e *Effect1062) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
absorbed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if !e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
continue
}
absorbed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
}
if !absorbed || e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
damage := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[0])
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{Type: info.DamageType.Percent, Damage: damage})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, damage)
return true
}
func effect106xMatchesOpp(target *input.Input, name string) bool {
if target == nil || target.CurrentPet == nil {
return false
}
return strings.TrimSpace(target.CurrentPet.PetInfo.DefName) == name
}
type Effect1063 struct{ node.EffectNode }
func (e *Effect1063) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) == 0 || !effect106xMatchesOpp(e.Ctx().Opp, "????") {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(100).Add(e.Args()[0])).Div(alpacadecimal.NewFromInt(100))
return true
}
type Effect1064 struct{ node.EffectNode }
func (e *Effect1064) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red || len(e.Args()) == 0 || !effect106xMatchesOpp(e.Ctx().Opp, "??????") {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(100).Add(e.Args()[0])).Div(alpacadecimal.NewFromInt(100))
return true
}
type Effect1065 struct{ node.EffectNode }
func (e *Effect1065) Skill_Use() bool {
if len(e.Args()) < 3 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 1065, e.SideEffectArgs...)
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect1065Sub struct{ RoundEffectArg0Base }
func (e *Effect1065Sub) Skill_Use() bool {
if len(e.Args()) < 3 || e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
value := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[1])
if e.Args()[2].Cmp(alpacadecimal.Zero) > 0 && e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[2])) < 0 {
value = value.Mul(alpacadecimal.NewFromInt(2))
}
if value.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, value)
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{Type: info.DamageType.Percent, Damage: value})
return true
}
type Effect1066 struct{ node.EffectNode }
func (e *Effect1066) Skill_Use() bool {
if len(e.Args()) < 3 || e.Ctx().SkillEntity == nil {
return true
}
if e.Ctx().SkillEntity.Category() == info.Category.STATUS || e.Ctx().SkillEntity.AttackTime == 0 {
return true
}
if e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) >= 0 {
return true
}
damage := e.Args()[1]
if e.IsFirst() {
damage = damage.Add(e.Args()[2])
}
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{Type: info.DamageType.Fixed, Damage: damage})
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 1062, &Effect1062{})
input.InitEffect(input.EffectType.Skill, 1063, &Effect1063{})
input.InitEffect(input.EffectType.Skill, 1064, &Effect1064{})
input.InitEffect(input.EffectType.Skill, 1065, &Effect1065{})
input.InitEffect(input.EffectType.Sub, 1065, &Effect1065Sub{})
input.InitEffect(input.EffectType.Skill, 1066, &Effect1066{})
}

148
logic/service/fight/effect/876_880.go Normal file
View File

@@ -0,0 +1,148 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 876: 附加自身防御、特防和速度总和{0}%的百分比伤害
type Effect876 struct {
node.EffectNode
}
func (e *Effect876) OnSkill() bool {
if len(e.Args()) == 0 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
base := e.Ctx().Our.GetProp(1).Add(e.Ctx().Our.GetProp(3)).Add(e.Ctx().Our.GetProp(4))
damage := base.Mul(e.Args()[0]).Div(alpacadecimal.NewFromInt(100))
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
// Effect 877: 先手时自身全属性+{0}
type Effect877 struct {
node.EffectNode
}
func (e *Effect877) OnSkill() bool {
if len(e.Args()) == 0 || !e.IsFirst() {
return true
}
applyAllPropUp(e.Ctx().Our, int8(e.Args()[0].IntPart()))
return true
}
// Effect 878: 接下来{0}回合，若先手则使对手进入{1}状态
type Effect878 struct {
node.EffectNode
}
func (e *Effect878) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 878, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect878Sub struct {
RoundEffectArg0Base
}
func (e *Effect878Sub) OnSkill() bool {
if len(e.Args()) < 2 || !e.IsFirst() {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
// Effect 879: 消除对手回合类效果，消除成功则自身回复满体力
type Effect879 struct {
node.EffectNode
}
func (e *Effect879) Skill_Use() bool {
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Sub(e.Ctx().Our.CurrentPet.GetHP())
if heal.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
return true
}
// Effect 880: 消除对手回合类效果，消除成功则下回合所有技能先制+{0}
type Effect880 struct {
node.EffectNode
}
func (e *Effect880) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 880, 1, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect880Sub struct {
RoundEffectArg0Base
}
func (e *Effect880Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if len(e.Args()) < 2 {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
current.SkillEntity.XML.Priority += int(e.Args()[1].IntPart())
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 876, &Effect876{})
input.InitEffect(input.EffectType.Skill, 877, &Effect877{})
input.InitEffect(input.EffectType.Skill, 878, &Effect878{})
input.InitEffect(input.EffectType.Sub, 878, &Effect878Sub{})
input.InitEffect(input.EffectType.Skill, 879, &Effect879{})
input.InitEffect(input.EffectType.Skill, 880, &Effect880{})
input.InitEffect(input.EffectType.Sub, 880, &Effect880Sub{})
}

185
logic/service/fight/effect/881_885.go Normal file
View File

@@ -0,0 +1,185 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 881: Priority +3 when self has any negative stat stage.
type Effect881 struct{ node.EffectNode }
func (e *Effect881) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if !e.Ctx().Our.HasPropSub() {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current != nil && current.SkillEntity != nil {
current.SkillEntity.XML.Priority += 3
}
return true
}
// Effect 882: For each positive stat stage kind on self, increase skill power by {0}.
type Effect882 struct{ node.EffectNode }
func (e *Effect882) SkillHit() bool {
if len(e.Args()) == 0 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
boostKinds := countPositivePropKinds(e.Ctx().Our)
if boostKinds <= 0 {
return true
}
e.Ctx().SkillEntity.XML.Power += boostKinds * int(e.Args()[0].IntPart())
return true
}
// Effect 883: On hit, reduce opponent next switched-in pet max HP by {0}% up to {1}%.
type Effect883 struct{ node.EffectNode }
func (e *Effect883) Skill_Use() bool {
if len(e.Args()) < 2 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.AttackTime == 0 {
return true
}
step := int(e.Args()[0].IntPart())
capPercent := int(e.Args()[1].IntPart())
if step <= 0 || capPercent <= 0 {
return true
}
if exist := e.Ctx().Opp.GetEffect(input.EffectType.Sub, 883); exist != nil {
if sub, ok := exist.(*Effect883Sub); ok {
sub.AddReduction(step, capPercent)
return true
}
}
sub := e.Ctx().Opp.InitEffect(input.EffectType.Sub, 883, step, capPercent)
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect883Sub struct {
node.EffectNode
reducePercent int
capPercent int
}
func (e *Effect883Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(-1)
if len(a) > 0 {
e.reducePercent = a[0]
}
if len(a) > 1 {
e.capPercent = a[1]
}
if e.capPercent <= 0 {
e.capPercent = e.reducePercent
}
if e.capPercent > 100 {
e.capPercent = 100
}
if e.reducePercent > e.capPercent {
e.reducePercent = e.capPercent
}
if e.reducePercent < 0 {
e.reducePercent = 0
}
}
func (e *Effect883Sub) AddReduction(step, cap int) {
if cap > 0 {
e.capPercent = cap
}
if e.capPercent > 100 {
e.capPercent = 100
}
if step <= 0 {
return
}
e.reducePercent += step
if e.capPercent > 0 && e.reducePercent > e.capPercent {
e.reducePercent = e.capPercent
}
}
func (e *Effect883Sub) SwitchIn(in *input.Input) bool {
if in != e.Ctx().Our || e.reducePercent <= 0 || e.Ctx().Our == nil || e.Ctx().Our.CurrentPet == nil {
return true
}
currentMax := e.Ctx().Our.CurrentPet.GetMaxHP()
newMax := currentMax.Mul(hundred.Sub(alpacadecimal.NewFromInt(int64(e.reducePercent)))).Div(hundred)
if newMax.Cmp(alpacadecimal.NewFromInt(1)) < 0 {
newMax = alpacadecimal.NewFromInt(1)
}
e.Ctx().Our.CurrentPet.Info.MaxHp = uint32(newMax.IntPart())
if e.Ctx().Our.CurrentPet.Info.Hp > e.Ctx().Our.CurrentPet.Info.MaxHp {
e.Ctx().Our.CurrentPet.Info.Hp = e.Ctx().Our.CurrentPet.Info.MaxHp
}
e.Alive(false)
return true
}
// Effect 884: Make opponent's next used skill invalid.
type Effect884 struct{ node.EffectNode }
func (e *Effect884) Skill_Use() bool {
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 884)
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect884Sub struct{ node.EffectNode }
func (e *Effect884Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(-1)
}
func (e *Effect884Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil {
return true
}
e.Ctx().SkillEntity.SetMiss()
e.Alive(false)
return true
}
// Effect 885: Increase all stats by {0}, doubled when current HP > opponent HP.
type Effect885 struct{ node.EffectNode }
func (e *Effect885) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
boost := int8(e.Args()[0].IntPart())
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) > 0 {
boost *= 2
}
for i := 0; i < 6; i++ {
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), boost)
}
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 881, &Effect881{})
input.InitEffect(input.EffectType.Skill, 882, &Effect882{})
input.InitEffect(input.EffectType.Skill, 883, &Effect883{})
input.InitEffect(input.EffectType.Sub, 883, &Effect883Sub{})
input.InitEffect(input.EffectType.Skill, 884, &Effect884{})
input.InitEffect(input.EffectType.Sub, 884, &Effect884Sub{})
input.InitEffect(input.EffectType.Skill, 885, &Effect885{})
}

176
logic/service/fight/effect/886_890.go Normal file
View File

@@ -0,0 +1,176 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 886: 下次攻击忽略对手双防值的{0}%
type Effect886 struct {
node.EffectNode
}
func (e *Effect886) Skill_Use() bool {
addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect886Sub{}, -1)
return true
}
type Effect886Sub struct {
FixedDuration1Base
}
func (e *Effect886Sub) CalculatePre() bool {
if len(e.Args()) == 0 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
if e.ID().GetCatchTime() != e.Ctx().Our.CurrentPet.Info.CatchTime {
return true
}
if e.Ctx().Opp == nil || e.Ctx().Opp.CurrentPet == nil {
return true
}
percent := e.Args()[0].IntPart()
if percent <= 0 {
return true
}
if percent > 100 {
percent = 100
}
remain := alpacadecimal.NewFromInt(100 - percent)
base := alpacadecimal.NewFromInt(100)
if e.Ctx().SkillEntity.Category() == info.Category.PHYSICAL {
def := alpacadecimal.NewFromInt(int64(e.Ctx().Opp.CurrentPet.Info.Prop[2]))
e.Ctx().Opp.CurrentPet.Info.Prop[2] = uint32(def.Mul(remain).Div(base).IntPart())
} else if e.Ctx().SkillEntity.Category() == info.Category.SPECIAL {
spDef := alpacadecimal.NewFromInt(int64(e.Ctx().Opp.CurrentPet.Info.Prop[4]))
e.Ctx().Opp.CurrentPet.Info.Prop[4] = uint32(spDef.Mul(remain).Div(base).IntPart())
}
return true
}
// Effect 887: 吸收对手能力提升状态，吸收成功则回复满体力并在下回合先制+{0}
type Effect887 struct {
node.EffectNode
}
func (e *Effect887) Skill_Use() bool {
absorbed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if !e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
continue
}
absorbed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
}
if !absorbed {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, e.Ctx().Our.CurrentPet.GetMaxHP())
addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect887Sub{}, -1)
return true
}
type Effect887Sub struct {
FixedDuration1Base
}
func (e *Effect887Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
current.SkillEntity.XML.Priority += int(e.Args()[0].IntPart())
return true
}
// Effect 888: 若行动时自身体力低于对手，则回合结束时减少对手1/{0}最大体力
type Effect888 struct {
node.EffectNode
}
func (e *Effect888) Skill_Use() bool {
if len(e.Args()) == 0 || e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) >= 0 {
return true
}
addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect888Sub{}, -1)
return true
}
type Effect888Sub struct {
FixedDuration1Base
}
func (e *Effect888Sub) TurnEnd() {
if len(e.Args()) == 0 || e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
e.EffectNode.TurnEnd()
return
}
damage := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[0])
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
e.EffectNode.TurnEnd()
}
// Effect 889: 消除对手回合类效果，成功则令对手{0}
type Effect889 struct {
node.EffectNode
}
func (e *Effect889) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
statusEffect := e.Ctx().Our.InitEffect(input.EffectType.Status, int(e.Args()[0].IntPart()))
if statusEffect != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, statusEffect)
}
return true
}
// Effect 890: 自身处于能力提升状态时，造成伤害翻倍
type Effect890 struct {
node.EffectNode
}
func (e *Effect890) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red {
return true
}
if !e.Ctx().Our.HasPropADD() {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(2))
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 886, &Effect886{})
input.InitEffect(input.EffectType.Sub, 886, &Effect886Sub{})
input.InitEffect(input.EffectType.Skill, 887, &Effect887{})
input.InitEffect(input.EffectType.Sub, 887, &Effect887Sub{})
input.InitEffect(input.EffectType.Skill, 888, &Effect888{})
input.InitEffect(input.EffectType.Sub, 888, &Effect888Sub{})
input.InitEffect(input.EffectType.Skill, 889, &Effect889{})
input.InitEffect(input.EffectType.Skill, 890, &Effect890{})
}

204
logic/service/fight/effect/891_895.go Normal file
View File

@@ -0,0 +1,204 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 891: 吸收对手能力提升状态，吸收成功则下{0}回合造成的伤害翻倍
type Effect891 struct {
node.EffectNode
}
func (e *Effect891) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
cleared := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
cleared = true
}
}
if !cleared {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 891, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect891Sub struct {
RoundEffectArg0Base
}
func (e *Effect891Sub) Damage_Mul(zone *info.DamageZone) bool {
if zone == nil || zone.Type != info.DamageType.Red {
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
zone.Damage = zone.Damage.Mul(alpacadecimal.NewFromInt(2))
return true
}
// Effect 892: 每使用此技能击败一只精灵则减少对手下只出场精灵{0}%最大体力
type Effect892 struct {
node.EffectNode
}
func (e *Effect892) Skill_Use() bool {
if len(e.Args()) == 0 || e.Ctx().Opp == nil || e.Ctx().Opp.CurrentPet == nil || e.Ctx().Opp.CurrentPet.Info.Hp > 0 {
return true
}
sub := e.Ctx().Opp.InitEffect(input.EffectType.Sub, 892, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect892Sub struct {
node.EffectNode
}
func (e *Effect892Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(1)
}
func (e *Effect892Sub) SwitchIn(in *input.Input) bool {
if in != e.Ctx().Our || len(e.Args()) == 0 || e.Ctx().Our == nil || e.Ctx().Our.CurrentPet == nil {
return true
}
percent := e.Args()[0]
if percent.Cmp(alpacadecimal.Zero) <= 0 {
e.Alive(false)
return true
}
if percent.Cmp(alpacadecimal.NewFromInt(100)) > 0 {
percent = alpacadecimal.NewFromInt(100)
}
currentMax := e.Ctx().Our.CurrentPet.GetMaxHP()
newMax := currentMax.Mul(alpacadecimal.NewFromInt(100).Sub(percent)).Div(alpacadecimal.NewFromInt(100))
if newMax.Cmp(alpacadecimal.NewFromInt(1)) < 0 {
newMax = alpacadecimal.NewFromInt(1)
}
e.Ctx().Our.CurrentPet.Info.MaxHp = uint32(newMax.IntPart())
if e.Ctx().Our.CurrentPet.Info.Hp > e.Ctx().Our.CurrentPet.Info.MaxHp {
e.Ctx().Our.CurrentPet.Info.Hp = e.Ctx().Our.CurrentPet.Info.MaxHp
}
e.Alive(false)
return true
}
// Effect 893: 全属性+{0}，自身满体力时强化效果翻倍
type Effect893 struct {
node.EffectNode
}
func (e *Effect893) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
boost := int8(e.Args()[0].IntPart())
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Our.CurrentPet.GetMaxHP()) == 0 {
boost *= 2
}
applyAllPropUp(e.Ctx().Our, boost)
return true
}
// Effect 894: 吸取对手{0}点体力，体力低于对手时吸取效果翻倍
type Effect894 struct {
node.EffectNode
}
func (e *Effect894) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
drain := e.Args()[0]
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) < 0 {
drain = drain.Mul(alpacadecimal.NewFromInt(2))
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: drain,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, drain)
return true
}
// Effect 895: {0}回合内受到的所有类型伤害的1/{1}转化为自身体力
type Effect895 struct {
node.EffectNode
}
func (e *Effect895) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 895, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect895Sub struct {
RoundEffectArg0Base
}
func (e *Effect895Sub) DamageLockEx(zone *info.DamageZone) bool {
if zone == nil || len(e.Args()) < 2 || zone.Damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
if e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
convert := zone.Damage.Div(e.Args()[1])
if convert.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
if convert.Cmp(zone.Damage) > 0 {
convert = zone.Damage
}
zone.Damage = zone.Damage.Sub(convert)
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, convert)
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 891, &Effect891{})
input.InitEffect(input.EffectType.Sub, 891, &Effect891Sub{})
input.InitEffect(input.EffectType.Skill, 892, &Effect892{})
input.InitEffect(input.EffectType.Sub, 892, &Effect892Sub{})
input.InitEffect(input.EffectType.Skill, 893, &Effect893{})
input.InitEffect(input.EffectType.Skill, 894, &Effect894{})
input.InitEffect(input.EffectType.Skill, 895, &Effect895{})
input.InitEffect(input.EffectType.Sub, 895, &Effect895Sub{})
}

264
logic/service/fight/effect/926_930.go Normal file
View File

@@ -0,0 +1,264 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 926: 反转自身能力下降状态，反转成功则下{0}回合先制+{1}
type Effect926 struct {
node.EffectNode
}
func (e *Effect926) Skill_Use() bool {
if len(e.Args()) < 2 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
if e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -v) {
reversed = true
}
}
if !reversed {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 926, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect926Sub struct {
RoundEffectArg0Base
}
func (e *Effect926Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil || current.SkillEntity.Category() == info.Category.STATUS {
return true
}
current.SkillEntity.XML.Priority += int(e.Args()[1].IntPart())
return true
}
// Effect 927: {0}回合内每回合使用技能后恢复1/{1}最大体力，低于1/{2}时附加等量百分比伤害
type Effect927 struct {
node.EffectNode
}
func (e *Effect927) Skill_Use() bool {
if len(e.Args()) < 3 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 927, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()), int(e.Args()[2].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect927Sub struct {
RoundEffectArg0Base
}
func (e *Effect927Sub) OnSkill() bool {
if len(e.Args()) < 3 || e.Ctx().Our == nil || e.Ctx().Our.CurrentPet == nil || e.Ctx().Opp == nil || e.Ctx().Opp.CurrentPet == nil {
return true
}
if e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 || e.Args()[2].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[1])
if heal.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
lowHP := e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[2])) < 0
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
if lowHP {
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: heal,
})
}
return true
}
// Effect 928: 消除对手回合类效果，消除成功则免疫下{0}次受到的异常状态
type Effect928 struct {
node.EffectNode
}
func (e *Effect928) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 928, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect928Sub struct {
node.EffectNode
remaining int
}
func (e *Effect928Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
}
func (e *Effect928Sub) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
if e.remaining <= 0 {
e.Alive(false)
return true
}
if in != e.Ctx().Opp || !input.IS_Stat(effEffect) {
return true
}
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return false
}
// Effect 929: 反弹{0}倍的伤害给对手并使自身恢复等量体力
type Effect929 struct {
node.EffectNode
}
func (e *Effect929) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 929, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect929Sub struct {
FixedDuration1Base
}
func (e *Effect929Sub) DamageLockEx(zone *info.DamageZone) bool {
if zone == nil || zone.Damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
switch zone.Type {
case info.DamageType.Red, info.DamageType.Fixed, info.DamageType.Percent, info.DamageType.True:
default:
return true
}
if len(e.Args()) == 0 {
return true
}
rebound := zone.Damage.Mul(e.Args()[0])
if rebound.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: rebound,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, rebound)
return true
}
// Effect 930: 获得{0}点护盾，护盾消失时对对手造成{1}点固定伤害且有{2}%概率使对手{3}
type Effect930 struct {
node.EffectNode
}
func (e *Effect930) Skill_Use() bool {
if len(e.Args()) < 4 {
return true
}
shield := e.Args()[0]
if shield.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.AddShield(shield)
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 930, int(e.Args()[1].IntPart()), int(e.Args()[2].IntPart()), int(e.Args()[3].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect930Sub struct {
node.EffectNode
}
func (e *Effect930Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(-1)
}
func (e *Effect930Sub) ShieldChange(before, after alpacadecimal.Decimal) bool {
if len(e.Args()) < 3 {
return true
}
if before.Cmp(alpacadecimal.Zero) <= 0 || after.Cmp(alpacadecimal.Zero) > 0 {
return true
}
damage := e.Args()[0]
if damage.Cmp(alpacadecimal.Zero) > 0 {
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: damage,
})
}
if ok, _, _ := e.Input.Player.Roll(int(e.Args()[1].IntPart()), 100); ok {
addStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[2].IntPart()))
}
e.Alive(false)
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 926, &Effect926{})
input.InitEffect(input.EffectType.Sub, 926, &Effect926Sub{})
input.InitEffect(input.EffectType.Skill, 927, &Effect927{})
input.InitEffect(input.EffectType.Sub, 927, &Effect927Sub{})
input.InitEffect(input.EffectType.Skill, 928, &Effect928{})
input.InitEffect(input.EffectType.Sub, 928, &Effect928Sub{})
input.InitEffect(input.EffectType.Skill, 929, &Effect929{})
input.InitEffect(input.EffectType.Sub, 929, &Effect929Sub{})
input.InitEffect(input.EffectType.Skill, 930, &Effect930{})
input.InitEffect(input.EffectType.Sub, 930, &Effect930Sub{})
}

195
logic/service/fight/effect/931_935.go Normal file
View File

@@ -0,0 +1,195 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 931: 吸取对手能力提升状态，吸取成功则对手{0}个技能PP值归零
type Effect931 struct {
node.EffectNode
}
func (e *Effect931) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
absorbed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0) {
absorbed = true
e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), v)
}
}
if !absorbed {
return true
}
zeroRandomSkillPP(e.Ctx().Opp, int(e.Args()[0].IntPart()))
return true
}
// Effect 932: 先出手时附加自身攻击{0}%的百分比伤害
type Effect932 struct {
node.EffectNode
}
func (e *Effect932) OnSkill() bool {
if len(e.Args()) == 0 || !e.IsFirst() {
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
damage := e.Ctx().Our.GetProp(0).Mul(e.Args()[0]).Div(hundred)
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
// Effect 933: 未击败对手则己方下{0}次攻击技能必定打出致命一击
type Effect933 struct {
node.EffectNode
}
func (e *Effect933) Skill_Use() bool {
if len(e.Args()) == 0 || e.Ctx().Opp.CurrentPet == nil || e.Ctx().Opp.CurrentPet.Info.Hp == 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 933, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect933Sub struct {
node.EffectNode
remaining int
}
func (e *Effect933Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
}
func (e *Effect933Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.remaining <= 0 {
e.Alive(false)
return true
}
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.XML.CritRate = 16
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return true
}
// Effect 934: 击败对手则对手下只出场精灵{0}回合内先制-{1}
type Effect934 struct {
node.EffectNode
}
func (e *Effect934) Skill_Use() bool {
if len(e.Args()) < 2 || e.Ctx().Opp.CurrentPet == nil || e.Ctx().Opp.CurrentPet.Info.Hp > 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 934, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect934Sub struct {
node.EffectNode
}
func (e *Effect934Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.CanStack(false)
e.Duration(1)
}
func (e *Effect934Sub) SwitchIn(in *input.Input) bool {
if in != e.Ctx().Our || len(e.Args()) < 2 {
return true
}
prioritySub := e.Ctx().Opp.InitEffect(input.EffectType.Sub, 9341, int(e.Args()[0].IntPart()), int(e.Args()[1].IntPart()))
if prioritySub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Opp, prioritySub)
}
e.Alive(false)
return true
}
type Effect934PrioritySub struct {
RoundEffectArg0Base
}
func (e *Effect934PrioritySub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if len(e.Args()) < 2 {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
current.SkillEntity.XML.Priority -= int(e.Args()[1].IntPart())
return true
}
// Effect 935: 若自身体力高于对手则使对手{0}
type Effect935 struct {
node.EffectNode
}
func (e *Effect935) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) <= 0 {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[0].IntPart()))
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 931, &Effect931{})
input.InitEffect(input.EffectType.Skill, 932, &Effect932{})
input.InitEffect(input.EffectType.Skill, 933, &Effect933{})
input.InitEffect(input.EffectType.Sub, 933, &Effect933Sub{})
input.InitEffect(input.EffectType.Skill, 934, &Effect934{})
input.InitEffect(input.EffectType.Sub, 934, &Effect934Sub{})
input.InitEffect(input.EffectType.Sub, 9341, &Effect934PrioritySub{})
input.InitEffect(input.EffectType.Skill, 935, &Effect935{})
}

159
logic/service/fight/effect/936_940.go Normal file
View File

@@ -0,0 +1,159 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
)
// Effect 936: {0}%令对手{1}，未触发则令对手{2}回合内使用的属性技能无效
type Effect936 struct {
node.EffectNode
}
func (e *Effect936) OnSkill() bool {
if len(e.Args()) < 3 {
return true
}
if ok, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100); ok {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 936, int(e.Args()[2].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect936Sub struct {
RoundEffectArg0Base
}
func (e *Effect936Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() != info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetNoSide()
e.Ctx().SkillEntity.AttackTime = 0
return true
}
// Effect 937: 命中后{0}%使对手{1}，未触发则对手下{2}回合先制-{3}
type Effect937 struct {
node.EffectNode
}
func (e *Effect937) SkillHit() bool {
if len(e.Args()) < 4 {
return true
}
if ok, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100); ok {
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[1].IntPart()))
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 937, int(e.Args()[2].IntPart()), int(e.Args()[3].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect937Sub struct {
RoundEffectArg0Base
}
func (e *Effect937Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if len(e.Args()) < 2 {
return true
}
priorityDown := int(e.Args()[1].IntPart())
if fattack != nil && fattack.PlayerID == e.Ctx().Opp.UserID && fattack.SkillEntity != nil {
fattack.SkillEntity.XML.Priority -= priorityDown
}
if sattack != nil && sattack.PlayerID == e.Ctx().Opp.UserID && sattack.SkillEntity != nil {
sattack.SkillEntity.XML.Priority -= priorityDown
}
return true
}
// Effect 938: 使对手全属性-{0}，先出手时效果翻倍
type Effect938 struct {
node.EffectNode
}
func (e *Effect938) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
level := int8(e.Args()[0].IntPart())
if level <= 0 {
return true
}
if e.IsFirst() {
level *= 2
}
applyAllPropDown(e.Ctx().Our, e.Ctx().Opp, level)
return true
}
// Effect 939: 若后出手则附加自身最大体力1/{0}的百分比伤害并恢复等量体力
type Effect939 struct {
node.EffectNode
}
func (e *Effect939) OnSkill() bool {
if len(e.Args()) == 0 || e.IsFirst() || e.Args()[0].IntPart() <= 0 {
return true
}
damage := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[0])
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, damage)
return true
}
// Effect 940: 全属性+{0}，若对手处于封印属性技能状态则攻击额外+{1}
type Effect940 struct {
node.EffectNode
}
func (e *Effect940) OnSkill() bool {
if len(e.Args()) < 2 {
return true
}
baseUp := int8(e.Args()[0].IntPart())
if baseUp > 0 {
applyAllPropUp(e.Ctx().Our, baseUp)
}
if e.Ctx().Opp.StatEffect_Exist_all() {
extraAtkUp := int8(e.Args()[1].IntPart())
if extraAtkUp > 0 {
e.Ctx().Our.SetProp(e.Ctx().Our, 0, extraAtkUp)
}
}
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 936, &Effect936{})
input.InitEffect(input.EffectType.Sub, 936, &Effect936Sub{})
input.InitEffect(input.EffectType.Skill, 937, &Effect937{})
input.InitEffect(input.EffectType.Sub, 937, &Effect937Sub{})
input.InitEffect(input.EffectType.Skill, 938, &Effect938{})
input.InitEffect(input.EffectType.Skill, 939, &Effect939{})
input.InitEffect(input.EffectType.Skill, 940, &Effect940{})
}

128
logic/service/fight/effect/941_945.go Normal file
View File

@@ -0,0 +1,128 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
func ownDefensePairSum(in *input.Input) alpacadecimal.Decimal {
if in == nil {
return alpacadecimal.Zero
}
return in.GetProp(1).Add(in.GetProp(3))
}
// Effect 941: 出手时有概率使对手{0}，概率等同于出手时自身当前体力百分比
type Effect941 struct{ node.EffectNode }
func (e *Effect941) OnSkill() bool {
if len(e.Args()) == 0 || e.Ctx().Our == nil || e.Ctx().Our.CurrentPet == nil {
return true
}
maxHP := e.Ctx().Our.CurrentPet.GetMaxHP()
if maxHP.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
chance := int(e.Ctx().Our.CurrentPet.GetHP().Mul(hundred).Div(maxHP).IntPart())
if chance <= 0 {
return true
}
if chance > 100 {
chance = 100
}
success, _, _ := e.Input.Player.Roll(chance, 100)
if !success {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[0].IntPart()))
return true
}
// Effect 942: 消除对手回合类效果，消除成功则吸取对手最大体力的1/{0}
type Effect942 struct{ node.EffectNode }
func (e *Effect942) Skill_Use() bool {
if len(e.Args()) == 0 || e.Args()[0].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
damage := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[0])
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, damage)
return true
}
// Effect 943: 附加自身防御、特防总和{0}%的百分比伤害
type Effect943 struct{ node.EffectNode }
func (e *Effect943) OnSkill() bool {
if len(e.Args()) == 0 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
damage := ownDefensePairSum(e.Ctx().Our).Mul(e.Args()[0]).Div(hundred)
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
// Effect 944: {0}回合内对手使用攻击技能时受到自身防御、特防总和{1}%的百分比伤害
type Effect944 struct{ RoundEffectArg0Base }
func (e *Effect944) Skill_Use_ex() bool {
if len(e.Args()) < 2 || e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
damage := ownDefensePairSum(e.Ctx().Our).Mul(e.Args()[1]).Div(hundred)
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
return true
}
// Effect 945: 消除对手回合类效果，消除成功则恢复自身全部体力
type Effect945 struct{ node.EffectNode }
func (e *Effect945) Skill_Use() bool {
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Sub(e.Ctx().Our.CurrentPet.GetHP())
if heal.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 941, &Effect941{})
input.InitEffect(input.EffectType.Skill, 942, &Effect942{})
input.InitEffect(input.EffectType.Skill, 943, &Effect943{})
input.InitEffect(input.EffectType.Skill, 944, &Effect944{})
input.InitEffect(input.EffectType.Skill, 945, &Effect945{})
}

117
logic/service/fight/effect/946_950.go Normal file
View File

@@ -0,0 +1,117 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 946: 全属性+{0}，若自身当前体力低于对手则强化效果翻倍
type Effect946 struct{ node.EffectNode }
func (e *Effect946) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
boost := int8(e.Args()[0].IntPart())
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) < 0 {
boost *= 2
}
applyAllPropUp(e.Ctx().Our, boost)
return true
}
// Effect 947: 造成的伤害不足{0}则吸取对手最大体力的1/{1}
type Effect947 struct{ node.EffectNode }
func (e *Effect947) Skill_Use() bool {
if len(e.Args()) < 2 || e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 {
return true
}
if e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) >= 0 {
return true
}
damage := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[1])
if damage.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Percent,
Damage: damage,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, damage)
return true
}
// Effect 948: 吸取对手能力提升状态，吸取成功则对手{0}
type Effect948 struct{ node.EffectNode }
func (e *Effect948) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
if !clearPositivePropsTo(e.Ctx().Opp, e.Ctx().Our) {
return true
}
applyStatusByID(e.Ctx().Our, e.Ctx().Opp, int(e.Args()[0].IntPart()))
return true
}
// Effect 949: 造成伤害不足{0}则恢复自身全部体力
type Effect949 struct{ node.EffectNode }
func (e *Effect949) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
if e.Ctx().Our.SumDamage.Cmp(e.Args()[0]) >= 0 {
return true
}
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Sub(e.Ctx().Our.CurrentPet.GetHP())
if heal.Cmp(alpacadecimal.Zero) <= 0 {
return true
}
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
return true
}
// Effect 950: 消除对手回合类效果，消除成功则对手{0}回合内攻击技能MISS
type Effect950 struct{ node.EffectNode }
func (e *Effect950) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
before := activeTurnEffectCount(e.Ctx().Opp)
e.Ctx().Opp.CancelTurn(e.Ctx().Our)
if before <= 0 {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 950, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Opp.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect950Sub struct{ RoundEffectArg0Base }
func (e *Effect950Sub) ActionStart(a, b *action.SelectSkillAction) bool {
if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
return true
}
e.Ctx().SkillEntity.SetMiss()
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 946, &Effect946{})
input.InitEffect(input.EffectType.Skill, 947, &Effect947{})
input.InitEffect(input.EffectType.Skill, 948, &Effect948{})
input.InitEffect(input.EffectType.Skill, 949, &Effect949{})
input.InitEffect(input.EffectType.Skill, 950, &Effect950{})
input.InitEffect(input.EffectType.Sub, 950, &Effect950Sub{})
}

163
logic/service/fight/effect/951_955.go Normal file
View File

@@ -0,0 +1,163 @@
package effect
import (
"blazing/logic/service/fight/action"
"blazing/logic/service/fight/info"
"blazing/logic/service/fight/input"
"blazing/logic/service/fight/node"
"github.com/alpacahq/alpacadecimal"
)
// Effect 951: 反转对手能力提升状态，反转成功则己方免疫下{0}次受到的异常状态
type Effect951 struct{ node.EffectNode }
func (e *Effect951) Skill_Use() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Opp.Prop[:] {
if v <= 0 {
continue
}
if e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), -2*v) {
reversed = true
}
}
if !reversed {
return true
}
sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 951, int(e.Args()[0].IntPart()))
if sub != nil {
e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
}
return true
}
type Effect951Sub struct {
node.EffectNode
remaining int
}
func (e *Effect951Sub) SetArgs(t *input.Input, a ...int) {
e.EffectNode.SetArgs(t, a...)
e.Duration(-1)
if len(a) > 0 {
e.remaining = a[0]
}
}
func (e *Effect951Sub) EFFect_Befer(in *input.Input, effEffect input.Effect) bool {
if e.remaining <= 0 {
e.Alive(false)
return true
}
if in != e.Ctx().Opp || !input.IS_Stat(effEffect) {
return true
}
e.remaining--
if e.remaining <= 0 {
e.Alive(false)
}
return false
}
// Effect 952: 全属性+{0},若对手处于能力下降状态则效果翻倍
type Effect952 struct{ node.EffectNode }
func (e *Effect952) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
boost := int8(e.Args()[0].IntPart())
if e.Ctx().Opp.HasPropSub() {
boost *= 2
}
applyAllPropUp(e.Ctx().Our, boost)
return true
}
// Effect 953: {0}回合恢复最大体力的1/{1}，体力低于{2}%时先制+{3}
type Effect953 struct{ RoundEffectArg0Base }
func (e *Effect953) TurnEnd() {
if len(e.Args()) < 2 || e.Args()[1].Cmp(alpacadecimal.Zero) <= 0 {
e.EffectNode.TurnEnd()
return
}
heal := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[1])
if heal.Cmp(alpacadecimal.Zero) > 0 {
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
}
e.EffectNode.TurnEnd()
}
func (e *Effect953) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if len(e.Args()) < 4 {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
currentPercent := e.Ctx().Our.CurrentPet.GetHP().Mul(hundred)
thresholdPercent := e.Ctx().Our.CurrentPet.GetMaxHP().Mul(e.Args()[2])
if currentPercent.Cmp(thresholdPercent) >= 0 {
return true
}
current.SkillEntity.XML.Priority += int(e.Args()[3].IntPart())
return true
}
// Effect 954: 若当前体力低于对手则先制+1
type Effect954 struct{ node.EffectNode }
func (e *Effect954) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
if e.Ctx().Our.CurrentPet.GetHP().Cmp(e.Ctx().Opp.CurrentPet.GetHP()) >= 0 {
return true
}
current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
if current == nil || current.SkillEntity == nil {
return true
}
current.SkillEntity.XML.Priority += 1
return true
}
// Effect 955: 反转自身能力下降状态，反转成功则吸取对手{0}点体力
type Effect955 struct{ node.EffectNode }
func (e *Effect955) OnSkill() bool {
if len(e.Args()) == 0 {
return true
}
reversed := false
for i, v := range e.Ctx().Our.Prop[:] {
if v >= 0 {
continue
}
if e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), -v) {
reversed = true
}
}
if !reversed {
return true
}
drain := e.Args()[0]
e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
Type: info.DamageType.Fixed,
Damage: drain,
})
e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, drain)
return true
}
func init() {
input.InitEffect(input.EffectType.Skill, 951, &Effect951{})
input.InitEffect(input.EffectType.Sub, 951, &Effect951Sub{})
input.InitEffect(input.EffectType.Skill, 952, &Effect952{})
input.InitEffect(input.EffectType.Skill, 953, &Effect953{})
input.InitEffect(input.EffectType.Skill, 954, &Effect954{})
input.InitEffect(input.EffectType.Skill, 955, &Effect955{})
}

60
logic/service/fight/effect/effect_info_map.go
View File

@@ -543,6 +543,26 @@ var effectInfoByID = map[int]string{
868: "消除对手能力提升状态，消除成功则令对手下回合所有技能先制-{0}",
869: "附加自身速度{0}%的百分比伤害，每次触发增加{1}%，最高{2}%",
870: "吸取对手{0}点体力",
876: "附加自身防御、特防和速度总和{0}%的百分比伤害",
877: "若先出手则自身全属性+{0}",
878: "下{0}回合先出手则对手{1}",
879: "消除对手回合类效果，消除成功则恢复自身全部体力",
880: "消除对手回合类效果，消除成功则令自身下回合所有技能先制+{0}",
881: "若自身处于能力下降状态则先制+3",
882: "自身每处于一种能力提升状态，此技能威力提升{0}",
883: "每次命中对手会降低对手下只出战精灵最大体力的{0}%，最多降低{1}%",
884: "令对手下次使用的技能无效",
885: "全属性+{0}，自身当前体力高于对手时强化效果翻倍",
886: "下次攻击忽略对手双防值的{0}%",
887: "吸收对手能力提升，吸收成功恢复自身所有体力并且下回合先制+{0}",
888: "自己出手时若自身体力低于对手则回合结束时减少对手1/{0}最大体力",
889: "消除对手回合类效果，消除成功则令对手{0}",
890: "自身处于能力提升状态时造成的伤害翻倍",
891: "吸收对手能力提升状态，吸收成功则下{0}回合造成的伤害翻倍",
892: "每使用此技能击败一只精灵则减少对手下只出场精灵{0}%最大体力",
893: "全属性+{0}，自身满体力时强化效果翻倍",
894: "吸取对手{0}点体力，体力低于对手时吸取效果翻倍",
895: "{0}回合内受到的所有类型伤害的1/{1}转化为自身体力",
911: "全属性+{0}，自身处于能力提升状态时强化效果翻倍",
912: "若对手处于能力下降则使对手随机{0}个技能的PP归零",
913: "消除对手回合类效果，消除成功则下回合自身造成的攻击伤害额外提升{0}%",
@@ -808,6 +828,36 @@ var effectInfoByID = map[int]string{
1692: "{0}%的概率造成伤害翻倍，终阶源盾处于激活状态时概率提升至{1}%",
1693: "{0}回合内每回合使用技能附加对手最大体力1/{1}的百分比伤害，对手免疫百分比伤害时额外附加{2}点真实伤害",
1694: "随机吸取对手{0}-{1}点体力，若自身处于能力提升状态则效果转变为{2}-{3}点",
926: "反转自身能力下降状态，反转成功则下{0}回合先制+{1}",
927: "{0}回合内每回合使用技能则出手流程结束后恢复自身最大体力的1/{1}，恢复体力时若自身体力低于最大体力的1/{2}则附加给对手等量百分比伤害",
928: "消除对手回合类效果，消除成功则己方免疫下{0}次受到的异常状态",
929: "反弹{0}倍的伤害给对手并使自身恢复等量体力",
930: "获得{0}点护盾，护盾消失时对对手造成{1}点固定伤害且有{2}%的概率使对手{3}",
931: "吸取对手能力提升状态，吸取成功则对手{0}技能PP值归零",
932: "先出手时附加自身攻击{0}%的百分比伤害",
933: "未击败对手则己方下{0}次攻击技能必定打出致命一击",
934: "击败对手则对手下只出场精灵{0}回合内先制-{1}",
935: "若自身体力高于对手则使对手{0}",
936: "{0}%令对手{1}，未触发则令对手{2}回合内使用的属性技能无效",
937: "命中后{0}%使对手{1}，未触发则对手下{2}回合先制-{3}",
938: "使对手全属性-{0}，先出手时效果翻倍",
939: "若后出手则附加自身最大体力1/{0}的百分比伤害并恢复等量体力",
940: "全属性+{0}，若对手处于封印属性技能状态则攻击额外+{1}",
941: "出手时有概率使对手{0}，概率等同于出手时自身当前体力百分比",
942: "消除对手回合类效果，消除成功则吸取对手最大体力的1/{0}",
943: "附加自身防御、特防总和{0}%的百分比伤害",
944: "{0}回合内对手使用攻击技能时受到自身防御、特防总和{1}%的百分比伤害",
945: "消除对手回合类效果，消除成功则恢复自身全部体力",
946: "全属性+{0}，若自身当前体力低于对手则强化效果翻倍",
947: "造成的伤害不足{0}则吸取对手最大体力的1/{1}",
948: "吸取对手能力提升状态，吸取成功则对手{0}",
949: "造成伤害不足{0}则恢复自身全部体力",
950: "消除对手回合类效果，消除成功则对手{0}回合内攻击技能MISS",
951: "反转对手能力提升状态，反转成功则己方免疫下{0}次受到的异常状态",
952: "全属性+{0},若对手处于能力下降状态则效果翻倍",
953: "{0}回合恢复最大体力的1/{1}，体力低于{2}%时先制+{3}",
954: "若当前体力低于对手则先制+1",
955: "反转自身能力下降状态，反转成功则吸取对手{0}点体力",
956: "未击败对手则下回合使用技能后附加{0}点固定伤害，遇到天敌时附加的固定伤害翻倍",
957: "使对手全属性-{0}，若对手处于{1}状态则自身额外全属性+{2}",
958: "若对手处于{0}状态则先制+{1}",
@@ -858,6 +908,16 @@ var effectInfoByID = map[int]string{
1003: "命中后{0}%使对手{1}，未触发则使对手全属性-{2}",
1004: "{0}回合内使用技能附加{1}点固定伤害，若自身体力高于对手则效果翻倍",
1005: "恢复自身最大体力的1/{0}并造成等量百分比伤害",
1057: "{0}回合内若自身能力提升状态消失，则消除对手回合类效果",
1058: "命中则{0}%概率使对手{1}，未触发则对手{2}回合内攻击技能无效",
1059: "牺牲自身全部体力，{0}%令对方进入{1}种控制类异常状态，令自身下只出场精灵{2}回合内攻击伤害提升{3}%且先制+{4}",
1060: "吸取对手能力提升状态，吸取成功则下{0}回合对手攻击技能无效",
1061: "反转对手能力提升状态，反转成功则自身附加相同的能力提升，反转失败则消除对手能力提升状态",
1062: "吸取对手能力提升状态，吸取成功则吸取对手最大体力的1/{0}",
1063: "对王·战联造成的伤害提高{0}%",
1064: "对大暗黑天长老造成的伤害提高{0}%",
1065: "{0}回合内每回合使用技能恢复自身最大体力的1/{1}并造成等量百分比伤害，恢复体力时若自身体力低于最大体力的1/{2}则恢复效果和百分比伤害翻倍",
1066: "造成的伤害低于{0}则附加{1}点固定伤害，若先出手则固定伤害提高{2}点",
}
func EffectInfo(id int) string {