feat: 新增战斗效果714-733

docs/effect-unimplemented-tasks/task-021-effects-714-718.md

@@ -1,35 +0,0 @@
-# Task 021: Effects 714-718
-
-## 目标
-
-- 补齐以下 5 个（或最后一组不足 5 个）当前判定未实现的 skill effect。
-- 实现位置优先放在 `logic/service/fight/effect/`。
-- 如 effect 需要展示说明，同步更新 `logic/service/fight/effect/effect_info_map.go`。
-- 完成后至少执行：`cd /workspace/logic && go test ./service/fight/effect`。
-
-## Effect 列表
-
-### Effect 714
-- `argsNum`: `1`
-- `info`: `使用技能时若对手处于能力提升状态，则先制+{0}，同时消除对手能力提升状态`
-
-### Effect 715
-- `argsNum`: `2`
-- `info`: `若下回合受到攻击，则对手随机{0}项能力值-{1}`
-
-### Effect 716
-- `argsNum`: `2`
-- `info`: `{0}回合内对手使用攻击技能，则使对手随机{1}个技能的PP值归零`
-
-### Effect 717
-- `argsNum`: `3`
-- `info`: `{0}回合内每回合使用技能吸取对手最大体力的1/{1}，恢复体力时若自身体力低于最大体力的1/{2}则恢复效果翻倍`
-
-### Effect 718
-- `argsNum`: `2`
-- `info`: `{0}回合内对手使用属性技能，则自身下{1}回合必定暴击`
-
-## 备注
-
-- 该清单按当前仓库静态注册结果生成；如果某个 effect 实际通过其他模块或运行时路径实现，需要先复核后再落代码。
-- 对 `201`、`445` 这类占位 effect，优先补核心逻辑或补充明确的不可实现说明。

docs/effect-unimplemented-tasks/task-022-effects-719-723.md

@@ -1,36 +0,0 @@
-# Task 022: Effects 719-723
-
-## 目标
-
-- 补齐以下 5 个（或最后一组不足 5 个）当前判定未实现的 skill effect。
-- 实现位置优先放在 `logic/service/fight/effect/`。
-- 如 effect 需要展示说明，同步更新 `logic/service/fight/effect/effect_info_map.go`。
-- 完成后至少执行：`cd /workspace/logic && go test ./service/fight/effect`。
-
-## Effect 列表
-
-### Effect 719
-- `argsNum`: `2`
-- `info`: `未击败对手则{0}%令对手{1}`
-- `param`: `1,1,1`
-
-### Effect 720
-- `argsNum`: `0`
-- `info`: `若先出手则当回合闪避对手的攻击技能`
-
-### Effect 721
-- `argsNum`: `1`
-- `info`: `后出手时使对手下{0}回合攻击技能MISS`
-
-### Effect 722
-- `argsNum`: `0`
-- `info`: `将自身相应的能力提升赋予给对手相应的能力下降`
-
-### Effect 723
-- `argsNum`: `2`
-- `info`: `后出手时令对手下{0}回合先制-{1}`
-
-## 备注
-
-- 该清单按当前仓库静态注册结果生成；如果某个 effect 实际通过其他模块或运行时路径实现，需要先复核后再落代码。
-- 对 `201`、`445` 这类占位 effect，优先补核心逻辑或补充明确的不可实现说明。

docs/effect-unimplemented-tasks/task-024-effects-729-733.md

@@ -1,39 +0,0 @@
-# Task 024: Effects 729-733
-
-## 目标
-
-- 补齐以下 5 个（或最后一组不足 5 个）当前判定未实现的 skill effect。
-- 实现位置优先放在 `logic/service/fight/effect/`。
-- 如 effect 需要展示说明，同步更新 `logic/service/fight/effect/effect_info_map.go`。
-- 完成后至少执行：`cd /workspace/logic && go test ./service/fight/effect`。
-
-## Effect 列表
-
-### Effect 729
-- `argsNum`: `4`
-- `info`: `{0}回合内若造成伤害大于{1}则{2}%概率使对手{3}`
-- `param`: `1,3,3`
-
-### Effect 730
-- `argsNum`: `7`
-- `info`: `下回合起，{0}回合内每回合{1}`
-- `param`: `0,1,0`
-
-### Effect 731
-- `argsNum`: `1`
-- `info`: `本回合打出致命一击则下{0}回合其它攻击技能必定致命一击`
-
-### Effect 732
-- `argsNum`: `6`
-- `info`: `本回合若没有打出致命一击则{0}`
-- `param`: `0,0,0`
-
-### Effect 733
-- `argsNum`: `1`
-- `info`: `反转自身能力下降状态，反转成功则对手{0}`
-- `param`: `1,0,0`
-
-## 备注
-
-- 该清单按当前仓库静态注册结果生成；如果某个 effect 实际通过其他模块或运行时路径实现，需要先复核后再落代码。
-- 对 `201`、`445` 这类占位 effect，优先补核心逻辑或补充明确的不可实现说明。

logic/service/fight/effect/714_718.go

@@ -0,0 +1,182 @@
+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"
+)
+
+// Effect 714: 使用技能时若对手处于能力提升状态，则先制+{0}，同时消除对手能力提升状态
+type Effect714 struct {
+	node.EffectNode
+	armed bool
+}
+
+func (e *Effect714) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
+	if !e.Ctx().Opp.HasPropADD() {
+		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()[0].IntPart())
+	e.armed = true
+	return true
+}
+
+func (e *Effect714) OnSkill() bool {
+	if !e.armed {
+		return true
+	}
+	for i, v := range e.Ctx().Opp.Prop[:] {
+		if v > 0 {
+			e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), 0)
+		}
+	}
+	return true
+}
+
+// Effect 715: 若下回合受到攻击，则对手随机{0}项能力值-{1}
+type Effect715 struct {
+	node.EffectNode
+}
+
+func (e *Effect715) OnSkill() bool {
+	effect := e.Ctx().Our.InitEffect(input.EffectType.Sub, 715, e.SideEffectArgs...)
+	if effect != nil {
+		e.Ctx().Our.AddEffect(e.Ctx().Our, effect)
+	}
+	return true
+}
+
+type Effect715Sub struct {
+	FixedDuration1Base
+	triggered bool
+}
+
+func (e *Effect715Sub) Skill_Use_ex() bool {
+	if e.triggered {
+		return true
+	}
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS {
+		return true
+	}
+
+	count := int(e.Args()[0].IntPart())
+	level := int8(e.Args()[1].IntPart())
+	if count <= 0 || level <= 0 {
+		e.Alive(false)
+		return true
+	}
+
+	indexes := grand.Perm(len(e.Ctx().Opp.Prop))
+	if count > len(indexes) {
+		count = len(indexes)
+	}
+	for _, idx := range indexes[:count] {
+		e.Ctx().Opp.SetProp(e.Ctx().Our, int8(idx), -level)
+	}
+	e.triggered = true
+	e.Alive(false)
+	return true
+}
+
+// Effect 716: {0}回合内对手使用攻击技能，则使对手随机{1}个技能的PP值归零
+type Effect716 struct {
+	node.EffectNode
+}
+
+func (e *Effect716) OnSkill() bool {
+	addSubEffect(e.Ctx().Our, e.Ctx().Opp, &e.EffectNode, &Effect716Sub{}, -1)
+	return true
+}
+
+type Effect716Sub struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect716Sub) Skill_Use() bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS {
+		return true
+	}
+
+	zeroRandomSkillPP(e.Ctx().Our, int(e.Args()[1].IntPart()))
+	return true
+}
+
+// Effect 717: {0}回合内每回合使用技能吸取对手最大体力的1/{1}，恢复体力时若自身体力低于最大体力的1/{2}则恢复效果翻倍
+type Effect717 struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect717) Skill_Use() bool {
+	if e.Ctx().SkillEntity == nil {
+		return true
+	}
+	drain := e.Ctx().Opp.CurrentPet.GetMaxHP().Div(e.Args()[1])
+	if drain.IntPart() <= 0 {
+		return true
+	}
+
+	e.Ctx().Opp.Damage(e.Ctx().Our, &info.DamageZone{
+		Type:   info.DamageType.Percent,
+		Damage: drain,
+	})
+
+	heal := drain
+	if e.Args()[2].IntPart() > 0 {
+		threshold := e.Ctx().Our.CurrentPet.GetMaxHP().Div(e.Args()[2])
+		if e.Ctx().Our.CurrentPet.GetHP().Cmp(threshold) < 0 {
+			heal = heal.Mul(alpacadecimal.NewFromInt(2))
+		}
+	}
+	e.Ctx().Our.Heal(e.Ctx().Our, &action.SelectSkillAction{}, heal)
+	return true
+}
+
+// Effect 718: {0}回合内对手使用属性技能，则自身下{1}回合必定暴击
+type Effect718 struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect718) SkillHit_ex() bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() != info.Category.STATUS {
+		return true
+	}
+	addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect718Sub{}, -1)
+	return true
+}
+
+type Effect718Sub struct {
+	RoundEffectArg1Base
+}
+
+func (e *Effect718Sub) ActionStart(a, b *action.SelectSkillAction) bool {
+	if e.Ctx().SkillEntity == nil {
+		return true
+	}
+	if e.Ctx().SkillEntity.Category() == info.Category.STATUS {
+		return true
+	}
+	e.Ctx().SkillEntity.XML.CritRate = 16
+	return true
+}
+
+func init() {
+	input.InitEffect(input.EffectType.Skill, 714, &Effect714{})
+	input.InitEffect(input.EffectType.Skill, 715, &Effect715{})
+	input.InitEffect(input.EffectType.Sub, 715, &Effect715Sub{})
+	input.InitEffect(input.EffectType.Skill, 716, &Effect716{})
+	input.InitEffect(input.EffectType.Skill, 717, &Effect717{})
+	input.InitEffect(input.EffectType.Skill, 718, &Effect718{})
+}

logic/service/fight/effect/719_723.go

@@ -0,0 +1,136 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/action"
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// Effect 719: 未击败对手则{0}%令对手{1}
+type Effect719 struct {
+	node.EffectNode
+}
+
+func (e *Effect719) Skill_Use() bool {
+	if len(e.Args()) < 2 || e.Ctx().Opp.CurrentPet.Info.Hp <= 0 {
+		return true
+	}
+
+	success, _, _ := e.Input.Player.Roll(int(e.Args()[0].IntPart()), 100)
+	if !success {
+		return true
+	}
+
+	statusEffect := e.Ctx().Our.InitEffect(input.EffectType.Status, int(e.Args()[1].IntPart()))
+	if statusEffect != nil {
+		e.Ctx().Opp.AddEffect(e.Ctx().Our, statusEffect)
+	}
+	return true
+}
+
+// Effect 720: 若先出手则当回合闪避对手的攻击技能
+type Effect720 struct {
+	node.EffectNode
+}
+
+func (e *Effect720) Skill_Use() bool {
+	if !e.IsFirst() {
+		return true
+	}
+
+	addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect720Sub{}, -1)
+	return true
+}
+
+type Effect720Sub struct {
+	FixedDuration1Base
+}
+
+func (e *Effect720Sub) SkillHit_ex() bool {
+	if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
+		return true
+	}
+
+	e.Ctx().SkillEntity.SetMiss()
+	return true
+}
+
+// Effect 721: 后出手时使对手下{0}回合攻击技能MISS
+type Effect721 struct {
+	node.EffectNode
+}
+
+func (e *Effect721) Skill_Use() bool {
+	if e.IsFirst() {
+		return true
+	}
+
+	addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect721Sub{}, -1)
+	return true
+}
+
+type Effect721Sub struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect721Sub) SkillHit_ex() bool {
+	if e.Ctx().SkillEntity == nil || e.Ctx().SkillEntity.Category() == info.Category.STATUS {
+		return true
+	}
+
+	e.Ctx().SkillEntity.SetMiss()
+	return true
+}
+
+// Effect 722: 将自身相应的能力提升赋予给对手相应的能力下降
+type Effect722 struct {
+	node.EffectNode
+}
+
+func (e *Effect722) OnSkill() bool {
+	for i, v := range e.Ctx().Our.Prop[:] {
+		if v <= 0 {
+			continue
+		}
+		e.Ctx().Opp.SetProp(e.Ctx().Our, int8(i), -v)
+	}
+	return true
+}
+
+// Effect 723: 后出手时令对手下{0}回合先制-{1}
+type Effect723 struct {
+	node.EffectNode
+}
+
+func (e *Effect723) Skill_Use() bool {
+	if e.IsFirst() {
+		return true
+	}
+
+	addSubEffect(e.Ctx().Our, e.Ctx().Opp, &e.EffectNode, &Effect723Sub{}, -1)
+	return true
+}
+
+type Effect723Sub struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect723Sub) ComparePre(fattack, sattack *action.SelectSkillAction) bool {
+	priorityDown := int(e.Args()[1].IntPart())
+	current := actionByPlayer(fattack, sattack, e.Ctx().Our.UserID)
+	if current == nil || current.SkillEntity == nil {
+		return true
+	}
+
+	current.SkillEntity.XML.Priority -= priorityDown
+	return true
+}
+
+func init() {
+	input.InitEffect(input.EffectType.Skill, 719, &Effect719{})
+	input.InitEffect(input.EffectType.Skill, 720, &Effect720{})
+	input.InitEffect(input.EffectType.Skill, 721, &Effect721{})
+	input.InitEffect(input.EffectType.Skill, 722, &Effect722{})
+	input.InitEffect(input.EffectType.Skill, 723, &Effect723{})
+}

logic/service/fight/effect/729_733.go

@@ -0,0 +1,162 @@
+package effect
+
+import (
+	"blazing/logic/service/fight/action"
+	"blazing/logic/service/fight/info"
+	"blazing/logic/service/fight/input"
+	"blazing/logic/service/fight/node"
+)
+
+// Effect 729: {0}回合内若造成伤害大于{1}则{2}%概率使对手{3}
+type Effect729 struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect729) Skill_Use() bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS || len(e.Args()) < 4 {
+		return true
+	}
+	if e.Ctx().Opp.CurrentPet.Info.Hp <= 0 {
+		return true
+	}
+	if e.Ctx().Our.SumDamage.Cmp(e.Args()[1]) <= 0 {
+		return true
+	}
+
+	success, _, _ := e.Input.Player.Roll(int(e.Args()[2].IntPart()), 100)
+	if !success {
+		return true
+	}
+
+	statusEffect := e.Ctx().Our.InitEffect(input.EffectType.Status, int(e.Args()[3].IntPart()))
+	if statusEffect != nil {
+		e.Ctx().Opp.AddEffect(e.Ctx().Our, statusEffect)
+	}
+	return true
+}
+
+// Effect 730: 下回合起，{0}回合内每回合{1}
+type Effect730 struct {
+	node.EffectNode
+}
+
+func (e *Effect730) Skill_Use() bool {
+	addSubEffect(e.Ctx().Our, e.Ctx().Our, &e.EffectNode, &Effect730Sub{}, -1)
+	return true
+}
+
+type Effect730Sub struct {
+	RoundEffectArg0Base
+}
+
+func (e *Effect730Sub) ActionStart(a, b *action.SelectSkillAction) bool {
+	for i := 1; i < len(e.Args()) && i <= 6; i++ {
+		level := int8(e.Args()[i].IntPart())
+		if level == 0 {
+			continue
+		}
+		e.Ctx().Our.SetProp(e.Ctx().Our, int8(i-1), level)
+	}
+	return true
+}
+
+// Effect 731: 本回合打出致命一击则下{0}回合其它攻击技能必定致命一击
+type Effect731 struct {
+	node.EffectNode
+}
+
+func (e *Effect731) Skill_Use() bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS || skill.AttackTime == 0 || skill.Crit == 0 || len(e.Args()) == 0 {
+		return true
+	}
+
+	sub := e.Ctx().Our.InitEffect(input.EffectType.Sub, 731, int(e.Args()[0].IntPart()), skill.XML.ID)
+	if sub != nil {
+		e.Ctx().Our.AddEffect(e.Ctx().Our, sub)
+	}
+	return true
+}
+
+type Effect731Sub struct {
+	RoundEffectArg0Base
+	triggerSkillID int
+}
+
+func (e *Effect731Sub) SetArgs(t *input.Input, a ...int) {
+	setArgsWithDuration0(&e.EffectNode, t, a...)
+	if len(a) > 1 {
+		e.triggerSkillID = a[1]
+	}
+}
+
+func (e *Effect731Sub) ActionStart(a, b *action.SelectSkillAction) bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS || skill.AttackTime == 0 {
+		return true
+	}
+	if skill.XML.ID == e.triggerSkillID {
+		return true
+	}
+
+	skill.XML.CritRate = 16
+	return true
+}
+
+// Effect 732: 本回合若没有打出致命一击则{0}
+type Effect732 struct {
+	node.EffectNode
+}
+
+func (e *Effect732) Skill_Use() bool {
+	skill := e.Ctx().SkillEntity
+	if skill == nil || skill.Category() == info.Category.STATUS || skill.AttackTime == 0 || skill.Crit != 0 {
+		return true
+	}
+
+	for i := 0; i < len(e.Args()) && i < 6; i++ {
+		level := int8(e.Args()[i].IntPart())
+		if level == 0 {
+			continue
+		}
+		e.Ctx().Our.SetProp(e.Ctx().Our, int8(i), level)
+	}
+	return true
+}
+
+// Effect 733: 反转自身能力下降状态，反转成功则对手{0}
+type Effect733 struct {
+	node.EffectNode
+}
+
+func (e *Effect733) OnSkill() bool {
+	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 || len(e.Args()) == 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
+}
+
+func init() {
+	input.InitEffect(input.EffectType.Skill, 729, &Effect729{})
+	input.InitEffect(input.EffectType.Skill, 730, &Effect730{})
+	input.InitEffect(input.EffectType.Sub, 730, &Effect730Sub{})
+	input.InitEffect(input.EffectType.Skill, 731, &Effect731{})
+	input.InitEffect(input.EffectType.Sub, 731, &Effect731Sub{})
+	input.InitEffect(input.EffectType.Skill, 732, &Effect732{})
+	input.InitEffect(input.EffectType.Skill, 733, &Effect733{})
+}

logic/service/fight/effect/effect_info_map.go

@@ -431,11 +431,21 @@ var effectInfoByID = map[int]string{
 	711:  "下{0}回合若自身能力提升状态被消除则必定致命一击",
 	712:  "{0}回合内将对手的{1}能力降为0点",
 	713:  "附加自身能力提升等级总和X{0}的固定伤害",
+	719:  "未击败对手则{0}%令对手{1}",
+	720:  "若先出手则当回合闪避对手的攻击技能",
+	721:  "后出手时使对手下{0}回合攻击技能MISS",
+	722:  "将自身相应的能力提升赋予给对手相应的能力下降",
+	723:  "后出手时令对手下{0}回合先制-{1}",
 	724:  "{0}回合内受到攻击{1}%恢复1/{2}体力",
 	725:  "{0}回合内每回合有{1}%的概率降低对手最大体力的1/{2}",
 	726:  "下{0}回合若对手先出手，则令对手当回合使用的攻击技能无效",
 	727:  "后出手时将自身能力等级返回至上一回合结束时",
 	728:  "自身处于能力提升状态时，回合结束时直接减少对手1/{0}最大体力",
+	729:  "{0}回合内若造成伤害大于{1}则{2}%概率使对手{3}",
+	730:  "下回合起，{0}回合内每回合{1}",
+	731:  "本回合打出致命一击则下{0}回合其它攻击技能必定致命一击",
+	732:  "本回合若没有打出致命一击则{0}",
+	733:  "反转自身能力下降状态，反转成功则对手{0}",
 	841:  "使对手和自身同时降低1/{0}最大体力",
 	842:  "若自身处于能力提升状态则造成的攻击伤害额外提升{0}%",
 	843:  "下{0}回合令自身所有技能先制+{1}",